Skip to content

Commit 7cea13d

Browse files
chetto1983claude
andcommitted
Wire the same-SHA replay through one atomic reservation
ReserveCandidateVersion had zero production callers. The real ingress created and catalogued in four statements, so a second upload of identical bytes wrote a fresh raw storage object and then attached it to the version already on record, and a repeat ingest redid Docling, embedding and projection work that version already owned -- conversions that run up to 900s. ReservePipelineCandidateVersion now owns the raw object, the version and the asset binding in ONE statement, and PostgresCatalogStore.RecordAssetVersion routes through it. The object INSERT names a version that does not exist yet because both foreign keys are DEFERRABLE INITIALLY DEFERRED (0093:378-394); every hand-off travels through a RETURNING projection, since data-modifying CTEs cannot observe each other's effects on the underlying tables. The statement projects replay_is_active -- ready AND activated AND the document's active version -- surfaced as CandidateVersion.ReplayedActive and DocumentVersionRecord.ReplayedActive. DocumentVersionRecord deliberately gets NO bare Replayed: identity of bytes without liveness would let a caller short-circuit on a still-processing version and mark an unindexed document searchable. document_processor short-circuits ONLY on ReplayedActive, omitting pipeline_activation_job_id so the queue worker still settles the job; every other case, replay included, falls through to Pipeline.Run unchanged, so this is a strict improvement rather than a trade. A replay's duplicate bytes are ledgered under a non-raw kind bound to the same version. That row is not decoration: SoftDeleteDocument sweeps storage_objects by document_id with no kind filter, and FinalizeDocumentDelete refuses to finish while any live row carries that document_id -- without it the duplicate asset's bytes would outlive their document. CreateStorageObject is kept for that reason; UpdateStorageObjectVersion, LinkAssetDocumentVersion and the duplicate deterministicDocumentVersionID are deleted as dead. Verified on a disposable database with all 68 migrations, driving the rendered live query text: fresh insert, replay onto a non-activated version, idempotent re-drive that does not demote the raw object, replay onto an activated version, and a same-key different-sha attempt that returns zero rows. End state one live version, one live raw object, duplicates reaped by the delete sweep, and the version still owned by the FIRST asset. T1 was proven to fail against the old body by executing it: two live raw objects where it asserts one. The sqlc.arg(id)::uuid cast in `binding` is load-bearing, not cosmetic -- sqlc's static analyzer cannot name a select-list expression wrapping a named parameter (sqlc-dev/sqlc#1646, #3991) and codegen fails for the whole package without it. Co-Authored-By: Claude Opus 5 (1M context) <[email protected]> Claude-Session: https://claude.ai/code/session_01KzRkrbwUqo2oWsryXKc34F
1 parent afd5a05 commit 7cea13d

19 files changed

Lines changed: 912 additions & 370 deletions

‎.planning/handoffs/document-pipeline-2026-08-05.md‎

Lines changed: 136 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -6,17 +6,21 @@ the next session does not re-derive them.
66

77
## State
88

9-
**The worktree is clean.** Three commits landed, every lefthook gate green
9+
**The worktree is clean.** Commits landed, every lefthook gate green
1010
(gofmt, file-size, vet, lint):
1111

1212
```
13+
<F3> Wire the same-SHA replay through one atomic reservation
14+
afd5a05e6 Record the document pipeline checkpoint
1315
a974cfb22 Give the nightly Postgres backup a clock (operator's work, own commit)
1416
8d2701bd1 Converge the industrial document pipeline (163 files)
1517
fe20c2c72 Rule passage erasure physical, not tombstoned (PRD amendment #117)
1618
```
1719

1820
Nothing has been pushed. `origin/master` is still at `975b7d521`.
1921

22+
**All six audit findings are now closed.** F3 shipped 2026-08-05; see below.
23+
2024
## What is done
2125

2226
Five of the six audit findings are closed, each with a test that fails without
@@ -96,68 +100,137 @@ silently reuses vectors from a different model.
96100
trips `unused` no matter what you stage. This is why the operator's
97101
nightly-backup work had to be committed as its own unit.
98102

103+
## F3 — same-SHA replay wiring — DONE (2026-08-05)
104+
105+
`ReservePipelineCandidateVersion` now owns the raw storage object, the version and
106+
the asset binding in ONE statement, and `PostgresCatalogStore.RecordAssetVersion`
107+
routes through it. The four-statement body is gone.
108+
109+
Shipped shape:
110+
111+
- **`bound_asset`** validates the INCOMING asset (live, owned) for both legs.
112+
- **`binding`** decides ONCE — which version, `raw` vs `temp`, which generation —
113+
because sqlc cannot resolve a computed CTE column referenced downstream.
114+
- **`asset_object`** INSERTs the ledger row naming a version that does not exist
115+
yet. `ON CONFLICT (bucket, object_key)` deliberately does NOT rewrite `kind`:
116+
demoting a version's own raw object to `temp` would break the resolution
117+
`existing` depends on. Its guard is stricter than `CreateStorageObject`'s —
118+
other bytes under that key, or a key already scheduled for deletion, return no
119+
row and the statement resolves to `ErrPipelineCandidateRejected`.
120+
- **`existing`** projects `replay_is_active` using `IS NOT DISTINCT FROM`, not
121+
`=`: under `=` a document with no active version yields SQL NULL, and a NULL
122+
decoding to Go false is a guarantee resting on luck. The conjunction is total.
123+
- **`linked_asset`** binds `bound_asset.id` (the incoming asset, not
124+
`selected.asset_id`) and uses `GREATEST(...)` so a replay never walks an
125+
asset's generation backwards.
126+
- **`inserted`** carries `ON CONFLICT DO NOTHING`: reaching a conflict means a row
127+
holds these bytes while `existing` refused it (its asset or raw object is no
128+
longer live) — incoherent, so it becomes the statement's own empty result rather
129+
than a raw 23505 the caller retries to dead-letter.
130+
131+
Surfaced as `CandidateVersion.ReplayedActive` and
132+
`DocumentVersionRecord.ReplayedActive`. `DocumentVersionRecord` deliberately has
133+
NO bare `Replayed`. `internal/assets/document_processor.go` short-circuits only on
134+
`ReplayedActive` (`replayedAssetResult`), which omits `pipeline_activation_job_id`
135+
so the queue worker still settles the job; every other case falls through to
136+
`Pipeline.Run` unchanged.
137+
138+
**Deleted as dead:** `UpdateStorageObjectVersion`, `LinkAssetDocumentVersion`,
139+
`deterministicDocumentVersionID`. **`CreateStorageObject` was KEPT** per review,
140+
and is now caller-less — the duplicate's bytes get their owner from the statement's
141+
non-raw ledger row instead. That tension is open for the operator to settle.
142+
143+
### Proven, not argued
144+
145+
Probe against a disposable DB (68 migrations), driving the RENDERED live query
146+
text — both probe DBs dropped, live `aura` untouched:
147+
148+
| leg | result |
149+
|---|---|
150+
| fresh insert | `replayed=f replay_is_active=f`; object written naming a not-yet-existing version |
151+
| 2nd asset, new key, same SHA, not activated | `replayed=t replay_is_active=f` |
152+
| re-drive same asset+key | idempotent; raw object NOT demoted to `temp` |
153+
| 2nd asset after activation | `replayed=t replay_is_active=t` |
154+
| same key, different SHA | **0 rows** → `ErrPipelineCandidateRejected` |
155+
156+
End state: 1 live version · 1 live `raw` · 2 `temp` duplicates all carrying
157+
`document_id` and all swept to `delete_pending` by `SoftDeleteDocument` ·
158+
`version.asset_id` still the FIRST asset.
159+
160+
**T1 was proven to fail against the pre-change code by executing it**, not by
161+
reasoning: the old four-statement body run twice yields `live raw objects=2` where
162+
T1 asserts 1. The version already de-duplicated via `CreateDocumentVersion`'s
163+
`ON CONFLICT`; what did not was the OBJECT — a fresh raw row rebound to the old
164+
version, exactly the finding. T2/T3 could not compile before (`ReplayedActive` did
165+
not exist). Honest caveat: the `internal/assets` **false** case passes before AND
166+
after — it constrains the wrong implementation (short-circuiting on `Replayed`),
167+
not the old one.
168+
169+
Tests: `internal/documents/catalog_store_replay_integration_test.go` (T1/T2/T3,
170+
`db_integration`, disposable pool) and
171+
`internal/assets/document_processor_replay_test.go` (daemon-free).
172+
173+
### sqlc gotcha, cost ~40 minutes — read before editing this query
174+
175+
sqlc's STATIC analyzer cannot name a SELECT-list expression wrapping a named
176+
parameter (`*ast.ResTarget has nil name` — sqlc-dev/sqlc#1646, #3991) and cannot
177+
resolve a virtual CTE column referenced downstream (#3555, still open). The
178+
documented no-managed-DB fix is an explicit cast: `sqlc.arg(id)::uuid`. That cast
179+
in `binding` is load-bearing — removing it fails the whole package's codegen.
180+
Enabling the database-backed analyzer would also fix it but requires a reachable
181+
server at `sqlc generate` time (config `database.managed` + `servers`), which CI
182+
does not have.
183+
99184
## Open work, in order
100185

101-
### 1. F3 — same-SHA replay wiring (the only remaining finding)
102-
103-
`ReserveCandidateVersion` still has **zero production callers**. The real ingress
104-
can attach a newly written raw object to an old immutable version, and a repeat
105-
ingest redoes Docling + embed + project work.
106-
107-
Its one unproven assumption is now **proven**: a single statement can insert a
108-
storage object referencing a not-yet-existing version and the version referencing
109-
that object, because both FKs are `DEFERRABLE INITIALLY DEFERRED` (0093:378-394).
110-
Verified on a disposable database (`aura_f3_probe`, 68 migrations): committed,
111-
`versions=1 objects=1`. Probe DB dropped; live `aura` untouched.
112-
113-
The corrected design (first pass was rejected on review):
114-
115-
1. rewrite `ReservePipelineCandidateVersion` so one statement owns the raw
116-
object, the version and the asset binding, projecting a `replay_is_active`
117-
boolean computed from `status='ready' AND activated_at IS NOT NULL AND
118-
document.active_version_id = existing.id`
119-
2. surface it as `CandidateVersion.ReplayedActive` / `DocumentVersionRecord.ReplayedActive`.
120-
**Do NOT add a bare `Replayed` to `DocumentVersionRecord`** — a caller that can
121-
see identity without liveness will short-circuit on a still-`processing`
122-
version and mark an unindexed document searchable.
123-
3. route the real recorder through it; delete the four-statement body it replaces
124-
4. `internal/assets/document_processor.go`: short-circuit **only** on
125-
`ReplayedActive`; every other case falls through to the existing
126-
`p.Pipeline.Run`, so `beginStage` resumes from the ledger as it does today.
127-
The unit test needs both cases, and the not-live case must assert `Run` WAS called.
128-
5. `linked_asset` binds `sqlc.arg(asset_id)`; use
129-
`GREATEST(asset.pipeline_generation, selected.pipeline_generation)` — never lower it
130-
6. **Do not delete `CreateStorageObject`** until the duplicate asset's bytes have
131-
an owner, or `SoftDeleteDocument`'s object sweep stops reaping them. Preferred:
132-
register the duplicate's object as an additional non-raw ledger row bound to
133-
the same version.
134-
135-
Tests (all `db_integration`, all via `pipelineDisposablePool`, whose
136-
`pipelineEnvOrSkip` already `t.Fatal`s under `$CI`):
137-
- **T1** drive the production `PostgresCatalogStore.RecordAssetVersion` twice —
138-
two assets, same SHA, different object keys. Assert exactly 1 live version,
139-
exactly 1 live `kind='raw'` object, `asset_id` still A1, A2 bound to V1.
140-
- **T2** replay onto a still-`processing` version → `ReplayedActive == false`,
141-
and a daemon-free `internal/assets` test asserting `Pipeline.Run` ran.
142-
- **T3** replay onto an activated version → `ReplayedActive == true`, `Run` not called.
143-
144-
**Split out of F3, own commit:** the repeat-source `23505`. It needs 0093 amended
145-
— replace `ADD CONSTRAINT documents_source_unique UNIQUE (...)` (:306) with a
146-
partial unique index `WHERE deleted_at IS NULL`, mirroring its sibling at :308,
147-
and mirror the DROP in the `.down.sql`. Only then may `CreateDocument` take an
148-
`ON CONFLICT ... DO UPDATE`. Without the partial index, delete-then-reingest
149-
cannot create a fresh document.
150-
151-
### 2. Production E2E (Amendment #115/#116)
186+
### 1. Document status vocabularies never followed migration 0093 — NEW, blocking
187+
188+
The production recorder cannot insert a version at all. Probed on a disposable DB:
189+
190+
- `document_versions_status_check` admits `uploaded, hash_calculated, stored,
191+
queued, parsing, parsed, chunking, chunked, embedding, embedded, indexed, ready,
192+
failed, deleting, deleted, archived` — **not `processing`**, which
193+
`cmd/aura/document_version_recorder.go:66` hard-codes and
194+
`catalog_service.go:239` defaults to. `ERROR: violates check constraint`.
195+
- `documents_status_check` admits `accepted, stored, queued, converting, chunking,
196+
embedding, projecting, ready, failed, dead_letter, deleting, deleted` — **not
197+
`processing`** (`document_version_recorder.go:65`, `catalog_service.go:224`,
198+
`documents/service.go:133`) and **not `draft`** (`catalog_service.go:126,166`).
199+
- `web/src/documents/documentApi.ts:2-10` mirrors the SAME stale vocabulary:
200+
it lists `draft`/`processing`/`archived`, which the DB can no longer produce,
201+
and lacks `accepted`/`stored`/`converting`/`chunking`/`projecting`/`dead_letter`,
202+
which it can.
203+
- Corroborating live evidence: `aura` has 3 `ready` documents but only ONE
204+
`document_versions` row.
205+
206+
0093:279-288 already states the project's own mapping — `draft→accepted`,
207+
`processing→converting`, `archived→failed`. `catalog_service_test.go:168` pins
208+
`"processing"`, so that test is broken too and its rewrite needs justification in
209+
the commit message. **This is wire-visible; it is its own commit.** F3 does not
210+
depend on it — F3 is a strict improvement either way — which is why the F3 tests
211+
pass explicitly-legal statuses (the precedent `card_ingest_integration_test.go`
212+
already sets) rather than masking the defect.
213+
214+
### 2. Repeat-source `23505` (was: split out of F3)
215+
216+
Needs 0093 amended — replace `ADD CONSTRAINT documents_source_unique UNIQUE (...)`
217+
(:306) with a partial unique index `WHERE deleted_at IS NULL`, mirroring its
218+
sibling at :308, and mirror the DROP in the `.down.sql`. Only then may
219+
`CreateDocument` take an `ON CONFLICT ... DO UPDATE`. Without the partial index,
220+
delete-then-reingest cannot create a fresh document.
221+
222+
### 3. Production E2E (Amendment #115/#116)
152223

153224
Corpus verified intact — exactly the 7 authorized files under
154225
`D:\tmp\aura-document-pipeline-references\document_ingestion\baseline-corpus`,
155226
`Clienti.xlsx` present for the 699/TORINO ground truth.
156227

157-
**Run it after F3, not before**: F3 changes the version and activation counts the
158-
E2E asserts, so a green run now would be misread either way.
228+
F3 has landed, so the version and activation counts the E2E asserts are now
229+
stable. **It still cannot pass until item 1 is fixed**: the recorder's own status
230+
defaults are rejected by both CHECK constraints, so the real ingress never gets as
231+
far as producing a version.
159232

160-
### 3. Before any push
233+
### 4. Before any push
161234

162235
- `make quality-full` (needs the stack up)
163236
- combined coverage ≥85% over the full tag matrix; mutation ≥70% on the
@@ -181,6 +254,14 @@ E2E asserts, so a green run now would be misread either way.
181254
(`UpsertDocumentPipelineStage`, `ClaimDocumentPipelineStage`,
182255
`CompleteDocumentPipelineStage`, `HeartbeatDocumentPipelineStage`,
183256
`UpdateDocumentPipelineStageStatus`) — zero non-generated callers.
257+
- `CreateStorageObject` is now caller-less. It was kept on review instruction; the
258+
duplicate asset's bytes get their owner from the reservation's non-raw ledger
259+
row instead. Delete it or give it a caller — the deadcode gate does NOT catch
260+
this (sqlc methods satisfy the used `Querier` interface, so they read as
261+
reachable), which is also why the three below survived unnoticed.
262+
- `MarkStorageObjectDeletePending`, `MarkStorageObjectDeleted` and
263+
`ListDocumentStorageObjects` have zero callers anywhere, tests included —
264+
pre-existing, untouched by F3.
184265
- `cmd/aura/document_pipeline_wiring.go:101-129` duplicates the
185266
tombstone→delete→verify sequence in `delete_durable_worker.go:102-133`.
186267
- `StorageOrphanService.DryRun` detects orphan objects only; there is no

‎internal/assets/document_processor.go‎

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -87,6 +87,9 @@ func (p *DocumentProcessor) ProcessAsset(ctx context.Context, asset Asset) (Resu
8787
if err != nil {
8888
return Result{}, err
8989
}
90+
if record.ReplayedActive {
91+
return replayedAssetResult(asset, record), nil
92+
}
9093
published, err := p.Pipeline.Run(ctx, documents.PipelineRunRequest{
9194
Record: record, AssetID: asset.ID, JobID: claim.ID, WorkerID: claim.LockedBy,
9295
LeaseGeneration: claim.LeaseGeneration, Title: record.Document.Title,
@@ -110,6 +113,34 @@ func (p *DocumentProcessor) ProcessAsset(ctx context.Context, asset Asset) (Resu
110113
}, nil
111114
}
112115

116+
// replayedAssetResult settles an upload whose bytes are ALREADY the document's published
117+
// version: the passages, embeddings and projections behind them exist, so re-running the
118+
// pipeline would spend a Docling conversion — up to fifteen minutes — to arrive back here.
119+
//
120+
// Only ReplayedActive earns this. Every other outcome, a replay onto a version still
121+
// processing included, falls through to Pipeline.Run, whose beginStage resumes from the
122+
// stage ledger exactly as it does on a first upload.
123+
//
124+
// It deliberately omits pipeline_activation_job_id. That key is the ingestion handler's
125+
// signal that the activation statement already settled the job (asset_processing_handler.go);
126+
// nothing settled it here, so the key's absence is what lets the queue worker close the job
127+
// itself instead of leaving it leased until it dead-letters.
128+
func replayedAssetResult(asset Asset, record documents.DocumentVersionRecord) Result {
129+
return Result{
130+
Status: StatusSearchable,
131+
DocumentID: record.Document.SearchDocumentID,
132+
Summary: fmt.Sprintf(
133+
"%s was already indexed; reused the active version without reprocessing.",
134+
asset.FileName,
135+
),
136+
Metadata: map[string]any{
137+
"document_version_id": record.Version.ID,
138+
"pipeline_generation": record.Version.PipelineGeneration,
139+
"replayed_active": true,
140+
},
141+
}
142+
}
143+
113144
func firstNonBlank(values ...string) string {
114145
for _, value := range values {
115146
if value != "" {
Lines changed: 114 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,114 @@
1+
// The replay short-circuit in DocumentProcessor.ProcessAsset, exercised without a database
2+
// or a container: both cases turn on one boolean the recorder returns.
3+
//
4+
// The pair matters more than either test alone. Skipping the pipeline is only safe when the
5+
// replayed version is the document's PUBLISHED one; skipping on mere identity of bytes would
6+
// mark a document searchable while a still-processing version has nothing indexed behind it.
7+
// So one test proves the skip happens, and the other proves it does NOT happen anywhere else.
8+
9+
package assets
10+
11+
import (
12+
"context"
13+
"strings"
14+
"testing"
15+
16+
"github.com/chetto1983/aura/internal/documents"
17+
"github.com/chetto1983/aura/internal/objectstore"
18+
)
19+
20+
func TestDocumentProcessorSkipsPipelineOnlyForActiveReplay(t *testing.T) {
21+
tests := []struct {
22+
name string
23+
replayedActive bool
24+
wantRuns int
25+
wantSummary string
26+
}{
27+
{
28+
name: "replay onto a version that is not the published one still runs",
29+
replayedActive: false,
30+
wantRuns: 1,
31+
wantSummary: "3 verified passages",
32+
},
33+
{
34+
name: "replay onto the published version skips the pipeline",
35+
replayedActive: true,
36+
wantRuns: 0,
37+
wantSummary: "already indexed",
38+
},
39+
}
40+
for _, test := range tests {
41+
t.Run(test.name, func(t *testing.T) {
42+
pipeline, result := runReplayProcessor(t, test.replayedActive)
43+
if pipeline.calls != test.wantRuns {
44+
t.Fatalf("Pipeline.Run calls = %d, want %d", pipeline.calls, test.wantRuns)
45+
}
46+
if result.Status != StatusSearchable || result.DocumentID != "doc-1" {
47+
t.Fatalf("result = %+v, want searchable doc-1", result)
48+
}
49+
if !strings.Contains(result.Summary, test.wantSummary) {
50+
t.Fatalf("Summary = %q, want it to mention %q", result.Summary, test.wantSummary)
51+
}
52+
})
53+
}
54+
}
55+
56+
// TestDocumentProcessorReplayLeavesJobForTheQueue pins the metadata key the ingestion
57+
// handler reads. pipeline_activation_job_id means "the activation statement already marked
58+
// this job succeeded"; the replay path activates nothing, so emitting it would leave the
59+
// job leased until it dead-lettered.
60+
func TestDocumentProcessorReplayLeavesJobForTheQueue(t *testing.T) {
61+
_, result := runReplayProcessor(t, true)
62+
if _, present := result.Metadata["pipeline_activation_job_id"]; present {
63+
t.Fatalf("replay result claims the activation committed the job: %#v", result.Metadata)
64+
}
65+
if result.Metadata["replayed_active"] != true {
66+
t.Fatalf("replay result metadata = %#v, want replayed_active", result.Metadata)
67+
}
68+
if result.Metadata["document_version_id"] != "version-1" {
69+
t.Fatalf("replay result version id = %#v", result.Metadata["document_version_id"])
70+
}
71+
}
72+
73+
func runReplayProcessor(t *testing.T, replayedActive bool) (*recordingDocumentPipeline, Result) {
74+
t.Helper()
75+
const identity = "00000000-0000-0000-0000-000000000001"
76+
objects := objectstore.NewFake()
77+
ref := objectstore.ObjectRef{Bucket: "b", Key: "k"}
78+
if _, err := objects.Put(context.Background(), ref, strings.NewReader("%PDF test"),
79+
objectstore.PutOptions{MIMEType: "application/pdf", Size: 9}); err != nil {
80+
t.Fatalf("Put: %v", err)
81+
}
82+
ingest := &recordingIngestor{
83+
job: &documents.Job{ID: "job-1", DocumentID: "doc-1", FileName: "manual.pdf"},
84+
}
85+
recorder := &recordingVersionRecorder{record: documents.DocumentVersionRecord{
86+
Document: documents.Document{
87+
ID: "catalog-1", IdentityID: identity, SearchDocumentID: "doc-1", Title: "Manual",
88+
},
89+
Version: documents.DocumentVersion{
90+
ID: "version-1", IdentityID: identity, DocumentID: "catalog-1",
91+
SearchDocumentID: "doc-1", VersionNumber: 1, PipelineGeneration: 1,
92+
},
93+
ReplayedActive: replayedActive,
94+
}}
95+
pipeline := &recordingDocumentPipeline{result: documents.PipelineRunResult{
96+
DocumentID: "catalog-1", SearchDocumentID: "doc-1", VersionID: "version-1",
97+
VersionNumber: 1, PipelineGeneration: 1, PassageCount: 3,
98+
}}
99+
ctx := documents.WithClaimedIngestionJob(context.Background(), documents.IngestionJob{
100+
ID: "queue-job-1", IdentityID: identity, AssetID: "asset-1",
101+
LockedBy: "worker-1", LeaseGeneration: 1,
102+
})
103+
result, err := (&DocumentProcessor{
104+
Objects: objects, Ingest: ingest, VersionRecorder: recorder, Pipeline: pipeline,
105+
}).ProcessAsset(ctx, Asset{
106+
ID: "asset-1", IdentityID: identity, SourceKind: SourceWeb, Scope: ScopeThread,
107+
ObjectBucket: "b", ObjectKey: "k", ObjectETag: "etag-1", FileName: "manual.pdf",
108+
MIMEType: "application/pdf", SizeBytes: 9, ContentHash: "sha256",
109+
})
110+
if err != nil {
111+
t.Fatalf("ProcessAsset: %v", err)
112+
}
113+
return pipeline, result
114+
}

0 commit comments

Comments
 (0)