@murumets-ee/imports 0.33.0 → 0.34.0

package/dist/worker.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"worker.mjs","names":[],"sources":["../src/worker.ts"],"sourcesContent":["/**\n * Queue handler for `imports:run`. The route handler that creates the\n * `import_run` row enqueues this job carrying `{ importRunId }`; the\n * worker module here resolves the run, the transform, and the ES\n * client, then runs `runImport` and writes results back.\n *\n * Per PLAN-ECOMMERCE.md PR 7 (PoC scope): one job type, no resumability.\n * A failed handler attempt re-runs from row 1 on retry — fine for the\n * tens-of-MB feed sizes the PoC exercises.\n *\n * Per CLAUDE.md \"leaf packages\" boundary rule: this handler reads the\n * import_run row via an injected `AdminClient`, NOT a direct `db.select`.\n * Construction happens at plugin init in `plugin.ts`.\n */\n\nimport { type Logger, runAsCli } from '@murumets-ee/core'\nimport {\n  defineJob,\n  type JobDefinition,\n  type QueueJobDeadEvent,\n  type QueueTerminalNotifier,\n} from '@murumets-ee/queue/client'\nimport type { EsClientLike } from '@murumets-ee/search-elasticsearch'\nimport { eq } from 'drizzle-orm'\nimport type { PgColumn } from 'drizzle-orm/pg-core'\nimport { z } from 'zod'\nimport type { ImportRunClient, ImportRunStatus } from './entities/import-run.js'\nimport { feedReaderConfigSchema, type ReadFeedOptions } from './read-feed.js'\nimport {\n  publishImportRunFailed,\n  publishImportRunStarted,\n  publishImportRunSucceeded,\n} from './realtime/publish.js'\nimport { type ImportRunProgress, runImport } from './runner.js'\nimport { countDataRows } from './streaming.js'\nimport type { TransformRegistry } from './transform.js'\n\n/**\n * Structural subset of `JobContext` the handler reads. Declared\n * locally so we don't depend on a `JobHandler` import — the queue\n * package doesn't re-export it from any subpath today (matches the\n * `SendEmailJobContext` pattern in `@murumets-ee/notifications`).\n *\n * Function-param contravariance lets a handler returned with this\n * narrower shape be assigned to the wider `JobHandler<TPayload>` that\n * `registerJob` expects.\n */\nexport interface ImportsRunJobContext {\n  id: string\n  payload: ImportsRunJobPayload\n  updateProgress(data: ImportRunProgress): void\n}\n\n/**\n * Payload schema. `importRunId` is the `import_run.id` UUID — the worker\n * looks up everything else (filePath, transformName, params, …) from\n * that row. Keeping the payload tiny means the queue's progress JSON\n * column never bloats with feed metadata duplicated across `toolkit_jobs`.\n */\nexport const importsRunJobPayloadSchema = z.object({\n  importRunId: z.string().uuid(),\n})\nexport type ImportsRunJobPayload = z.infer<typeof importsRunJobPayloadSchema>\n\n/**\n * Job definition. Consumers register their handler against this with\n * `registerJob(importsRunJob, createRunImportHandler({...}))`.\n *\n * `defaultRetries: 0` — re-running a multi-batch import against the\n * same `import_run.id` while the previous handler may still be writing\n * is a footgun (duplicate batches, double-counted progress). The\n * operator handles retries explicitly via PR 8a's \"retry\" button by\n * creating a new `import_run` row. When the resumable design lands\n * (post-PoC), retries become safe to enable.\n */\nexport const importsRunJob: JobDefinition<ImportsRunJobPayload> = defineJob({\n  name: 'imports:run',\n  description: 'Stream a feed file, transform rows, bulk-write to Elasticsearch.',\n  schema: importsRunJobPayloadSchema,\n  defaultRetries: 0,\n})\n\n/**\n * Resolves the ES client at handler-invocation time. A function (rather\n * than the bare `EsClientLike`) so the consumer can lazy-construct the\n * client — typical Next.js setups create the ES connection in a\n * route-handler initialiser, not at plugin-init time.\n */\nexport type EsClientResolver = () => EsClientLike | Promise<EsClientLike>\n\n/**\n * Ensure the destination index/alias exists before the first bulk-write.\n * Invoked once per job, BEFORE {@link runImport}. Idempotent: the canonical\n * implementation (`ensureAliasedIndex` in `@murumets-ee/search-elasticsearch`)\n * no-ops when the alias already resolves.\n *\n * **Why it lives here.** This is the home of the foot-gun it guards: a worker\n * that bulk-writes to alias `<x>` before the alias exists makes ES\n * auto-create a physical `<x>` index with default `text` mappings, breaking\n * aggregations forever. The bootstrap used to run at app boot, which turned\n * \"ES is down\" into a full-admin 500 (issue #610). Moving it onto the import\n * path keeps the guarantee while scoping ES availability to imports/search —\n * the rest of the admin boots and runs with ES down.\n */\nexport type EnsureIndexResolver = () => Promise<unknown>\n\n/**\n * Resolves the value of `import_run.filePath` (whatever the upload\n * route persisted there — typically a storage adapter key) to a\n * readable LOCAL filesystem path that {@link runImport} can hand to\n * `node:fs.createReadStream`.\n *\n * **Why this exists:** the streaming reader (`streamFeed`) reads from\n * local disk via `createReadStream`. The upload route may persist a\n * remote-storage object key (R2, S3, …) on `import_run.filePath`\n * because that's what `@murumets-ee/storage` returns. Without a\n * resolver, `createReadStream('uploads/2026/05/<uuid>/feed.txt')`\n * crashes with `ENOENT`. The resolver is the documented integration\n * point — typical wiring downloads the storage object to a tmpfile\n * and returns its path.\n *\n * **`cleanup`** runs after the run finishes (success OR failure). The\n * worker awaits it best-effort — a failed cleanup logs but does not\n * crash the run.\n *\n * **No-resolver fallback:** when `resolveFilePath` is unset, the\n * worker treats `import_run.filePath` as already a local FS path\n * (back-compat with the original PoC design where uploads landed on\n * local disk). This stays valid for fixture-driven tests + on-disk\n * deployments.\n */\nexport type FilePathResolver = (\n  storageKey: string,\n) => Promise<{ localPath: string; cleanup?: () => Promise<void> }>\n\nexport interface RunImportHandlerConfig {\n  /** AdminClient over the `import_run` entity. */\n  importRuns: ImportRunClient\n  /** Transform registry to dispatch against. Defaults to the process-global singleton. */\n  transforms: TransformRegistry\n  /** Resolver for the ES client. */\n  esClient: EsClientResolver\n  /** ES alias / index to bulk-write into. Per D6 callers always pass an alias. */\n  esIndex: string\n  /**\n   * Optional bootstrap for the destination index/alias, run once per job\n   * before any bulk-write. See {@link EnsureIndexResolver}. Omit for\n   * deployments that bootstrap the index out-of-band (e.g. a reindex job).\n   */\n  ensureIndex?: EnsureIndexResolver\n  /**\n   * Optional resolver for `import_run.filePath`. See {@link FilePathResolver}.\n   * Required when uploads land in remote storage (R2/S3); optional for\n   * on-disk PoC setups.\n   */\n  resolveFilePath?: FilePathResolver\n  /** Optional structured logger. Defaults to silent. */\n  logger?: Logger\n}\n\n/**\n * Build the `JobHandler` for {@link importsRunJob}. The returned\n * handler is what gets passed to `registerJob`.\n *\n * The body is wrapped in `runAsCli` so AdminClient calls inside have a\n * synthetic `cli` admin context — `auditable()` records `updatedBy:\n * 'cli'` rather than NULL, and the firewall checker passes. This is\n * the documented worker entry-point pattern (see `runAsCli` JSDoc in\n * `@murumets-ee/core`).\n */\nexport function createRunImportHandler(\n  config: RunImportHandlerConfig,\n): (job: ImportsRunJobContext) => Promise<void> {\n  const { importRuns, transforms, esClient, esIndex, resolveFilePath, ensureIndex, logger } = config\n\n  return async (job: ImportsRunJobContext): Promise<void> =>\n    runAsCli(async () => {\n      const { importRunId } = job.payload\n      const log = logger?.child({ jobId: job.id, importRunId, type: 'imports:run' })\n\n      const run = await importRuns.findById(importRunId)\n      if (!run) {\n        // Row was deleted between enqueue and dispatch — nothing to do.\n        // Don't throw: a thrown handler retries with no payoff because\n        // the row stays gone. Log + return so the queue marks the job\n        // completed.\n        log?.warn('import_run row not found — skipping')\n        return\n      }\n\n      // Re-claim detection. The queue's `recoverStuckJobs` sweep flips a\n      // crashed worker's `toolkit_jobs` row from `processing` back to\n      // `pending` — but the queue layer has no knowledge of `import_run`,\n      // so this row stays at `status='running'` from the prior attempt.\n      // When the queue re-dispatches the job, we land here with a row\n      // that the operator-facing Active panel has been showing as live\n      // for however long lock-recovery took (default 30 min). The\n      // existing `update` below overwrites `queueJobId` + `startedAt` so\n      // there is no STATE corruption — but emit a structured warning so\n      // ops can correlate this re-run with the worker crash that\n      // produced it. The sibling `sweepStaleImportRuns` job below catches\n      // the case where re-dispatch never happens (queue marks the job\n      // dead, or the queue worker is offline long-term).\n      if (run.status === 'running') {\n        log?.warn(\n          {\n            previousQueueJobId: run.queueJobId,\n            previousStartedAt: run.startedAt,\n          },\n          'imports: re-claiming a row left in running by a prior worker — likely a crash recovered by queue lock-recovery',\n        )\n      }\n\n      // `transformName`, `filePath`, `label` are declared `field.text({\n      // required: true })` so the inferred DTO already types them as\n      // `string` — no cast needed. `params` is `field.json()` which\n      // infers as `JsonValue | undefined`; narrow to a record so the\n      // transform receives an object.\n      const transform = transforms.get(run.transformName)\n      if (!transform) {\n        await markFailed(importRuns, importRunId, `Unknown transform \"${run.transformName}\"`)\n        throw new Error(`No transform registered for name \"${run.transformName}\"`)\n      }\n      const params: Record<string, unknown> =\n        run.params && typeof run.params === 'object' && !Array.isArray(run.params)\n          ? (run.params as Record<string, unknown>)\n          : {}\n\n      // Reader config (format/delimiter/header/sheet) travels in\n      // `params.feed` for mapping-driven runs (commerce-demo PR3). Carmaker\n      // runs omit it → empty config → tab-delimited default, so the existing\n      // path is byte-for-byte unchanged. Re-validate here as defense-in-depth\n      // even though the enqueuing route already validated the saved mapping.\n      const feedRaw =\n        params.feed && typeof params.feed === 'object' && !Array.isArray(params.feed)\n          ? params.feed\n          : {}\n      const feedParsed = feedReaderConfigSchema.safeParse(feedRaw)\n      if (!feedParsed.success) {\n        const reason = feedParsed.error.issues[0]?.message ?? 'invalid feed reader config'\n        await markFailed(importRuns, importRunId, `Invalid params.feed: ${reason}`)\n        throw new Error(`Invalid params.feed for import_run ${importRunId}: ${reason}`)\n      }\n      const feedConfig = feedParsed.data\n\n      await importRuns.update(importRunId, {\n        status: 'running' satisfies ImportRunStatus,\n        queueJobId: job.id,\n        startedAt: new Date(),\n      })\n      // Realtime: row transitioned pending → running. Subscribers\n      // refetch to surface the change in the imports admin page.\n      // Best-effort — a publish failure is logged inside `publishSafe`\n      // and does NOT roll back the row update.\n      publishImportRunStarted(importRunId)\n\n      let resolvedClient: EsClientLike\n      try {\n        resolvedClient = await esClient()\n      } catch (err) {\n        const reason = err instanceof Error ? err.message : String(err)\n        await markFailed(importRuns, importRunId, `Could not resolve ES client: ${reason}`)\n        throw err\n      }\n\n      // Ensure the destination alias exists BEFORE any bulk-write. Moved here\n      // from app boot (issue #610): the foot-gun is the worker auto-creating a\n      // mis-mapped physical index, so the guard belongs on the import path —\n      // not gating the whole app on ES. Idempotent + scoped: an ES outage (or\n      // the `ensureAliasedIndex` physical-collision guard firing) fails THIS\n      // job loudly while the rest of the admin keeps working.\n      if (ensureIndex) {\n        try {\n          await ensureIndex()\n        } catch (err) {\n          const reason = err instanceof Error ? err.message : String(err)\n          await markFailed(importRuns, importRunId, `Could not ensure ES index/alias: ${reason}`)\n          throw err\n        }\n      }\n\n      // Materialise the file locally if the consumer wired a resolver.\n      // The `cleanup` callback (when present) runs in the `finally`\n      // below regardless of run outcome so a tmpfile created here\n      // doesn't outlive the handler.\n      let localPath: string\n      let fileCleanup: (() => Promise<void>) | undefined\n      if (resolveFilePath) {\n        try {\n          const resolved = await resolveFilePath(run.filePath)\n          localPath = resolved.localPath\n          fileCleanup = resolved.cleanup\n        } catch (err) {\n          const reason = err instanceof Error ? err.message : String(err)\n          await markFailed(importRuns, importRunId, `Could not resolve filePath: ${reason}`)\n          throw err\n        }\n      } else {\n        // Back-compat: no resolver wired → treat `filePath` as already\n        // a local FS path. Fine for fixture-driven tests + the original\n        // on-disk PoC design.\n        localPath = run.filePath\n      }\n\n      // Pre-pass line count: a 16 MB tab-delimited feed counts in\n      // ~50ms; a 500 MB feed in <2s. Cheap relative to the full\n      // import. Gives the operator a denominator (`processed / total`)\n      // so the imports-page panel can render an actual percent\n      // instead of just \"rows so far\".\n      // Pre-pass row count is a `\\n`-tally over a delimited file — meaningless\n      // on an xlsx binary, so skip it there (the UI falls back to bare counts).\n      // `hasHeader` from the feed config keeps the header-exclusion correct for\n      // headerless mappings.\n      let totalRows: number | undefined\n      if (feedConfig.format !== 'xlsx') {\n        try {\n          totalRows = await countDataRows(\n            localPath,\n            feedConfig.hasHeader !== undefined ? { hasHeader: feedConfig.hasHeader } : {},\n          )\n          log?.info({ importRunId, totalRows }, 'imports: pre-pass row count')\n        } catch (err) {\n          // Don't fail the run on a count miss — the actual import is\n          // unaffected; the operator just loses the percent denominator.\n          log?.warn({ err }, 'imports: pre-pass row count failed — continuing without total')\n        }\n      }\n\n      let result: Awaited<ReturnType<typeof runImport>>\n      try {\n        // Build feed options with the conditional-spread idiom (NOT\n        // `...feedConfig`) so absent optionals stay ABSENT — spreading a\n        // `T | undefined` value would set the key to `undefined`, which\n        // `exactOptionalPropertyTypes` rejects against `ReadFeedOptions`.\n        const feedOpts: ReadFeedOptions = {\n          filePath: localPath,\n          ...(feedConfig.format !== undefined && { format: feedConfig.format }),\n          ...(feedConfig.delimiter !== undefined && { delimiter: feedConfig.delimiter }),\n          ...(feedConfig.hasHeader !== undefined && { hasHeader: feedConfig.hasHeader }),\n          ...(feedConfig.headerRowIndex !== undefined && {\n            headerRowIndex: feedConfig.headerRowIndex,\n          }),\n          ...(feedConfig.sheet !== undefined && { sheet: feedConfig.sheet }),\n        }\n        result = await runImport({\n          importRunId,\n          runLabel: run.label,\n          params,\n          transform,\n          feed: feedOpts,\n          esClient: resolvedClient,\n          esIndex,\n          onProgress: (progress) =>\n            job.updateProgress(totalRows !== undefined ? { ...progress, totalRows } : progress),\n          ...(log !== undefined && { logger: log }),\n        })\n      } catch (err) {\n        const reason = err instanceof Error ? err.message : String(err)\n        await markFailed(importRuns, importRunId, reason)\n        if (fileCleanup) {\n          await fileCleanup().catch((cleanupErr: unknown) => {\n            log?.warn({ err: cleanupErr }, 'filePath cleanup after failed run threw — ignoring')\n          })\n        }\n        throw err\n      }\n\n      // Cleanup runs before the success-update so a cleanup throw\n      // surfaces as a logged warning rather than a crashed handler at\n      // the worst possible moment (just after the row was about to be\n      // marked succeeded).\n      if (fileCleanup) {\n        await fileCleanup().catch((cleanupErr: unknown) => {\n          log?.warn({ err: cleanupErr }, 'filePath cleanup after successful run threw — ignoring')\n        })\n      }\n\n      await importRuns.update(importRunId, {\n        status: 'succeeded' satisfies ImportRunStatus,\n        finishedAt: new Date(),\n        totals: {\n          rowsRead: result.rowsRead,\n          rowsSucceeded: result.rowsSucceeded,\n          rowsFailed: result.rowsFailed,\n          rowsSkipped: result.rowsSkipped,\n          batchesCompleted: result.batchesCompleted,\n        },\n        // The typed `ErrorTrackerSnapshot` is fully JSON-serialisable but\n        // doesn't structurally satisfy entity's recursive `JsonValue`\n        // (objects without an index signature aren't `Record<string,\n        // JsonValue>`). Round-trip through `JSON.parse(JSON.stringify(...))`\n        // to land as the recursive JSON shape — the runtime cost is one\n        // serialise per import_run completion, the type-cast cost is zero.\n        errorSummary: JSON.parse(JSON.stringify(result.errors)),\n      })\n      // Realtime: row transitioned to terminal-success. Subscribers\n      // refetch to move the row from Active → Recent.\n      publishImportRunSucceeded(importRunId, {\n        rowsRead: result.rowsRead,\n        rowsSucceeded: result.rowsSucceeded,\n        rowsFailed: result.rowsFailed,\n      })\n\n      log?.info(\n        {\n          rowsRead: result.rowsRead,\n          rowsSucceeded: result.rowsSucceeded,\n          rowsFailed: result.rowsFailed,\n          rowsSkipped: result.rowsSkipped,\n          batches: result.batchesCompleted,\n        },\n        'import_run completed',\n      )\n    })\n}\n\n/** Write a `failed` row with a fatal error reason. Best-effort — logs but does not throw on DB failure. */\nasync function markFailed(\n  importRuns: ImportRunClient,\n  id: string,\n  reason: string,\n): Promise<void> {\n  try {\n    await importRuns.update(id, {\n      status: 'failed' satisfies ImportRunStatus,\n      finishedAt: new Date(),\n      errorSummary: { fatal: reason },\n    })\n    // Realtime: row transitioned to terminal-failure. Subscribers\n    // refetch to surface the failure in the Recent panel. Publish\n    // is best-effort and only fires when the persist succeeds —\n    // skipping it on persist failure keeps subscribers consistent\n    // with the DB (no event for a row that didn't transition).\n    publishImportRunFailed(id, reason)\n  } catch {\n    // The handler already threw / will throw — the queue will surface\n    // the original error. A second failure here just logs noise.\n  }\n}\n\nexport interface ImportsRunDeadListenerConfig {\n  importRuns: ImportRunClient\n  /** Optional structured logger. */\n  logger?: Logger\n}\n\n/**\n * Build a {@link QueueTerminalNotifier} that mirrors `imports:run`\n * dead-job events into `import_run.status='failed'`.\n *\n * **Why this exists.** The `imports:run` handler's normal failure path\n * already calls `markFailed` before re-throwing, so a synchronous\n * handler error reaches the operator-visible `failed` status without\n * help from anyone. The case THIS listener catches is the one\n * `markFailed` never gets to: the worker process is killed mid-handler\n * (OOM, container restart, kill -9), the queue's lock-recovery sweep\n * eventually reclaims the row, and the queue ultimately marks the job\n * `dead` (defaultRetries: 0 + repeated process death = dead-letter\n * with `import_run.status` still `running`). Without this listener\n * the row sits in the operator's Active panel forever.\n *\n * **Generic primitive.** This is a thin subscriber over the queue's\n * multi-subscriber `QueueTerminalNotifier` registry — the same shape\n * graphile-worker (`job:failed`) and BullMQ (`failed`) expose. Other\n * domain plugins that mirror queue state (ticketing-reply, future\n * exports/reports/...) can register their own listeners exactly the\n * same way without coordinating via a per-domain sweep job.\n *\n * **Filtering.** The listener is invoked for EVERY dead event in the\n * process. We early-return on any `jobType` other than `imports:run`\n * so the per-event cost on unrelated jobs is a single property read.\n *\n * **Idempotency.** A dead event delivered after the row has already\n * reached its own terminal state (succeeded / failed / cancelled) is\n * ignored — the only transition we make is `running → failed`. This\n * keeps a late replay or out-of-order delivery from clobbering a\n * row whose worker reached `markFailed` faster than the queue's\n * dead-letter dispatch.\n *\n * The handler is wrapped in `runAsCli` so AdminClient calls inside\n * have a synthetic CLI admin context — same pattern as\n * {@link createRunImportHandler}.\n */\nexport function createImportsRunDeadListener(\n  config: ImportsRunDeadListenerConfig,\n): QueueTerminalNotifier {\n  const { importRuns, logger } = config\n\n  return {\n    onJobDead: async (event: QueueJobDeadEvent): Promise<void> => {\n      if (event.jobType !== 'imports:run') return\n\n      await runAsCli(async () => {\n        const log = logger?.child({\n          event: 'imports.run.dead',\n          jobId: event.jobId,\n          type: 'imports:run',\n        })\n\n        // Look up the mirror row by `queueJobId`. Cap to 1 — the\n        // upload route writes one `import_run` per enqueued job.\n        //\n        // `AdminClient.getTable()` returns `PgTableWithColumns<any>`\n        // because entity tables have dynamic column shapes (see the\n        // `getTable()` JSDoc in `packages/entity/src/admin/client.ts`\n        // and the documented-`any`-cases list in CLAUDE.md). Cast\n        // the table to a structural shape covering only the column\n        // we touch, so both `eq()` and type-coverage see a typed\n        // operand instead of an `any`-derived property access.\n        const table = importRuns.getTable() as unknown as { queueJobId: PgColumn }\n        const matches = await importRuns.findMany({\n          where: eq(table.queueJobId, event.jobId),\n          limit: 1,\n        })\n        const row = matches[0]\n        if (!row) {\n          // No mirror row for this dead job. Either it was deleted\n          // by the operator, or the dead event is for a job\n          // unrelated to imports despite the type filter\n          // (shouldn't happen, but is cheap to log).\n          log?.warn('queue.job.dead with no matching import_run — skipping')\n          return\n        }\n\n        // Only transition rows that haven't already reached their\n        // own terminal state. A late dead-event must not overwrite\n        // a `succeeded` row that the worker reached via the normal\n        // path before the queue's dead-letter dispatch fired.\n        if (row.status !== 'running' && row.status !== 'pending') {\n          log?.info(\n            { importRunId: row.id, status: row.status },\n            'queue.job.dead arrived for a row already in a terminal state — leaving as-is',\n          )\n          return\n        }\n\n        // Dead-from-`pending` is the rarer + more interesting case:\n        // the worker process died (or never claimed) BEFORE it could\n        // flip the row to `running`. Log it at warn so ops can spot\n        // a queue+worker-startup pathology that the standard `running\n        // → failed` transition wouldn't surface. Dead-from-`running`\n        // is the documented \"crash mid-import\" case — info is enough.\n        if (row.status === 'pending') {\n          log?.warn(\n            { importRunId: row.id, attempts: event.attempts },\n            'queue.job.dead arrived for an import_run still in pending — worker crashed BEFORE claim/lookup',\n          )\n        }\n\n        await markFailed(importRuns, row.id, event.error)\n        log?.info(\n          { importRunId: row.id, attempts: event.attempts, priorStatus: row.status },\n          'queue.job.dead → import_run marked failed',\n        )\n      })\n    },\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"worker.mjs","names":[],"sources":["../src/worker.ts"],"sourcesContent":["/**\n * Queue handler for `imports:run`. The route handler that creates the\n * `import_run` row enqueues this job carrying `{ importRunId }`; the\n * worker module here resolves the run, the transform, and the ES\n * client, then runs `runImport` and writes results back.\n *\n * Per PLAN-ECOMMERCE.md PR 7 (PoC scope): one job type, no resumability.\n * A failed handler attempt re-runs from row 1 on retry — fine for the\n * tens-of-MB feed sizes the PoC exercises.\n *\n * Per CLAUDE.md \"leaf packages\" boundary rule: this handler reads the\n * import_run row via an injected `AdminClient`, NOT a direct `db.select`.\n * Construction happens at plugin init in `plugin.ts`.\n */\n\nimport { type Logger, runAsCli } from '@murumets-ee/core'\nimport {\n  defineJob,\n  type JobDefinition,\n  type QueueJobDeadEvent,\n  type QueueTerminalNotifier,\n} from '@murumets-ee/queue/client'\nimport type { EsClientLike } from '@murumets-ee/search-elasticsearch'\nimport { eq } from 'drizzle-orm'\nimport type { PgColumn } from 'drizzle-orm/pg-core'\nimport { z } from 'zod'\nimport type { ImportRunClient, ImportRunStatus } from './entities/import-run.js'\nimport { feedReaderConfigSchema, type ReadFeedOptions } from './read-feed.js'\nimport {\n  publishImportRunFailed,\n  publishImportRunStarted,\n  publishImportRunSucceeded,\n} from './realtime/publish.js'\nimport { type ImportRunProgress, runImport } from './runner.js'\nimport { countDataRows } from './streaming.js'\nimport type { TransformRegistry } from './transform.js'\n\n/**\n * Structural subset of `JobContext` the handler reads. Declared\n * locally so we don't depend on a `JobHandler` import — the queue\n * package doesn't re-export it from any subpath today (matches the\n * `SendEmailJobContext` pattern in `@murumets-ee/notifications`).\n *\n * Function-param contravariance lets a handler returned with this\n * narrower shape be assigned to the wider `JobHandler<TPayload>` that\n * `registerJob` expects.\n */\nexport interface ImportsRunJobContext {\n  id: string\n  payload: ImportsRunJobPayload\n  updateProgress(data: ImportRunProgress): void\n}\n\n/**\n * Payload schema. `importRunId` is the `import_run.id` UUID — the worker\n * looks up everything else (filePath, transformName, params, …) from\n * that row. Keeping the payload tiny means the queue's progress JSON\n * column never bloats with feed metadata duplicated across `toolkit_jobs`.\n */\nexport const importsRunJobPayloadSchema = z.object({\n  importRunId: z.string().uuid(),\n})\nexport type ImportsRunJobPayload = z.infer<typeof importsRunJobPayloadSchema>\n\n/**\n * Job definition. Consumers register their handler against this with\n * `registerJob(importsRunJob, createRunImportHandler({...}))`.\n *\n * `defaultRetries: 0` — re-running a multi-batch import against the\n * same `import_run.id` while the previous handler may still be writing\n * is a footgun (duplicate batches, double-counted progress). The\n * operator handles retries explicitly via PR 8a's \"retry\" button by\n * creating a new `import_run` row. When the resumable design lands\n * (post-PoC), retries become safe to enable.\n */\nexport const importsRunJob: JobDefinition<ImportsRunJobPayload> = defineJob({\n  name: 'imports:run',\n  description: 'Stream a feed file, transform rows, bulk-write to Elasticsearch.',\n  schema: importsRunJobPayloadSchema,\n  defaultRetries: 0,\n})\n\n/**\n * Resolves the ES client at handler-invocation time. A function (rather\n * than the bare `EsClientLike`) so the consumer can lazy-construct the\n * client — typical Next.js setups create the ES connection in a\n * route-handler initialiser, not at plugin-init time.\n */\nexport type EsClientResolver = () => EsClientLike | Promise<EsClientLike>\n\n/**\n * Ensure the destination index/alias exists before the first bulk-write.\n * Invoked once per job, BEFORE {@link runImport}. Idempotent: the canonical\n * implementation (`ensureAliasedIndex` in `@murumets-ee/search-elasticsearch`)\n * no-ops when the alias already resolves.\n *\n * **Why it lives here.** This is the home of the foot-gun it guards: a worker\n * that bulk-writes to alias `<x>` before the alias exists makes ES\n * auto-create a physical `<x>` index with default `text` mappings, breaking\n * aggregations forever. The bootstrap used to run at app boot, which turned\n * \"ES is down\" into a full-admin 500 (issue #610). Moving it onto the import\n * path keeps the guarantee while scoping ES availability to imports/search —\n * the rest of the admin boots and runs with ES down.\n */\nexport type EnsureIndexResolver = () => Promise<unknown>\n\n/**\n * Resolves the value of `import_run.filePath` (whatever the upload\n * route persisted there — typically a storage adapter key) to a\n * readable LOCAL filesystem path that {@link runImport} can hand to\n * `node:fs.createReadStream`.\n *\n * **Why this exists:** the streaming reader (`streamFeed`) reads from\n * local disk via `createReadStream`. The upload route may persist a\n * remote-storage object key (R2, S3, …) on `import_run.filePath`\n * because that's what `@murumets-ee/storage` returns. Without a\n * resolver, `createReadStream('uploads/2026/05/<uuid>/feed.txt')`\n * crashes with `ENOENT`. The resolver is the documented integration\n * point — typical wiring downloads the storage object to a tmpfile\n * and returns its path.\n *\n * **`cleanup`** runs after the run finishes (success OR failure). The\n * worker awaits it best-effort — a failed cleanup logs but does not\n * crash the run.\n *\n * **No-resolver fallback:** when `resolveFilePath` is unset, the\n * worker treats `import_run.filePath` as already a local FS path\n * (back-compat with the original PoC design where uploads landed on\n * local disk). This stays valid for fixture-driven tests + on-disk\n * deployments.\n */\nexport type FilePathResolver = (\n  storageKey: string,\n) => Promise<{ localPath: string; cleanup?: () => Promise<void> }>\n\nexport interface RunImportHandlerConfig {\n  /** AdminClient over the `import_run` entity. */\n  importRuns: ImportRunClient\n  /** Transform registry to dispatch against. Defaults to the process-global singleton. */\n  transforms: TransformRegistry\n  /** Resolver for the ES client. */\n  esClient: EsClientResolver\n  /** ES alias / index to bulk-write into. Per D6 callers always pass an alias. */\n  esIndex: string\n  /**\n   * Optional bootstrap for the destination index/alias, run once per job\n   * before any bulk-write. See {@link EnsureIndexResolver}. Omit for\n   * deployments that bootstrap the index out-of-band (e.g. a reindex job).\n   */\n  ensureIndex?: EnsureIndexResolver\n  /**\n   * Optional resolver for `import_run.filePath`. See {@link FilePathResolver}.\n   * Required when uploads land in remote storage (R2/S3); optional for\n   * on-disk PoC setups.\n   */\n  resolveFilePath?: FilePathResolver\n  /** Optional structured logger. Defaults to silent. */\n  logger?: Logger\n}\n\n/**\n * Build the `JobHandler` for {@link importsRunJob}. The returned\n * handler is what gets passed to `registerJob`.\n *\n * The body is wrapped in `runAsCli` so AdminClient calls inside have a\n * synthetic `cli` admin context — `auditable()` records `updatedBy:\n * 'cli'` rather than NULL, and the firewall checker passes. This is\n * the documented worker entry-point pattern (see `runAsCli` JSDoc in\n * `@murumets-ee/core`).\n */\nexport function createRunImportHandler(\n  config: RunImportHandlerConfig,\n): (job: ImportsRunJobContext) => Promise<void> {\n  const { importRuns, transforms, esClient, esIndex, resolveFilePath, ensureIndex, logger } = config\n\n  return async (job: ImportsRunJobContext): Promise<void> =>\n    runAsCli(async () => {\n      const { importRunId } = job.payload\n      const log = logger?.child({ jobId: job.id, importRunId, type: 'imports:run' })\n\n      const run = await importRuns.findById(importRunId)\n      if (!run) {\n        // Row was deleted between enqueue and dispatch — nothing to do.\n        // Don't throw: a thrown handler retries with no payoff because\n        // the row stays gone. Log + return so the queue marks the job\n        // completed.\n        log?.warn('import_run row not found — skipping')\n        return\n      }\n\n      // Re-claim detection. The queue's `recoverStuckJobs` sweep flips a\n      // crashed worker's `toolkit_jobs` row from `processing` back to\n      // `pending` — but the queue layer has no knowledge of `import_run`,\n      // so this row stays at `status='running'` from the prior attempt.\n      // When the queue re-dispatches the job, we land here with a row\n      // that the operator-facing Active panel has been showing as live\n      // for however long lock-recovery took (default 30 min). The\n      // existing `update` below overwrites `queueJobId` + `startedAt` so\n      // there is no STATE corruption — but emit a structured warning so\n      // ops can correlate this re-run with the worker crash that\n      // produced it. The sibling `sweepStaleImportRuns` job below catches\n      // the case where re-dispatch never happens (queue marks the job\n      // dead, or the queue worker is offline long-term).\n      if (run.status === 'running') {\n        log?.warn(\n          {\n            previousQueueJobId: run.queueJobId,\n            previousStartedAt: run.startedAt,\n          },\n          'imports: re-claiming a row left in running by a prior worker — likely a crash recovered by queue lock-recovery',\n        )\n      }\n\n      // `transformName`, `filePath`, `label` are declared `field.text({\n      // required: true })` so the inferred DTO already types them as\n      // `string` — no cast needed. `params` is `field.json()` which\n      // infers as `JsonValue | undefined`; narrow to a record so the\n      // transform receives an object.\n      const transform = transforms.get(run.transformName)\n      if (!transform) {\n        await markFailed(importRuns, importRunId, `Unknown transform \"${run.transformName}\"`)\n        throw new Error(`No transform registered for name \"${run.transformName}\"`)\n      }\n      const params: Record<string, unknown> =\n        run.params && typeof run.params === 'object' && !Array.isArray(run.params)\n          ? (run.params as Record<string, unknown>)\n          : {}\n\n      // Reader config (format/delimiter/header/sheet) travels in\n      // `params.feed` for mapping-driven runs (commerce-demo PR3). Carmaker\n      // runs omit it → empty config → tab-delimited default, so the existing\n      // path is byte-for-byte unchanged. Re-validate here as defense-in-depth\n      // even though the enqueuing route already validated the saved mapping.\n      const feedRaw =\n        params.feed && typeof params.feed === 'object' && !Array.isArray(params.feed)\n          ? params.feed\n          : {}\n      const feedParsed = feedReaderConfigSchema.safeParse(feedRaw)\n      if (!feedParsed.success) {\n        const reason = feedParsed.error.issues[0]?.message ?? 'invalid feed reader config'\n        await markFailed(importRuns, importRunId, `Invalid params.feed: ${reason}`)\n        throw new Error(`Invalid params.feed for import_run ${importRunId}: ${reason}`)\n      }\n      const feedConfig = feedParsed.data\n\n      await importRuns.update(importRunId, {\n        status: 'running' satisfies ImportRunStatus,\n        queueJobId: job.id,\n        startedAt: new Date(),\n      })\n      // Realtime: row transitioned pending → running. Subscribers\n      // refetch to surface the change in the imports admin page.\n      // Best-effort — a publish failure is logged inside `publishSafe`\n      // and does NOT roll back the row update.\n      publishImportRunStarted(importRunId)\n\n      let resolvedClient: EsClientLike\n      try {\n        resolvedClient = await esClient()\n      } catch (err) {\n        const reason = err instanceof Error ? err.message : String(err)\n        await markFailed(importRuns, importRunId, `Could not resolve ES client: ${reason}`)\n        throw err\n      }\n\n      // Ensure the destination alias exists BEFORE any bulk-write. Moved here\n      // from app boot (issue #610): the foot-gun is the worker auto-creating a\n      // mis-mapped physical index, so the guard belongs on the import path —\n      // not gating the whole app on ES. Idempotent + scoped: an ES outage (or\n      // the `ensureAliasedIndex` physical-collision guard firing) fails THIS\n      // job loudly while the rest of the admin keeps working.\n      if (ensureIndex) {\n        try {\n          await ensureIndex()\n        } catch (err) {\n          const reason = err instanceof Error ? err.message : String(err)\n          await markFailed(importRuns, importRunId, `Could not ensure ES index/alias: ${reason}`)\n          throw err\n        }\n      }\n\n      // Materialise the file locally if the consumer wired a resolver.\n      // The `cleanup` callback (when present) runs in the `finally`\n      // below regardless of run outcome so a tmpfile created here\n      // doesn't outlive the handler.\n      let localPath: string\n      let fileCleanup: (() => Promise<void>) | undefined\n      if (resolveFilePath) {\n        try {\n          const resolved = await resolveFilePath(run.filePath)\n          localPath = resolved.localPath\n          fileCleanup = resolved.cleanup\n        } catch (err) {\n          const reason = err instanceof Error ? err.message : String(err)\n          await markFailed(importRuns, importRunId, `Could not resolve filePath: ${reason}`)\n          throw err\n        }\n      } else {\n        // Back-compat: no resolver wired → treat `filePath` as already\n        // a local FS path. Fine for fixture-driven tests + the original\n        // on-disk PoC design.\n        localPath = run.filePath\n      }\n\n      // Pre-pass line count: a 16 MB tab-delimited feed counts in\n      // ~50ms; a 500 MB feed in <2s. Cheap relative to the full\n      // import. Gives the operator a denominator (`processed / total`)\n      // so the imports-page panel can render an actual percent\n      // instead of just \"rows so far\".\n      // Pre-pass row count is a `\\n`-tally over a delimited file — meaningless\n      // on an xlsx binary, so skip it there (the UI falls back to bare counts).\n      // `hasHeader` from the feed config keeps the header-exclusion correct for\n      // headerless mappings.\n      let totalRows: number | undefined\n      if (feedConfig.format !== 'xlsx') {\n        try {\n          totalRows = await countDataRows(\n            localPath,\n            feedConfig.hasHeader !== undefined ? { hasHeader: feedConfig.hasHeader } : {},\n          )\n          log?.info({ importRunId, totalRows }, 'imports: pre-pass row count')\n        } catch (err) {\n          // Don't fail the run on a count miss — the actual import is\n          // unaffected; the operator just loses the percent denominator.\n          log?.warn({ err }, 'imports: pre-pass row count failed — continuing without total')\n        }\n      }\n\n      let result: Awaited<ReturnType<typeof runImport>>\n      try {\n        // Build feed options with the conditional-spread idiom (NOT\n        // `...feedConfig`) so absent optionals stay ABSENT — spreading a\n        // `T | undefined` value would set the key to `undefined`, which\n        // `exactOptionalPropertyTypes` rejects against `ReadFeedOptions`.\n        const feedOpts: ReadFeedOptions = {\n          filePath: localPath,\n          ...(feedConfig.format !== undefined && { format: feedConfig.format }),\n          ...(feedConfig.delimiter !== undefined && { delimiter: feedConfig.delimiter }),\n          ...(feedConfig.hasHeader !== undefined && { hasHeader: feedConfig.hasHeader }),\n          ...(feedConfig.headerRowIndex !== undefined && {\n            headerRowIndex: feedConfig.headerRowIndex,\n          }),\n          ...(feedConfig.sheet !== undefined && { sheet: feedConfig.sheet }),\n        }\n        result = await runImport({\n          importRunId,\n          runLabel: run.label,\n          params,\n          transform,\n          feed: feedOpts,\n          esClient: resolvedClient,\n          esIndex,\n          onProgress: (progress) =>\n            job.updateProgress(totalRows !== undefined ? { ...progress, totalRows } : progress),\n          ...(log !== undefined && { logger: log }),\n        })\n      } catch (err) {\n        const reason = err instanceof Error ? err.message : String(err)\n        await markFailed(importRuns, importRunId, reason)\n        if (fileCleanup) {\n          await fileCleanup().catch((cleanupErr: unknown) => {\n            log?.warn({ err: cleanupErr }, 'filePath cleanup after failed run threw — ignoring')\n          })\n        }\n        throw err\n      }\n\n      // Cleanup runs before the success-update so a cleanup throw\n      // surfaces as a logged warning rather than a crashed handler at\n      // the worst possible moment (just after the row was about to be\n      // marked succeeded).\n      if (fileCleanup) {\n        await fileCleanup().catch((cleanupErr: unknown) => {\n          log?.warn({ err: cleanupErr }, 'filePath cleanup after successful run threw — ignoring')\n        })\n      }\n\n      await importRuns.update(importRunId, {\n        status: 'succeeded' satisfies ImportRunStatus,\n        finishedAt: new Date(),\n        totals: {\n          rowsRead: result.rowsRead,\n          rowsSucceeded: result.rowsSucceeded,\n          rowsFailed: result.rowsFailed,\n          rowsSkipped: result.rowsSkipped,\n          rowsWarned: result.rowsWarned,\n          batchesCompleted: result.batchesCompleted,\n        },\n        // The typed `ErrorTrackerSnapshot` is fully JSON-serialisable but\n        // doesn't structurally satisfy entity's recursive `JsonValue`\n        // (objects without an index signature aren't `Record<string,\n        // JsonValue>`). Round-trip through `JSON.parse(JSON.stringify(...))`\n        // to land as the recursive JSON shape — the runtime cost is one\n        // serialise per import_run completion, the type-cast cost is zero.\n        errorSummary: JSON.parse(JSON.stringify(result.errors)),\n        // Non-fatal warnings (commerce-demo PR4) — kept separate from\n        // `errorSummary` so a `no_purchase_price` advisory never reads as a\n        // failed row. Same serialise-roundtrip rationale as `errorSummary`.\n        warningSummary: JSON.parse(JSON.stringify(result.warnings)),\n      })\n      // Realtime: row transitioned to terminal-success. Subscribers\n      // refetch to move the row from Active → Recent.\n      publishImportRunSucceeded(importRunId, {\n        rowsRead: result.rowsRead,\n        rowsSucceeded: result.rowsSucceeded,\n        rowsFailed: result.rowsFailed,\n      })\n\n      log?.info(\n        {\n          rowsRead: result.rowsRead,\n          rowsSucceeded: result.rowsSucceeded,\n          rowsFailed: result.rowsFailed,\n          rowsSkipped: result.rowsSkipped,\n          batches: result.batchesCompleted,\n        },\n        'import_run completed',\n      )\n    })\n}\n\n/** Write a `failed` row with a fatal error reason. Best-effort — logs but does not throw on DB failure. */\nasync function markFailed(\n  importRuns: ImportRunClient,\n  id: string,\n  reason: string,\n): Promise<void> {\n  try {\n    await importRuns.update(id, {\n      status: 'failed' satisfies ImportRunStatus,\n      finishedAt: new Date(),\n      errorSummary: { fatal: reason },\n    })\n    // Realtime: row transitioned to terminal-failure. Subscribers\n    // refetch to surface the failure in the Recent panel. Publish\n    // is best-effort and only fires when the persist succeeds —\n    // skipping it on persist failure keeps subscribers consistent\n    // with the DB (no event for a row that didn't transition).\n    publishImportRunFailed(id, reason)\n  } catch {\n    // The handler already threw / will throw — the queue will surface\n    // the original error. A second failure here just logs noise.\n  }\n}\n\nexport interface ImportsRunDeadListenerConfig {\n  importRuns: ImportRunClient\n  /** Optional structured logger. */\n  logger?: Logger\n}\n\n/**\n * Build a {@link QueueTerminalNotifier} that mirrors `imports:run`\n * dead-job events into `import_run.status='failed'`.\n *\n * **Why this exists.** The `imports:run` handler's normal failure path\n * already calls `markFailed` before re-throwing, so a synchronous\n * handler error reaches the operator-visible `failed` status without\n * help from anyone. The case THIS listener catches is the one\n * `markFailed` never gets to: the worker process is killed mid-handler\n * (OOM, container restart, kill -9), the queue's lock-recovery sweep\n * eventually reclaims the row, and the queue ultimately marks the job\n * `dead` (defaultRetries: 0 + repeated process death = dead-letter\n * with `import_run.status` still `running`). Without this listener\n * the row sits in the operator's Active panel forever.\n *\n * **Generic primitive.** This is a thin subscriber over the queue's\n * multi-subscriber `QueueTerminalNotifier` registry — the same shape\n * graphile-worker (`job:failed`) and BullMQ (`failed`) expose. Other\n * domain plugins that mirror queue state (ticketing-reply, future\n * exports/reports/...) can register their own listeners exactly the\n * same way without coordinating via a per-domain sweep job.\n *\n * **Filtering.** The listener is invoked for EVERY dead event in the\n * process. We early-return on any `jobType` other than `imports:run`\n * so the per-event cost on unrelated jobs is a single property read.\n *\n * **Idempotency.** A dead event delivered after the row has already\n * reached its own terminal state (succeeded / failed / cancelled) is\n * ignored — the only transition we make is `running → failed`. This\n * keeps a late replay or out-of-order delivery from clobbering a\n * row whose worker reached `markFailed` faster than the queue's\n * dead-letter dispatch.\n *\n * The handler is wrapped in `runAsCli` so AdminClient calls inside\n * have a synthetic CLI admin context — same pattern as\n * {@link createRunImportHandler}.\n */\nexport function createImportsRunDeadListener(\n  config: ImportsRunDeadListenerConfig,\n): QueueTerminalNotifier {\n  const { importRuns, logger } = config\n\n  return {\n    onJobDead: async (event: QueueJobDeadEvent): Promise<void> => {\n      if (event.jobType !== 'imports:run') return\n\n      await runAsCli(async () => {\n        const log = logger?.child({\n          event: 'imports.run.dead',\n          jobId: event.jobId,\n          type: 'imports:run',\n        })\n\n        // Look up the mirror row by `queueJobId`. Cap to 1 — the\n        // upload route writes one `import_run` per enqueued job.\n        //\n        // `AdminClient.getTable()` returns `PgTableWithColumns<any>`\n        // because entity tables have dynamic column shapes (see the\n        // `getTable()` JSDoc in `packages/entity/src/admin/client.ts`\n        // and the documented-`any`-cases list in CLAUDE.md). Cast\n        // the table to a structural shape covering only the column\n        // we touch, so both `eq()` and type-coverage see a typed\n        // operand instead of an `any`-derived property access.\n        const table = importRuns.getTable() as unknown as { queueJobId: PgColumn }\n        const matches = await importRuns.findMany({\n          where: eq(table.queueJobId, event.jobId),\n          limit: 1,\n        })\n        const row = matches[0]\n        if (!row) {\n          // No mirror row for this dead job. Either it was deleted\n          // by the operator, or the dead event is for a job\n          // unrelated to imports despite the type filter\n          // (shouldn't happen, but is cheap to log).\n          log?.warn('queue.job.dead with no matching import_run — skipping')\n          return\n        }\n\n        // Only transition rows that haven't already reached their\n        // own terminal state. A late dead-event must not overwrite\n        // a `succeeded` row that the worker reached via the normal\n        // path before the queue's dead-letter dispatch fired.\n        if (row.status !== 'running' && row.status !== 'pending') {\n          log?.info(\n            { importRunId: row.id, status: row.status },\n            'queue.job.dead arrived for a row already in a terminal state — leaving as-is',\n          )\n          return\n        }\n\n        // Dead-from-`pending` is the rarer + more interesting case:\n        // the worker process died (or never claimed) BEFORE it could\n        // flip the row to `running`. Log it at warn so ops can spot\n        // a queue+worker-startup pathology that the standard `running\n        // → failed` transition wouldn't surface. Dead-from-`running`\n        // is the documented \"crash mid-import\" case — info is enough.\n        if (row.status === 'pending') {\n          log?.warn(\n            { importRunId: row.id, attempts: event.attempts },\n            'queue.job.dead arrived for an import_run still in pending — worker crashed BEFORE claim/lookup',\n          )\n        }\n\n        await markFailed(importRuns, row.id, event.error)\n        log?.info(\n          { importRunId: row.id, attempts: event.attempts, priorStatus: row.status },\n          'queue.job.dead → import_run marked failed',\n        )\n      })\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/{xlsx-reader-Co4ulrnu.mjs → xlsx-reader-oApgZRJd.mjs}

@@ -1,2 +1,2 @@
-import{a as e}from"./runner-Cb1QPSt8.mjs";function t(e){if(e==null)return``;if(typeof e==`string`)return e;if(typeof e==`number`||typeof e==`boolean`)return String(e);if(e instanceof Date)return e.toISOString();if(`richText`in e&&Array.isArray(e.richText))return e.richText.map(e=>e.text).join(``);if(`text`in e&&typeof e.text==`string`)return e.text;if(`result`in e&&e.result!==void 0&&e.result!==null){let t=e.result;return t instanceof Date?t.toISOString():typeof t==`object`?``:String(t)}return``}function n(e){let n=[];if(Array.isArray(e))for(let r=1;r<e.length;r+=1)n[r-1]=t(e[r]);else for(let[r,i]of Object.entries(e)){let e=Number.parseInt(r,10);!Number.isNaN(e)&&e>=1&&(n[e-1]=t(i))}for(let e=0;e<n.length;e+=1)n[e]===void 0&&(n[e]=``);return n}async function*r(t){let{filePath:r,hasHeader:i=!0,headerRowIndex:a=0,sheet:o}=t,s=new(await(import(`exceljs`))).stream.xlsx.WorkbookReader(r,{worksheets:`emit`,sharedStrings:`cache`,styles:`ignore`,hyperlinks:`ignore`,entries:`ignore`}),c;if(o!==void 0&&(c=Number.parseInt(o,10),Number.isNaN(c)||c<1))throw Error(`Invalid xlsx sheet "${o}" — expected a 1-based worksheet index`);let l=0,u=0;for await(let t of s){if(u+=1,!(c===void 0?u===1:u===c)){for await(let e of t);continue}let r=0,o=null;for await(let s of t){r+=1;let t=n(s.values);if(i&&o===null){if(r<a+1)continue;o=t.map(e=>e.trim()),e(o);continue}l+=1;let c={};if(o)for(let e=0;e<o.length;e+=1){let n=o[e];n&&(c[n]=t[e]??``)}else for(let e=0;e<t.length;e+=1)c[String(e)]=t[e]??``;yield{rowNumber:l,row:c}}return}if(c!==void 0)throw Error(`xlsx worksheet ${c} not found`)}export{r as streamXlsx};
-//# sourceMappingURL=xlsx-reader-Co4ulrnu.mjs.map
+import{a as e}from"./runner-0r6UICjo.mjs";function t(e){if(e==null)return``;if(typeof e==`string`)return e;if(typeof e==`number`||typeof e==`boolean`)return String(e);if(e instanceof Date)return e.toISOString();if(`richText`in e&&Array.isArray(e.richText))return e.richText.map(e=>e.text).join(``);if(`text`in e&&typeof e.text==`string`)return e.text;if(`result`in e&&e.result!==void 0&&e.result!==null){let t=e.result;return t instanceof Date?t.toISOString():typeof t==`object`?``:String(t)}return``}function n(e){let n=[];if(Array.isArray(e))for(let r=1;r<e.length;r+=1)n[r-1]=t(e[r]);else for(let[r,i]of Object.entries(e)){let e=Number.parseInt(r,10);!Number.isNaN(e)&&e>=1&&(n[e-1]=t(i))}for(let e=0;e<n.length;e+=1)n[e]===void 0&&(n[e]=``);return n}async function*r(t){let{filePath:r,hasHeader:i=!0,headerRowIndex:a=0,sheet:o}=t,s=new(await(import(`exceljs`))).stream.xlsx.WorkbookReader(r,{worksheets:`emit`,sharedStrings:`cache`,styles:`ignore`,hyperlinks:`ignore`,entries:`ignore`}),c;if(o!==void 0&&(c=Number.parseInt(o,10),Number.isNaN(c)||c<1))throw Error(`Invalid xlsx sheet "${o}" — expected a 1-based worksheet index`);let l=0,u=0;for await(let t of s){if(u+=1,!(c===void 0?u===1:u===c)){for await(let e of t);continue}let r=0,o=null;for await(let s of t){r+=1;let t=n(s.values);if(i&&o===null){if(r<a+1)continue;o=t.map(e=>e.trim()),e(o);continue}l+=1;let c={};if(o)for(let e=0;e<o.length;e+=1){let n=o[e];n&&(c[n]=t[e]??``)}else for(let e=0;e<t.length;e+=1)c[String(e)]=t[e]??``;yield{rowNumber:l,row:c}}return}if(c!==void 0)throw Error(`xlsx worksheet ${c} not found`)}export{r as streamXlsx};
+//# sourceMappingURL=xlsx-reader-oApgZRJd.mjs.map

package/dist/{xlsx-reader-Co4ulrnu.mjs.map → xlsx-reader-oApgZRJd.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"xlsx-reader-Co4ulrnu.mjs","names":[],"sources":["../src/xlsx-reader.ts"],"sourcesContent":["/**\n * Streaming XLSX reader (commerce-demo phase 02, D005) — the exceljs branch of\n * the feed reader. Yields the SAME `AsyncIterable<{ rowNumber, row }>` contract as\n * the csv-parse `streamFeed`, so the runner / transform layer downstream is\n * format-agnostic.\n *\n * **exceljs over SheetJS** (R02): we parse operator-uploaded spreadsheets — the\n * exact threat model of the unfixed npm `xlsx` prototype-pollution CVE\n * (CVE-2023-30533). exceljs is MIT, ships its own types, has a real streaming\n * `WorkbookReader`, and carries no equivalent advisory.\n *\n * **exceljs is `await import()`-ed**, never statically imported, so it stays out\n * of this package's static module graph — heavy + Node-only, it must not be\n * inlinable into any `*-ui` server-pages bundle (CLAUDE.md bundle budgets). The\n * `read-feed` dispatcher additionally only loads THIS module for `format: 'xlsx'`.\n */\n\nimport type { CellValue } from 'exceljs'\nimport { assertUniqueHeaders, type StreamFeedRow } from './streaming.js'\n\nexport interface XlsxReadOptions {\n  /** Path to the .xlsx file on local disk. */\n  filePath: string\n  /** First row is the header (column names). `false` → positional `{ \"0\": … }` keys. Default `true`. */\n  hasHeader?: boolean\n  /** 0-based index of the header row (rows before it are skipped). Default `0`. */\n  headerRowIndex?: number\n  /** Worksheet to read, as a 1-based index string. Omit → the first worksheet. */\n  sheet?: string\n}\n\n/** Convert one exceljs cell value to a plain string (feeds are text/number cells). */\nfunction cellToString(v: CellValue): string {\n  if (v === null || v === undefined) return ''\n  if (typeof v === 'string') return v\n  if (typeof v === 'number' || typeof v === 'boolean') return String(v)\n  if (v instanceof Date) return v.toISOString()\n  // Object cell values: rich text, hyperlink, formula result, error.\n  if ('richText' in v && Array.isArray(v.richText)) {\n    return v.richText.map((r) => r.text).join('')\n  }\n  if ('text' in v && typeof v.text === 'string') return v.text\n  if ('result' in v && v.result !== undefined && v.result !== null) {\n    const r = v.result\n    if (r instanceof Date) return r.toISOString()\n    // A nested error object (formula error) surfaces as empty; primitives stringify.\n    return typeof r === 'object' ? '' : String(r)\n  }\n  return ''\n}\n\n/** Normalise an exceljs `row.values` (1-indexed array OR object form) to a 0-indexed string[]. */\nfunction rowCells(values: CellValue[] | { [key: string]: CellValue }): string[] {\n  const out: string[] = []\n  if (Array.isArray(values)) {\n    // exceljs row arrays are 1-indexed (`values[0]` is empty); shift to 0-based.\n    for (let i = 1; i < values.length; i += 1) out[i - 1] = cellToString(values[i])\n  } else {\n    for (const [k, v] of Object.entries(values)) {\n      const idx = Number.parseInt(k, 10)\n      if (!Number.isNaN(idx) && idx >= 1) out[idx - 1] = cellToString(v)\n    }\n  }\n  // Fill any holes (sparse rows) with empty strings — the contract is \"missing\n  // cell = ''\", matching streamFeed.\n  for (let i = 0; i < out.length; i += 1) if (out[i] === undefined) out[i] = ''\n  return out\n}\n\n/**\n * Async-iterable over the data rows of an .xlsx file. `rowNumber` is the 1-based\n * DATA row index (header excluded). Cell values are coerced to strings so the\n * mapping engine's per-column transforms (which expect raw string cells) apply\n * uniformly across csv/tsv/xlsx.\n */\nexport async function* streamXlsx(options: XlsxReadOptions): AsyncIterable<StreamFeedRow> {\n  const { filePath, hasHeader = true, headerRowIndex = 0, sheet } = options\n  const ExcelJS = await import('exceljs')\n  const reader = new ExcelJS.stream.xlsx.WorkbookReader(filePath, {\n    worksheets: 'emit',\n    sharedStrings: 'cache',\n    styles: 'ignore',\n    hyperlinks: 'ignore',\n    entries: 'ignore',\n  })\n\n  // `WorksheetReader` doesn't expose its sheet id, so count emitted worksheets\n  // (1-based) to match the configured `sheet`. Default: the first worksheet.\n  // A provided-but-invalid sheet FAILS FAST rather than silently reading sheet 1.\n  let targetSheetIndex: number | undefined\n  if (sheet !== undefined) {\n    targetSheetIndex = Number.parseInt(sheet, 10)\n    if (Number.isNaN(targetSheetIndex) || targetSheetIndex < 1) {\n      throw new Error(`Invalid xlsx sheet \"${sheet}\" — expected a 1-based worksheet index`)\n    }\n  }\n  let dataRowNumber = 0\n  let sheetIndex = 0\n\n  for await (const worksheet of reader) {\n    sheetIndex += 1\n    const isTarget =\n      targetSheetIndex === undefined ? sheetIndex === 1 : sheetIndex === targetSheetIndex\n\n    if (!isTarget) {\n      // Drain a non-target worksheet so the underlying zip stream advances to the\n      // next; exceljs's streaming reader stalls if a worksheet is left unconsumed.\n      for await (const _skip of worksheet) {\n        void _skip\n      }\n      continue\n    }\n\n    let excelRowNum = 0\n    let header: string[] | null = null\n    for await (const row of worksheet) {\n      excelRowNum += 1\n      const cells = rowCells(row.values)\n\n      if (hasHeader && header === null) {\n        // Skip rows before the configured header row, then capture it (trimmed).\n        if (excelRowNum < headerRowIndex + 1) continue\n        header = cells.map((c) => c.trim())\n        assertUniqueHeaders(header)\n        continue\n      }\n\n      dataRowNumber += 1\n      const rec: Record<string, string> = {}\n      if (header) {\n        for (let i = 0; i < header.length; i += 1) {\n          const key = header[i]\n          if (key) rec[key] = cells[i] ?? ''\n        }\n      } else {\n        for (let i = 0; i < cells.length; i += 1) rec[String(i)] = cells[i] ?? ''\n      }\n      yield { rowNumber: dataRowNumber, row: rec }\n    }\n\n    // Target worksheet fully read — done (remaining sheets are not consumed).\n    return\n  }\n\n  // Reached only when a specific sheet was requested but never matched — the\n  // first-sheet default always returns inside the loop on a non-empty workbook.\n  if (targetSheetIndex !== undefined) {\n    throw new Error(`xlsx worksheet ${targetSheetIndex} not found`)\n  }\n}\n"],"mappings":"0CAgCA,SAAS,EAAa,EAAsB,CAC1C,GAAI,GAAM,KAAyB,MAAO,GAC1C,GAAI,OAAO,GAAM,SAAU,OAAO,EAClC,GAAI,OAAO,GAAM,UAAY,OAAO,GAAM,UAAW,OAAO,OAAO,CAAC,EACpE,GAAI,aAAa,KAAM,OAAO,EAAE,YAAY,EAE5C,GAAI,aAAc,GAAK,MAAM,QAAQ,EAAE,QAAQ,EAC7C,OAAO,EAAE,SAAS,IAAK,GAAM,EAAE,IAAI,CAAC,CAAC,KAAK,EAAE,EAE9C,GAAI,SAAU,GAAK,OAAO,EAAE,MAAS,SAAU,OAAO,EAAE,KACxD,GAAI,WAAY,GAAK,EAAE,SAAW,IAAA,IAAa,EAAE,SAAW,KAAM,CAChE,IAAM,EAAI,EAAE,OAGZ,OAFI,aAAa,KAAa,EAAE,YAAY,EAErC,OAAO,GAAM,SAAW,GAAK,OAAO,CAAC,CAC9C,CACA,MAAO,EACT,CAGA,SAAS,EAAS,EAA8D,CAC9E,IAAM,EAAgB,CAAC,EACvB,GAAI,MAAM,QAAQ,CAAM,EAEtB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,OAAQ,GAAK,EAAG,EAAI,EAAI,GAAK,EAAa,EAAO,EAAE,OAE9E,IAAK,GAAM,CAAC,EAAG,KAAM,OAAO,QAAQ,CAAM,EAAG,CAC3C,IAAM,EAAM,OAAO,SAAS,EAAG,EAAE,EAC7B,CAAC,OAAO,MAAM,CAAG,GAAK,GAAO,IAAG,EAAI,EAAM,GAAK,EAAa,CAAC,EACnE,CAIF,IAAK,IAAI,EAAI,EAAG,EAAI,EAAI,OAAQ,GAAK,EAAO,EAAI,KAAO,IAAA,KAAW,EAAI,GAAK,IAC3E,OAAO,CACT,CAQA,eAAuB,EAAW,EAAwD,CACxF,GAAM,CAAE,WAAU,YAAY,GAAM,iBAAiB,EAAG,SAAU,EAE5D,EAAS,IAAI,MADG,OAAO,YAAA,CACF,OAAO,KAAK,eAAe,EAAU,CAC9D,WAAY,OACZ,cAAe,QACf,OAAQ,SACR,WAAY,SACZ,QAAS,QACX,CAAC,EAKG,EACJ,GAAI,IAAU,IAAA,KACZ,EAAmB,OAAO,SAAS,EAAO,EAAE,EACxC,OAAO,MAAM,CAAgB,GAAK,EAAmB,GACvD,MAAU,MAAM,uBAAuB,EAAM,uCAAuC,EAGxF,IAAI,EAAgB,EAChB,EAAa,EAEjB,UAAW,IAAM,KAAa,EAAQ,CAKpC,GAJA,GAAc,EAIV,EAFF,IAAqB,IAAA,GAAY,IAAe,EAAI,IAAe,GAEtD,CAGb,UAAW,IAAM,KAAS,GAG1B,QACF,CAEA,IAAI,EAAc,EACd,EAA0B,KAC9B,UAAW,IAAM,KAAO,EAAW,CACjC,GAAe,EACf,IAAM,EAAQ,EAAS,EAAI,MAAM,EAEjC,GAAI,GAAa,IAAW,KAAM,CAEhC,GAAI,EAAc,EAAiB,EAAG,SACtC,EAAS,EAAM,IAAK,GAAM,EAAE,KAAK,CAAC,EAClC,EAAoB,CAAM,EAC1B,QACF,CAEA,GAAiB,EACjB,IAAM,EAA8B,CAAC,EACrC,GAAI,EACF,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,OAAQ,GAAK,EAAG,CACzC,IAAM,EAAM,EAAO,GACf,IAAK,EAAI,GAAO,EAAM,IAAM,GAClC,MAEA,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,OAAQ,GAAK,EAAG,EAAI,OAAO,CAAC,GAAK,EAAM,IAAM,GAEzE,KAAM,CAAE,UAAW,EAAe,IAAK,CAAI,CAC7C,CAGA,MACF,CAIA,GAAI,IAAqB,IAAA,GACvB,MAAU,MAAM,kBAAkB,EAAiB,WAAW,CAElE"}
+{"version":3,"file":"xlsx-reader-oApgZRJd.mjs","names":[],"sources":["../src/xlsx-reader.ts"],"sourcesContent":["/**\n * Streaming XLSX reader (commerce-demo phase 02, D005) — the exceljs branch of\n * the feed reader. Yields the SAME `AsyncIterable<{ rowNumber, row }>` contract as\n * the csv-parse `streamFeed`, so the runner / transform layer downstream is\n * format-agnostic.\n *\n * **exceljs over SheetJS** (R02): we parse operator-uploaded spreadsheets — the\n * exact threat model of the unfixed npm `xlsx` prototype-pollution CVE\n * (CVE-2023-30533). exceljs is MIT, ships its own types, has a real streaming\n * `WorkbookReader`, and carries no equivalent advisory.\n *\n * **exceljs is `await import()`-ed**, never statically imported, so it stays out\n * of this package's static module graph — heavy + Node-only, it must not be\n * inlinable into any `*-ui` server-pages bundle (CLAUDE.md bundle budgets). The\n * `read-feed` dispatcher additionally only loads THIS module for `format: 'xlsx'`.\n */\n\nimport type { CellValue } from 'exceljs'\nimport { assertUniqueHeaders, type StreamFeedRow } from './streaming.js'\n\nexport interface XlsxReadOptions {\n  /** Path to the .xlsx file on local disk. */\n  filePath: string\n  /** First row is the header (column names). `false` → positional `{ \"0\": … }` keys. Default `true`. */\n  hasHeader?: boolean\n  /** 0-based index of the header row (rows before it are skipped). Default `0`. */\n  headerRowIndex?: number\n  /** Worksheet to read, as a 1-based index string. Omit → the first worksheet. */\n  sheet?: string\n}\n\n/** Convert one exceljs cell value to a plain string (feeds are text/number cells). */\nfunction cellToString(v: CellValue): string {\n  if (v === null || v === undefined) return ''\n  if (typeof v === 'string') return v\n  if (typeof v === 'number' || typeof v === 'boolean') return String(v)\n  if (v instanceof Date) return v.toISOString()\n  // Object cell values: rich text, hyperlink, formula result, error.\n  if ('richText' in v && Array.isArray(v.richText)) {\n    return v.richText.map((r) => r.text).join('')\n  }\n  if ('text' in v && typeof v.text === 'string') return v.text\n  if ('result' in v && v.result !== undefined && v.result !== null) {\n    const r = v.result\n    if (r instanceof Date) return r.toISOString()\n    // A nested error object (formula error) surfaces as empty; primitives stringify.\n    return typeof r === 'object' ? '' : String(r)\n  }\n  return ''\n}\n\n/** Normalise an exceljs `row.values` (1-indexed array OR object form) to a 0-indexed string[]. */\nfunction rowCells(values: CellValue[] | { [key: string]: CellValue }): string[] {\n  const out: string[] = []\n  if (Array.isArray(values)) {\n    // exceljs row arrays are 1-indexed (`values[0]` is empty); shift to 0-based.\n    for (let i = 1; i < values.length; i += 1) out[i - 1] = cellToString(values[i])\n  } else {\n    for (const [k, v] of Object.entries(values)) {\n      const idx = Number.parseInt(k, 10)\n      if (!Number.isNaN(idx) && idx >= 1) out[idx - 1] = cellToString(v)\n    }\n  }\n  // Fill any holes (sparse rows) with empty strings — the contract is \"missing\n  // cell = ''\", matching streamFeed.\n  for (let i = 0; i < out.length; i += 1) if (out[i] === undefined) out[i] = ''\n  return out\n}\n\n/**\n * Async-iterable over the data rows of an .xlsx file. `rowNumber` is the 1-based\n * DATA row index (header excluded). Cell values are coerced to strings so the\n * mapping engine's per-column transforms (which expect raw string cells) apply\n * uniformly across csv/tsv/xlsx.\n */\nexport async function* streamXlsx(options: XlsxReadOptions): AsyncIterable<StreamFeedRow> {\n  const { filePath, hasHeader = true, headerRowIndex = 0, sheet } = options\n  const ExcelJS = await import('exceljs')\n  const reader = new ExcelJS.stream.xlsx.WorkbookReader(filePath, {\n    worksheets: 'emit',\n    sharedStrings: 'cache',\n    styles: 'ignore',\n    hyperlinks: 'ignore',\n    entries: 'ignore',\n  })\n\n  // `WorksheetReader` doesn't expose its sheet id, so count emitted worksheets\n  // (1-based) to match the configured `sheet`. Default: the first worksheet.\n  // A provided-but-invalid sheet FAILS FAST rather than silently reading sheet 1.\n  let targetSheetIndex: number | undefined\n  if (sheet !== undefined) {\n    targetSheetIndex = Number.parseInt(sheet, 10)\n    if (Number.isNaN(targetSheetIndex) || targetSheetIndex < 1) {\n      throw new Error(`Invalid xlsx sheet \"${sheet}\" — expected a 1-based worksheet index`)\n    }\n  }\n  let dataRowNumber = 0\n  let sheetIndex = 0\n\n  for await (const worksheet of reader) {\n    sheetIndex += 1\n    const isTarget =\n      targetSheetIndex === undefined ? sheetIndex === 1 : sheetIndex === targetSheetIndex\n\n    if (!isTarget) {\n      // Drain a non-target worksheet so the underlying zip stream advances to the\n      // next; exceljs's streaming reader stalls if a worksheet is left unconsumed.\n      for await (const _skip of worksheet) {\n        void _skip\n      }\n      continue\n    }\n\n    let excelRowNum = 0\n    let header: string[] | null = null\n    for await (const row of worksheet) {\n      excelRowNum += 1\n      const cells = rowCells(row.values)\n\n      if (hasHeader && header === null) {\n        // Skip rows before the configured header row, then capture it (trimmed).\n        if (excelRowNum < headerRowIndex + 1) continue\n        header = cells.map((c) => c.trim())\n        assertUniqueHeaders(header)\n        continue\n      }\n\n      dataRowNumber += 1\n      const rec: Record<string, string> = {}\n      if (header) {\n        for (let i = 0; i < header.length; i += 1) {\n          const key = header[i]\n          if (key) rec[key] = cells[i] ?? ''\n        }\n      } else {\n        for (let i = 0; i < cells.length; i += 1) rec[String(i)] = cells[i] ?? ''\n      }\n      yield { rowNumber: dataRowNumber, row: rec }\n    }\n\n    // Target worksheet fully read — done (remaining sheets are not consumed).\n    return\n  }\n\n  // Reached only when a specific sheet was requested but never matched — the\n  // first-sheet default always returns inside the loop on a non-empty workbook.\n  if (targetSheetIndex !== undefined) {\n    throw new Error(`xlsx worksheet ${targetSheetIndex} not found`)\n  }\n}\n"],"mappings":"0CAgCA,SAAS,EAAa,EAAsB,CAC1C,GAAI,GAAM,KAAyB,MAAO,GAC1C,GAAI,OAAO,GAAM,SAAU,OAAO,EAClC,GAAI,OAAO,GAAM,UAAY,OAAO,GAAM,UAAW,OAAO,OAAO,CAAC,EACpE,GAAI,aAAa,KAAM,OAAO,EAAE,YAAY,EAE5C,GAAI,aAAc,GAAK,MAAM,QAAQ,EAAE,QAAQ,EAC7C,OAAO,EAAE,SAAS,IAAK,GAAM,EAAE,IAAI,CAAC,CAAC,KAAK,EAAE,EAE9C,GAAI,SAAU,GAAK,OAAO,EAAE,MAAS,SAAU,OAAO,EAAE,KACxD,GAAI,WAAY,GAAK,EAAE,SAAW,IAAA,IAAa,EAAE,SAAW,KAAM,CAChE,IAAM,EAAI,EAAE,OAGZ,OAFI,aAAa,KAAa,EAAE,YAAY,EAErC,OAAO,GAAM,SAAW,GAAK,OAAO,CAAC,CAC9C,CACA,MAAO,EACT,CAGA,SAAS,EAAS,EAA8D,CAC9E,IAAM,EAAgB,CAAC,EACvB,GAAI,MAAM,QAAQ,CAAM,EAEtB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,OAAQ,GAAK,EAAG,EAAI,EAAI,GAAK,EAAa,EAAO,EAAE,OAE9E,IAAK,GAAM,CAAC,EAAG,KAAM,OAAO,QAAQ,CAAM,EAAG,CAC3C,IAAM,EAAM,OAAO,SAAS,EAAG,EAAE,EAC7B,CAAC,OAAO,MAAM,CAAG,GAAK,GAAO,IAAG,EAAI,EAAM,GAAK,EAAa,CAAC,EACnE,CAIF,IAAK,IAAI,EAAI,EAAG,EAAI,EAAI,OAAQ,GAAK,EAAO,EAAI,KAAO,IAAA,KAAW,EAAI,GAAK,IAC3E,OAAO,CACT,CAQA,eAAuB,EAAW,EAAwD,CACxF,GAAM,CAAE,WAAU,YAAY,GAAM,iBAAiB,EAAG,SAAU,EAE5D,EAAS,IAAI,MADG,OAAO,YAAA,CACF,OAAO,KAAK,eAAe,EAAU,CAC9D,WAAY,OACZ,cAAe,QACf,OAAQ,SACR,WAAY,SACZ,QAAS,QACX,CAAC,EAKG,EACJ,GAAI,IAAU,IAAA,KACZ,EAAmB,OAAO,SAAS,EAAO,EAAE,EACxC,OAAO,MAAM,CAAgB,GAAK,EAAmB,GACvD,MAAU,MAAM,uBAAuB,EAAM,uCAAuC,EAGxF,IAAI,EAAgB,EAChB,EAAa,EAEjB,UAAW,IAAM,KAAa,EAAQ,CAKpC,GAJA,GAAc,EAIV,EAFF,IAAqB,IAAA,GAAY,IAAe,EAAI,IAAe,GAEtD,CAGb,UAAW,IAAM,KAAS,GAG1B,QACF,CAEA,IAAI,EAAc,EACd,EAA0B,KAC9B,UAAW,IAAM,KAAO,EAAW,CACjC,GAAe,EACf,IAAM,EAAQ,EAAS,EAAI,MAAM,EAEjC,GAAI,GAAa,IAAW,KAAM,CAEhC,GAAI,EAAc,EAAiB,EAAG,SACtC,EAAS,EAAM,IAAK,GAAM,EAAE,KAAK,CAAC,EAClC,EAAoB,CAAM,EAC1B,QACF,CAEA,GAAiB,EACjB,IAAM,EAA8B,CAAC,EACrC,GAAI,EACF,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,OAAQ,GAAK,EAAG,CACzC,IAAM,EAAM,EAAO,GACf,IAAK,EAAI,GAAO,EAAM,IAAM,GAClC,MAEA,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,OAAQ,GAAK,EAAG,EAAI,OAAO,CAAC,GAAK,EAAM,IAAM,GAEzE,KAAM,CAAE,UAAW,EAAe,IAAK,CAAI,CAC7C,CAGA,MACF,CAIA,GAAI,IAAqB,IAAA,GACvB,MAAU,MAAM,kBAAkB,EAAiB,WAAW,CAElE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@murumets-ee/imports",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "license": "Elastic-2.0",
   "type": "module",
   "exports": {
@@ -45,13 +45,13 @@
     "drizzle-orm": "^0.45.2",
     "exceljs": "^4.4.0",
     "zod": "^3.24.1",
-    "@murumets-ee/core": "0.33.0",
-    "@murumets-ee/db": "0.33.0",
-    "@murumets-ee/entity": "0.33.0",
-    "@murumets-ee/logging": "0.33.0",
-    "@murumets-ee/queue": "0.33.0",
-    "@murumets-ee/search-elasticsearch": "0.33.0",
-    "@murumets-ee/storage": "0.33.0"
+    "@murumets-ee/core": "0.34.0",
+    "@murumets-ee/db": "0.34.0",
+    "@murumets-ee/entity": "0.34.0",
+    "@murumets-ee/logging": "0.34.0",
+    "@murumets-ee/queue": "0.34.0",
+    "@murumets-ee/search-elasticsearch": "0.34.0",
+    "@murumets-ee/storage": "0.34.0"
   },
   "devDependencies": {
     "@types/node": "^20.19.42",

package/dist/runner-Cb1QPSt8.mjs

@@ -1,2 +0,0 @@
-import{z as e}from"zod";import{createReadStream as t}from"node:fs";import{parse as n}from"csv-parse";import{bulkUpsert as r}from"@murumets-ee/search-elasticsearch";const i=50,a=5;var o=class{patterns=new Map;maxPatterns;maxSamplesPerPattern;droppedSignatures=0;constructor(e={}){this.maxPatterns=e.maxPatterns??50,this.maxSamplesPerPattern=e.maxSamplesPerPattern??5}addError(e,t,n,r,i){let a=`${t}:${r??`GENERAL`}:${n}`,o=this.patterns.get(a);if(!o){if(this.patterns.size>=this.maxPatterns){this.droppedSignatures+=1;return}o={errorType:t,field:r??null,message:n,count:0,firstOccurrence:e,lastOccurrence:e,samples:[]},this.patterns.set(a,o)}o.count+=1,o.lastOccurrence=e,o.samples.length<this.maxSamplesPerPattern&&o.samples.push({rowNumber:e,rowData:i})}getTotalErrorCount(){let e=0;for(let t of this.patterns.values())e+=t.count;return e}getDistinctPatternCount(){return this.patterns.size}getDroppedSignatureCount(){return this.droppedSignatures}getTopPatterns(){let e=Array.from(this.patterns.values()).sort((e,t)=>t.count-e.count),t=e.reduce((e,t)=>e+t.count,0);return e.map(e=>({errorType:e.errorType,field:e.field,message:e.message,count:e.count,firstOccurrence:e.firstOccurrence,lastOccurrence:e.lastOccurrence,samples:e.samples.slice(),percentage:t>0?e.count/t*100:0}))}snapshot(){return{totalErrors:this.getTotalErrorCount(),distinctPatterns:this.getDistinctPatternCount(),droppedSignatures:this.droppedSignatures,patterns:this.getTopPatterns()}}};function s(e){let t=new Set;for(let n of e)if(n!==``){if(t.has(n))throw Error(`Duplicate header "${n}" after trimming — column names must be unique`);t.add(n)}}async function c(e,n={}){let{hasHeader:r=!0}=n,i=t(e),a=0,o=0;for await(let e of i){for(let t=0;t<e.length;t+=1)e[t]===10&&(a+=1);e.length>0&&(o=e[e.length-1]??0)}return o!==0&&o!==10&&(a+=1),r?Math.max(0,a-1):a}async function*l(e){let{filePath:r,delimiter:i=`	`,hasHeader:a=!0,columns:o,relaxColumnCount:c=!1,quote:l=!1}=e,u=o?Array.from(o):a?e=>{let t=e.map(e=>e.trim());return s(t),t}:!1,d=t(r),f=d.pipe(n({delimiter:i,columns:u,bom:!0,skip_empty_lines:!0,relax_column_count:c,quote:l})),p=0;try{for await(let e of f){p+=1;let t={};if(Array.isArray(e)){let n=e;for(let e=0;e<n.length;e+=1)t[String(e)]=n[e]??``}else for(let[n,r]of Object.entries(e))t[n]=r??``;yield{rowNumber:p,row:t}}}finally{d.destroy()}}const u=e.object({format:e.enum([`csv`,`tsv`,`xlsx`]).optional(),delimiter:e.string().min(1).max(4).optional(),hasHeader:e.boolean().optional(),headerRowIndex:e.number().int().min(0).optional(),sheet:e.string().min(1).max(128).optional()}).strict();function d(e){let t=e.delimiter??(e.format===`csv`?`,`:`	`);return{filePath:e.filePath,delimiter:t,...e.hasHeader!==void 0&&{hasHeader:e.hasHeader},...e.columns!==void 0&&{columns:e.columns},...e.relaxColumnCount!==void 0&&{relaxColumnCount:e.relaxColumnCount},...e.quote!==void 0&&{quote:e.quote}}}async function*f(e){if(e.format===`xlsx`){let{streamXlsx:t}=await import(`./xlsx-reader-Co4ulrnu.mjs`);yield*t({filePath:e.filePath,...e.hasHeader!==void 0&&{hasHeader:e.hasHeader},...e.headerRowIndex!==void 0&&{headerRowIndex:e.headerRowIndex},...e.sheet!==void 0&&{sheet:e.sheet}});return}yield*l(d(e))}const p=1e3;async function m(e){let{importRunId:t,runLabel:n,params:i,transform:a,feed:s,esClient:c,esIndex:l,batchSize:u=p,onProgress:d,rowLimit:m,signal:h,errorTracker:g=new o,logger:_}=e;if(u<1)throw Error(`batchSize must be >= 1 (got ${u})`);let v=Date.now();_?.info({importRunId:t,runLabel:n,batchSize:u,esIndex:l},`imports.runner: started`);let y=0,b=0,x=0,S=0,C=0,w=[],T=async()=>{if(w.length===0)return;let e=w;w=[];let n=Date.now(),i;try{i=await r(c,{index:l,docs:e.map(({id:e,doc:t})=>({id:e,doc:t})),...h!==void 0&&{signal:h}})}catch(t){let n=h?.aborted??(t instanceof Error&&(t.name===`AbortError`||/abort/i.test(t.message)))?`aborted`:`bulk_request_failed`,r=t instanceof Error?t.message:String(t);for(let{rowNumber:t}of e)g.addError(t,n,r,void 0,null);throw x+=e.length,t}b+=i.succeeded,x+=i.failures.length,C+=1;let a=Date.now()-n,o=(Date.now()-v)/1e3;if(_?.info({importRunId:t,batch:C,flushMs:a,submitted:e.length,succeeded:i.succeeded,failed:i.failures.length,rowsRead:y,rowsPerSecond:o>0?Math.round(y/o):0},`imports.runner: batch flushed`),i.failures.length>0){let t=new Map(e.map(e=>[e.id,e.rowNumber]));for(let e of i.failures){let n=t.get(e.id)??-1;g.addError(n,e.type,e.reason,void 0,{id:e.id})}}if(d){let e=(Date.now()-v)/1e3;d({rowsRead:y,rowsSucceeded:b,rowsFailed:x,rowsSkipped:S,batchesCompleted:C,elapsedSeconds:e,rowsPerSecond:e>0?y/e:0,distinctErrorPatterns:g.getDistinctPatternCount()})}},E=u,D=new Map;for await(let{rowNumber:e,row:r}of f(s)){if(h?.aborted||m!==void 0&&y>=m)break;if(y+=1,y===1&&_?.info({importRunId:t,rowNumber:e,sampleKeys:Object.keys(r)},`imports.runner: STREAM_FIRST_ROW`),y%E===0){let e=(Date.now()-v)/1e3;_?.info({importRunId:t,rowsRead:y,rowsSucceeded:b,rowsFailed:x,rowsSkipped:S,pending:w.length,elapsedSec:Math.round(e*10)/10,rowsPerSecond:e>0?Math.round(y/e):0,distinctFirstErrorTypes:D.size},`imports.runner: STREAM_TICK`)}let o={importRunId:t,params:i,runLabel:n,rowNumber:e},s;try{s=await a(r,o)}catch(n){let i=n instanceof Error?n.message:String(n);g.addError(e,`transform_threw`,i,void 0,r),D.has(`transform_threw`)||(D.set(`transform_threw`,{rowNumber:e,message:i}),_?.warn({importRunId:t,rowNumber:e,errorType:`transform_threw`,message:i},`imports.runner: FIRST_ERROR transform_threw`)),x+=1;continue}if(s.kind===`skip`){S+=1;continue}if(s.kind===`error`){g.addError(e,s.error.errorType,s.error.message,s.error.field,r),D.has(s.error.errorType)||(D.set(s.error.errorType,{rowNumber:e,message:s.error.message}),_?.warn({importRunId:t,rowNumber:e,errorType:s.error.errorType,field:s.error.field,message:s.error.message},`imports.runner: FIRST_ERROR ${s.error.errorType}`)),x+=1;continue}w.push({id:s.id,doc:s.doc,rowNumber:e}),w.length>=u&&await T()}await T();let O=(Date.now()-v)/1e3;return _?.info({importRunId:t,rowsRead:y,rowsSucceeded:b,rowsFailed:x,rowsSkipped:S,batchesCompleted:C,totalSec:Math.round(O*10)/10,rowsPerSecond:O>0?Math.round(y/O):0},`imports.runner: finished`),{rowsRead:y,rowsSucceeded:b,rowsFailed:x,rowsSkipped:S,batchesCompleted:C,errors:g.snapshot()}}export{s as a,i as c,f as i,a as l,m as n,c as o,u as r,l as s,p as t,o as u};
-//# sourceMappingURL=runner-Cb1QPSt8.mjs.map

package/dist/runner-Cb1QPSt8.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"runner-Cb1QPSt8.mjs","names":[],"sources":["../src/error-tracker.ts","../src/streaming.ts","../src/read-feed.ts","../src/runner.ts"],"sourcesContent":["/**\n * Aggregates per-row errors into top-N pattern buckets so a feed of 1M\n * malformed rows surfaces as a handful of actionable signatures rather\n * than a million identical strings.\n *\n * Lifted from giga-test (`backend/src/workers/csv-importer.ts`) and\n * generalized:\n * - Configurable caps so the importer can tune memory bounds per run.\n * - Pure data — no logging side effects, no I/O.\n * - JSON-serialisable output via {@link ErrorTracker.snapshot} for the\n *   `import_run.errorSummary` column.\n *\n * Pattern signature shape: `${errorType}:${field || 'GENERAL'}:${message}`.\n * Same `errorType + field + message` collapses to one bucket; differing\n * messages stay separate. This is intentional: a parser error on column\n * `NetPrice/Discount` (\"invalid number 'NA,5'\") and the same on column\n * `GrossPrice` are operationally distinct even if the parser is the same.\n *\n * Memory bounds: the patterns map is capped at `maxPatterns`. Once full,\n * additional NEW signatures are dropped — known patterns keep accumulating\n * counts. This is the \"top-N most common\" model: rare-but-novel errors\n * past the cap are invisible, but the cap protects against a runaway\n * adversarial feed exploding the map. Sample arrays are independently\n * capped at `maxSamplesPerPattern`.\n */\n\n/**\n * Recursively-defined JSON-serialisable value. Mirrors the shape of\n * `JsonValue` in `@murumets-ee/entity` without taking a dependency on\n * that package — error-tracker is otherwise standalone, and the\n * `ImportRun.errorSummary` JSONB column accepts anything in this shape.\n */\nexport type ImportJsonValue =\n  | string\n  | number\n  | boolean\n  | null\n  | ImportJsonValue[]\n  | { [key: string]: ImportJsonValue }\n\n/** One sample row attached to a pattern. `rowData` is the originally-parsed row. */\nexport interface ErrorSample {\n  rowNumber: number\n  rowData: ImportJsonValue\n}\n\n/** Public shape of an aggregated pattern as returned by {@link ErrorTracker.getTopPatterns}. */\nexport interface ErrorPattern {\n  errorType: string\n  field: string | null\n  message: string\n  count: number\n  firstOccurrence: number\n  lastOccurrence: number\n  samples: ReadonlyArray<ErrorSample>\n  /** `count / totalErrors`, scaled 0..100. `0` when there are zero errors total. */\n  percentage: number\n}\n\nexport interface ErrorTrackerConfig {\n  /** Hard cap on distinct signatures. Defaults to 50. New signatures past the cap are dropped. */\n  maxPatterns?: number\n  /** Hard cap on samples retained per pattern. Defaults to 5. Excess samples are dropped. */\n  maxSamplesPerPattern?: number\n}\n\n/** Default caps — match giga-test for compatibility. */\nexport const DEFAULT_MAX_PATTERNS = 50\nexport const DEFAULT_MAX_SAMPLES_PER_PATTERN = 5\n\ninterface InternalPattern {\n  errorType: string\n  field: string | null\n  message: string\n  count: number\n  firstOccurrence: number\n  lastOccurrence: number\n  samples: ErrorSample[]\n}\n\nexport class ErrorTracker {\n  private readonly patterns = new Map<string, InternalPattern>()\n  private readonly maxPatterns: number\n  private readonly maxSamplesPerPattern: number\n  private droppedSignatures = 0\n\n  constructor(config: ErrorTrackerConfig = {}) {\n    this.maxPatterns = config.maxPatterns ?? DEFAULT_MAX_PATTERNS\n    this.maxSamplesPerPattern = config.maxSamplesPerPattern ?? DEFAULT_MAX_SAMPLES_PER_PATTERN\n  }\n\n  /**\n   * Record one error. Same `(errorType, field, message)` triple bumps the\n   * existing bucket; a new triple opens a new one (subject to {@link maxPatterns}).\n   *\n   * `field` is optional — pass `undefined` for errors not tied to a single\n   * column (e.g. parse errors at row level). Internally normalised to the\n   * literal string `'GENERAL'` so it shares a bucket with other genericised\n   * errors of the same type+message.\n   */\n  addError(\n    rowNumber: number,\n    errorType: string,\n    message: string,\n    field: string | undefined,\n    rowData: ImportJsonValue,\n  ): void {\n    const fieldKey = field ?? 'GENERAL'\n    const signature = `${errorType}:${fieldKey}:${message}`\n\n    let pattern = this.patterns.get(signature)\n    if (!pattern) {\n      if (this.patterns.size >= this.maxPatterns) {\n        this.droppedSignatures += 1\n        return\n      }\n      pattern = {\n        errorType,\n        field: field ?? null,\n        message,\n        count: 0,\n        firstOccurrence: rowNumber,\n        lastOccurrence: rowNumber,\n        samples: [],\n      }\n      this.patterns.set(signature, pattern)\n    }\n\n    pattern.count += 1\n    pattern.lastOccurrence = rowNumber\n    if (pattern.samples.length < this.maxSamplesPerPattern) {\n      pattern.samples.push({ rowNumber, rowData })\n    }\n  }\n\n  /** Total count across every pattern. Counts errors, not patterns. */\n  getTotalErrorCount(): number {\n    let sum = 0\n    for (const p of this.patterns.values()) sum += p.count\n    return sum\n  }\n\n  /** Number of distinct signatures retained in the map (≤ `maxPatterns`). */\n  getDistinctPatternCount(): number {\n    return this.patterns.size\n  }\n\n  /**\n   * Number of NEW signatures dropped because the map was already at\n   * capacity. Surfacing this in the import_run summary tells the operator\n   * \"the top-N was saturated — there's a long tail you're not seeing\".\n   */\n  getDroppedSignatureCount(): number {\n    return this.droppedSignatures\n  }\n\n  /**\n   * Top patterns sorted by descending count, capped at `maxPatterns`.\n   * Stable secondary order is insertion order (Map iteration order is\n   * insertion order; Array.sort is stable in V8).\n   */\n  getTopPatterns(): ErrorPattern[] {\n    const all = Array.from(this.patterns.values()).sort((a, b) => b.count - a.count)\n    const totalErrors = all.reduce((sum, p) => sum + p.count, 0)\n    return all.map((p) => ({\n      errorType: p.errorType,\n      field: p.field,\n      message: p.message,\n      count: p.count,\n      firstOccurrence: p.firstOccurrence,\n      lastOccurrence: p.lastOccurrence,\n      samples: p.samples.slice(),\n      percentage: totalErrors > 0 ? (p.count / totalErrors) * 100 : 0,\n    }))\n  }\n\n  /**\n   * Compact JSON-serialisable snapshot for `import_run.errorSummary`.\n   * Aside from the patterns array, includes the totals so a reader of\n   * just this column doesn't have to re-derive them.\n   */\n  snapshot(): ErrorTrackerSnapshot {\n    return {\n      totalErrors: this.getTotalErrorCount(),\n      distinctPatterns: this.getDistinctPatternCount(),\n      droppedSignatures: this.droppedSignatures,\n      patterns: this.getTopPatterns(),\n    }\n  }\n}\n\nexport interface ErrorTrackerSnapshot {\n  totalErrors: number\n  distinctPatterns: number\n  droppedSignatures: number\n  patterns: ErrorPattern[]\n}\n","/**\n * Tab-delimited / CSV streaming reader. Generic over delimiter so the\n * same path handles `.txt` (tab), `.csv` (comma), and the rare `;`\n * European export dialect.\n *\n * Built on `csv-parse` per giga-test precedent — node-stream-based, low\n * memory, handles UTF-8 BOM (the carmaker feeds are Windows-exported\n * and ship with a BOM that breaks naive split-on-tab parsers).\n *\n * The reader yields `{ rowNumber, row }` pairs where:\n * - `rowNumber` is 1-based and counts the header as row 0.\n * - `row` is `Record<string, string>` keyed by header name. Empty cells\n *   are the empty string, NOT `undefined` — feed transforms test with\n *   `value === ''` consistently.\n *\n * Why this lives in a streaming reader and not inside the transform\n * itself: the transform sees one already-parsed row at a time, never\n * the file. That keeps transform implementations free of I/O concerns\n * and makes them trivially unit-testable with a fixture row map.\n */\n\nimport { createReadStream } from 'node:fs'\nimport { parse } from 'csv-parse'\n\n/**\n * Throw if two (non-empty) header names collide. Headers are the keys the mapping\n * engine matches a `source` against; after trimming, two columns differing only in\n * whitespace would collapse to one key and silently overwrite each other's data.\n * Fail fast instead — the operator fixes the feed or the mapping. Shared by the\n * csv/tsv reader (below) and the xlsx reader. Blank columns are ignored (unmapped).\n */\nexport function assertUniqueHeaders(header: readonly string[]): void {\n  const seen = new Set<string>()\n  for (const h of header) {\n    if (h === '') continue\n    if (seen.has(h)) {\n      throw new Error(`Duplicate header \"${h}\" after trimming — column names must be unique`)\n    }\n    seen.add(h)\n  }\n}\n\n/**\n * Pre-pass: count data rows in a delimited file (excluding the header\n * row when `hasHeader` is true; default `true` to match `streamFeed`).\n *\n * Implementation: stream the file as raw bytes and tally `\\n`. NOT a\n * full parse — escaped newlines inside quoted fields would over-count.\n * That's acceptable for the supplier-feed use case because we default\n * `quote: false` (every `\\n` IS a row boundary). For genuine RFC-4180\n * CSV inputs with embedded newlines, treat the result as an upper\n * bound; the actual parsed row count from `streamFeed` is authoritative.\n *\n * Why bytes-only and not csv-parse: a 16 MB feed counts in ~50 ms with\n * `\\n` tally vs ~500 ms with csv-parse parsing. For 500 MB the gap\n * matters — pre-pass needs to be a small fraction of the actual import\n * or the operator perceives the run as \"stuck on pre-pass\" with no UI.\n *\n * Returns the number of DATA rows (header excluded when present).\n * Empty trailing lines (no `\\n` after the final row, or a single\n * trailing `\\n`) are handled identically to how csv-parse treats them\n * with `skip_empty_lines: true`.\n */\nexport async function countDataRows(\n  filePath: string,\n  options: { hasHeader?: boolean } = {},\n): Promise<number> {\n  const { hasHeader = true } = options\n  const stream = createReadStream(filePath)\n  let count = 0\n  let lastByte = 0\n  for await (const chunk of stream as AsyncIterable<Buffer>) {\n    for (let i = 0; i < chunk.length; i += 1) {\n      if (chunk[i] === 0x0a /* \\n */) count += 1\n    }\n    if (chunk.length > 0) lastByte = chunk[chunk.length - 1] ?? 0\n  }\n  // If the file doesn't end with a newline, the final row didn't get\n  // counted by the `\\n` tally — add one. Skipping when the file is\n  // entirely empty (count=0 and lastByte=0).\n  if (lastByte !== 0 && lastByte !== 0x0a) count += 1\n  return hasHeader ? Math.max(0, count - 1) : count\n}\n\nexport interface StreamFeedOptions {\n  /** Path to the file on disk. The PoC uploads land on local disk; S3-keyed reads come later. */\n  filePath: string\n  /**\n   * Single-character field delimiter. Default `\\t` (the carmaker feed\n   * format). Pass `,` for CSV, `;` for some European dialects.\n   */\n  delimiter?: string\n  /**\n   * `true` (default): the first row is the header and column names come\n   * from it. `false`: rows are emitted as positional `{ \"0\": ..., \"1\": ... }`\n   * and the transform reads by index — useful for headerless feeds that\n   * commit to a documented column order.\n   */\n  hasHeader?: boolean\n  /**\n   * Optional explicit column-name list. When provided, takes precedence\n   * over `hasHeader` (header row, if present, is skipped but its values\n   * are ignored). Useful when the upstream header is unstable but the\n   * positional shape isn't.\n   */\n  columns?: ReadonlyArray<string>\n  /**\n   * Forward to `csv-parse` `relax_column_count`. Default `false` —\n   * a row whose column count doesn't match the header surfaces as a\n   * parser error so the transform isn't silently fed truncated data.\n   */\n  relaxColumnCount?: boolean\n  /**\n   * Forward to `csv-parse` `quote`. The character (or `false`) that\n   * encloses fields containing the delimiter. Default `false` — most\n   * supplier feeds in this package's target use case are tab-delimited\n   * exports that contain literal `\"` characters in description fields\n   * (e.g. `LIVRE \"INVERSION D'IMAGE\"` from the Mercedes carmaker feed)\n   * with NO quote-as-field-wrapper convention. csv-parse's library\n   * default `'\"'` then misreads the literal `\"` as an opening quote\n   * and rejects the row with `Invalid Opening Quote`.\n   *\n   * Pass `'\"'` (or any character) to opt back into RFC-4180-style\n   * CSV parsing for genuine quoted-CSV inputs. Pass `'\\''` for\n   * single-quoted dialects.\n   */\n  quote?: string | false\n}\n\nexport interface StreamFeedRow {\n  /** 1-based row number. Header (when present) is row 0; first data row is row 1. */\n  rowNumber: number\n  /**\n   * Cell values keyed by column name (or string-position when\n   * `hasHeader: false` AND no `columns`).\n   *\n   * **Cell-value invariants:**\n   * - Empty cells (`A\\t\\tC`) → `''` (empty string).\n   * - Missing TRAILING cells in `relaxColumnCount: true` mode → the\n   *   key is **absent** from the object, not present-with-`''`. csv-parse\n   *   does not emit keys for short rows. Transforms reading those\n   *   columns get `undefined` from `row['col']` and must handle it\n   *   (`row['col'] ?? ''` is the canonical idiom).\n   * - With the default `relaxColumnCount: false`, short rows reject at\n   *   the parser, so this case never reaches the transform.\n   */\n  row: Record<string, string>\n}\n\n/**\n * Async-iterable over the parsed rows of a delimited file. Use with\n * `for await (const { rowNumber, row } of streamFeed({ filePath, ... }))`.\n *\n * The iterator owns its file descriptor — the `for await` loop closes\n * the underlying stream when it returns or breaks. Aborting mid-stream\n * (`break`, `throw`, signal) is safe; csv-parse propagates the close.\n */\nexport async function* streamFeed(options: StreamFeedOptions): AsyncIterable<StreamFeedRow> {\n  const {\n    filePath,\n    delimiter = '\\t',\n    hasHeader = true,\n    columns,\n    relaxColumnCount = false,\n    quote = false,\n  } = options\n\n  // When the caller provides explicit `columns`, prefer them. When the file\n  // has a header but no explicit `columns`, derive the column names from the\n  // first row via a function so we can TRIM them — real supplier feeds ship\n  // leading/trailing-space headers (R03 Samples A/C: `\" JAEHIND KM-TA\"`), and\n  // an untrimmed key wouldn't match a mapping's `source`. The xlsx reader trims\n  // headers the same way. When neither is true, rows get string-position keys.\n  //\n  // csv-parse's `columns` accepts `ColumnOption[] | boolean | ((record) =>\n  // ColumnOption[])`; `string[]` satisfies `ColumnOption[]`.\n  const columnConfig: string[] | boolean | ((header: string[]) => string[]) = columns\n    ? Array.from(columns)\n    : hasHeader\n      ? (header: string[]) => {\n          const trimmed = header.map((h) => h.trim())\n          assertUniqueHeaders(trimmed)\n          return trimmed\n        }\n      : false\n\n  const stream = createReadStream(filePath)\n  const parser = stream.pipe(\n    parse({\n      delimiter,\n      columns: columnConfig,\n      bom: true,\n      skip_empty_lines: true,\n      // csv-parse defaults to strict column count; opt-in relaxation only.\n      relax_column_count: relaxColumnCount,\n      // Default `quote: false` — see StreamFeedOptions.quote JSDoc.\n      // Carmaker / parts-feed exports contain literal `\"` characters\n      // in description fields and would otherwise reject as\n      // `Invalid Opening Quote`. Genuine RFC-4180 CSV consumers opt\n      // back in by passing `quote: '\"'`.\n      quote,\n    }),\n  )\n\n  let rowNumber = 0\n  try {\n    for await (const rawRow of parser as AsyncIterable<\n      ReadonlyArray<string> | Record<string, string | undefined>\n    >) {\n      rowNumber += 1\n      // csv-parse emits records with string keys when `columns` is\n      // truthy, otherwise an Array. Normalise both shapes to\n      // `Record<string, string>` so transforms can rely on `value === ''`\n      // for missing cells (csv-parse leaves trailing missing cells as\n      // `undefined` when `relax_column_count: true`; this collapses\n      // them to `''` to keep the contract uniform).\n      const row: Record<string, string> = {}\n      if (Array.isArray(rawRow)) {\n        const arr = rawRow as ReadonlyArray<string | undefined>\n        for (let i = 0; i < arr.length; i += 1) {\n          row[String(i)] = arr[i] ?? ''\n        }\n      } else {\n        for (const [k, v] of Object.entries(rawRow)) {\n          row[k] = v ?? ''\n        }\n      }\n      yield { rowNumber, row }\n    }\n  } finally {\n    // Safety: ensure the underlying file descriptor closes even if the\n    // consumer breaks mid-iteration. Node closes streams on\n    // garbage-collection but this makes it deterministic under tests.\n    stream.destroy()\n  }\n}\n","/**\n * Feed reader dispatcher (commerce-demo phase 02, D005). Selects the reader by\n * `format` and yields the uniform `AsyncIterable<{ rowNumber, row }>` the runner\n * consumes — csv/tsv via the existing `streamFeed` (csv-parse), xlsx via the\n * exceljs-backed `streamXlsx`.\n *\n * **Back-compat**: with no `format` (the carmaker worker passes only `filePath`),\n * this defaults to tab-delimited — the original `streamFeed` behaviour — so the\n * existing import path is unchanged.\n *\n * **Bundle safety**: the xlsx reader (and its heavy, Node-only exceljs dep) is\n * `await import()`-ed ONLY for `format: 'xlsx'`, so the csv/tsv path — and anything\n * that statically imports the runner — never pulls exceljs into its module graph.\n */\n\nimport { z } from 'zod'\nimport { type StreamFeedOptions, type StreamFeedRow, streamFeed } from './streaming.js'\n\n/**\n * The reader-config subset safe to persist in `import_run.params.feed` and rehydrate\n * in the worker (commerce-demo PR3). It is exactly the {@link ReadFeedOptions} fields\n * that describe HOW to parse a feed — `filePath` is supplied by the worker after it\n * materialises the upload, never carried in params. Validated at BOTH ends: the\n * commerce run route builds it from a saved `import_mapping`, the worker re-parses it\n * before handing it to {@link readFeed} (defense-in-depth against a tampered row).\n */\nexport const feedReaderConfigSchema = z\n  .object({\n    format: z.enum(['csv', 'tsv', 'xlsx']).optional(),\n    delimiter: z.string().min(1).max(4).optional(),\n    hasHeader: z.boolean().optional(),\n    headerRowIndex: z.number().int().min(0).optional(),\n    sheet: z.string().min(1).max(128).optional(),\n  })\n  .strict()\nexport type FeedReaderConfig = z.infer<typeof feedReaderConfigSchema>\n\nexport interface ReadFeedOptions {\n  /** Path to the file on local disk. */\n  filePath: string\n  /** Feed format. Omitted → tab-delimited (tsv), matching the legacy carmaker reader. */\n  format?: 'csv' | 'tsv' | 'xlsx'\n  /** Explicit delimiter override (csv/tsv). Defaults from `format` (`csv` → `,`, else `\\t`). */\n  delimiter?: string\n  /** First row is the header. Default `true`. */\n  hasHeader?: boolean\n  /** 0-based header row index (xlsx). */\n  headerRowIndex?: number\n  /** xlsx worksheet as a 1-based index string. Omit → first sheet. */\n  sheet?: string\n  /** Explicit column-name list (csv/tsv) — see `streamFeed`. */\n  columns?: ReadonlyArray<string>\n  /** Forward to csv-parse `relax_column_count` (csv/tsv). */\n  relaxColumnCount?: boolean\n  /** Forward to csv-parse `quote` (csv/tsv). */\n  quote?: string | false\n}\n\nfunction toStreamFeedOptions(o: ReadFeedOptions): StreamFeedOptions {\n  // No format → tab (the carmaker feed default). `csv` → comma; everything else → tab.\n  const delimiter = o.delimiter ?? (o.format === 'csv' ? ',' : '\\t')\n  return {\n    filePath: o.filePath,\n    delimiter,\n    ...(o.hasHeader !== undefined && { hasHeader: o.hasHeader }),\n    ...(o.columns !== undefined && { columns: o.columns }),\n    ...(o.relaxColumnCount !== undefined && { relaxColumnCount: o.relaxColumnCount }),\n    ...(o.quote !== undefined && { quote: o.quote }),\n  }\n}\n\n/** Stream a feed file's data rows, dispatching on `format`. */\nexport async function* readFeed(options: ReadFeedOptions): AsyncIterable<StreamFeedRow> {\n  if (options.format === 'xlsx') {\n    const { streamXlsx } = await import('./xlsx-reader.js')\n    yield* streamXlsx({\n      filePath: options.filePath,\n      ...(options.hasHeader !== undefined && { hasHeader: options.hasHeader }),\n      ...(options.headerRowIndex !== undefined && { headerRowIndex: options.headerRowIndex }),\n      ...(options.sheet !== undefined && { sheet: options.sheet }),\n    })\n    return\n  }\n  yield* streamFeed(toStreamFeedOptions(options))\n}\n","/**\n * One-shot importer: stream rows → transform → batched bulk-write to ES,\n * accumulating per-row errors into `ErrorTracker` and reporting progress\n * to the queue every batch.\n *\n * Per PLAN-ECOMMERCE.md PR 7 (PoC scope):\n * - **Batch size 1000.** Matches giga-test precedent. Configurable for\n *   integration tests that don't want a 1k row floor.\n * - **No resumability and no automatic retries.** The `imports:run` queue\n *   job is registered with `defaultRetries: 0` (see `worker.ts`) so a\n *   failed handler does NOT re-enqueue itself — re-running a multi-batch\n *   import against the same `import_run.id` while the previous attempt\n *   may still be writing is a footgun (duplicate batches, double-counted\n *   progress). Operator retries by creating a NEW `import_run` row.\n * - **No per-supplier transform plugin.** The runner takes a single\n *   `RowTransform<TDoc>` from the registry and applies it to every row;\n *   PR 8 may diverge but only by registering a different transform name.\n * - **Direct `bulkUpsert` into the live aliased index** (D6 alias is\n *   set up by PR 4's `ensureAliasedIndex`; the importer doesn't reindex).\n *\n * Per D21 (sanctioned bulk path): this runner intentionally bypasses\n * AdminClient and entity hooks. Per-batch audit / observability lives\n * on the surrounding `import_run` row + queue progress, NOT per-row.\n */\n\nimport { bulkUpsert, type BulkIndexResult, type EsClientLike } from '@murumets-ee/search-elasticsearch'\nimport { ErrorTracker } from './error-tracker.js'\nimport { readFeed, type ReadFeedOptions } from './read-feed.js'\nimport type { RowTransform, TransformContext } from './transform.js'\n\n/** Soft default; chosen to match giga-test. ES bulk requests over ~5MB get split server-side anyway. */\nexport const DEFAULT_BATCH_SIZE = 1000\n\nexport interface RunImportOptions<TDoc> {\n  /** UUID of the `import_run` row driving this run. Forwarded to every transform invocation. */\n  importRunId: string\n  /** Operator-supplied label for the run. Forwarded to the transform context. */\n  runLabel: string\n  /** Opaque per-run params copied from `import_run.params`. */\n  params: Record<string, unknown>\n  /** Transform applied to every parsed row. */\n  transform: RowTransform<TDoc>\n  /** Feed reader options — file path + format (csv/tsv/xlsx) + delimiter/header config. */\n  feed: ReadFeedOptions\n  /** ES client (low-level shape from `@murumets-ee/search-elasticsearch`). */\n  esClient: EsClientLike\n  /** Index alias to write to. Per D6, callers always pass an alias, never a physical index. */\n  esIndex: string\n  /** Rows per `bulkUpsert` call. Default {@link DEFAULT_BATCH_SIZE}. */\n  batchSize?: number\n  /**\n   * Callback invoked after every batch. The handler in `worker.ts`\n   * forwards this to `ctx.updateProgress` for the queue UI; tests\n   * inspect it directly. Synchronous + cheap so a slow callback can't\n   * back-pressure the importer.\n   */\n  onProgress?: (progress: ImportRunProgress) => void\n  /** Optional: stop processing after this many rows. Tests use it; production passes `undefined`. */\n  rowLimit?: number\n  /** Abort signal threaded into the underlying ES client request — cooperative cancel. */\n  signal?: AbortSignal\n  /** Optional ErrorTracker config (caps). Default: top-50 patterns × 5 samples. */\n  errorTracker?: ErrorTracker\n  /**\n   * Optional structural logger for per-batch telemetry. Receives\n   * `{ batch, ms, succeeded, failed, rowsRead, rowsPerSecond }` after\n   * every flush, plus a one-shot `started` and `finished` event. The\n   * worker forwards `app.logger.child({ pkg: 'imports' })`; tests\n   * leave it undefined.\n   *\n   * Why: without per-batch visibility, a stalled run looks identical\n   * to \"first batch in progress\" forever — the only feedback is the\n   * queue's `progress` jsonb (which writes after each batch) and the\n   * eventual `succeeded`/`failed` job event. Adding this lets the\n   * operator tail the worker log and immediately see whether ES is\n   * rate-limiting, the transform is rejecting every row, or the\n   * stream is actually progressing.\n   */\n  logger?: {\n    info: (data: Record<string, unknown>, msg: string) => void\n    warn: (data: Record<string, unknown>, msg: string) => void\n  }\n}\n\n/**\n * Progress payload written to `toolkit_jobs.progress` after every batch.\n * Caps + flush rules live on the queue's `updateProgress` debounce —\n * callers don't need to throttle.\n */\nexport interface ImportRunProgress {\n  rowsRead: number\n  rowsSucceeded: number\n  rowsFailed: number\n  rowsSkipped: number\n  batchesCompleted: number\n  /** Wall-clock seconds since the runner started. */\n  elapsedSeconds: number\n  /** Rows / second, computed at every batch. */\n  rowsPerSecond: number\n  /** Distinct error patterns currently held by the tracker. Saturates at the cap. */\n  distinctErrorPatterns: number\n  /**\n   * Total data-row count from a pre-pass scan, when the worker computed one.\n   * Lets the UI render `processed / total` percent. Absent when the worker\n   * skipped the count (file too large for the count budget, count failed,\n   * etc.) — UI must treat it as optional.\n   */\n  totalRows?: number\n}\n\n/**\n * Final result returned by {@link runImport}. The handler writes these\n * onto the `import_run` row alongside the ErrorTracker snapshot.\n */\nexport interface RunImportResult {\n  /** Total rows read from the file (excludes skipped empty lines). */\n  rowsRead: number\n  /** Rows the transform turned into a successful doc AND the ES cluster acknowledged. */\n  rowsSucceeded: number\n  /**\n   * Rows that the transform rejected (`{ kind: 'error' }`) OR that ES\n   * rejected on bulk-write (per-doc failure). Both are aggregated by\n   * `errorTracker` for the import_run summary.\n   */\n  rowsFailed: number\n  /** Rows that the transform skipped (`{ kind: 'skip' }`) — header noise, blank lines, intentional drop. */\n  rowsSkipped: number\n  /** Number of `bulkUpsert` calls made. */\n  batchesCompleted: number\n  /** Final value of {@link ErrorTracker.snapshot}. */\n  errors: ReturnType<ErrorTracker['snapshot']>\n}\n\n/**\n * Apply the runner against a feed file. Stops on rowLimit OR end-of-file\n * OR if `signal` aborts. Throws if the streaming reader / ES client\n * throws — caller (the queue handler) catches that and writes\n * `import_run.status = 'failed'` with the error message in\n * `errorSummary.fatal`.\n */\nexport async function runImport<TDoc>(options: RunImportOptions<TDoc>): Promise<RunImportResult> {\n  const {\n    importRunId,\n    runLabel,\n    params,\n    transform,\n    feed,\n    esClient,\n    esIndex,\n    batchSize = DEFAULT_BATCH_SIZE,\n    onProgress,\n    rowLimit,\n    signal,\n    errorTracker = new ErrorTracker(),\n    logger,\n  } = options\n\n  if (batchSize < 1) {\n    throw new Error(`batchSize must be >= 1 (got ${batchSize})`)\n  }\n\n  const startedAt = Date.now()\n  logger?.info(\n    { importRunId, runLabel, batchSize, esIndex },\n    'imports.runner: started',\n  )\n  let rowsRead = 0\n  let rowsSucceeded = 0\n  let rowsFailed = 0\n  let rowsSkipped = 0\n  let batchesCompleted = 0\n\n  let pending: Array<{ id: string; doc: TDoc; rowNumber: number }> = []\n\n  const flush = async (): Promise<void> => {\n    if (pending.length === 0) return\n    const batch = pending\n    pending = []\n    const flushStartedAt = Date.now()\n    let result: BulkIndexResult\n    try {\n      result = await bulkUpsert<TDoc>(esClient, {\n        index: esIndex,\n        docs: batch.map(({ id, doc }) => ({ id, doc })),\n        ...(signal !== undefined && { signal }),\n      })\n    } catch (err) {\n      // Cluster- or transport-level failure — the whole batch is\n      // unaccounted for. Distinguish abort (operator-driven cancel) from\n      // a real cluster failure so the errorSummary doesn't mislabel a\n      // cancelled run as broken cluster connectivity.\n      const isAbort =\n        signal?.aborted ??\n        (err instanceof Error && (err.name === 'AbortError' || /abort/i.test(err.message)))\n      const errorType = isAbort ? 'aborted' : 'bulk_request_failed'\n      const reason = err instanceof Error ? err.message : String(err)\n      for (const { rowNumber } of batch) {\n        errorTracker.addError(rowNumber, errorType, reason, undefined, null)\n      }\n      rowsFailed += batch.length\n      throw err\n    }\n\n    rowsSucceeded += result.succeeded\n    rowsFailed += result.failures.length\n    batchesCompleted += 1\n\n    const flushMs = Date.now() - flushStartedAt\n    const elapsedSec = (Date.now() - startedAt) / 1000\n    logger?.info(\n      {\n        importRunId,\n        batch: batchesCompleted,\n        flushMs,\n        submitted: batch.length,\n        succeeded: result.succeeded,\n        failed: result.failures.length,\n        rowsRead,\n        rowsPerSecond: elapsedSec > 0 ? Math.round(rowsRead / elapsedSec) : 0,\n      },\n      'imports.runner: batch flushed',\n    )\n\n    if (result.failures.length > 0) {\n      // Map each ES failure back to its source row via `id`. The bulk\n      // response order matches the request order, but ES doesn't promise\n      // that; matching by `id` is the safe path. PoC volume is small\n      // enough that the O(failures × batch) cost is irrelevant.\n      const byId = new Map(batch.map((b) => [b.id, b.rowNumber]))\n      for (const fail of result.failures) {\n        const rowNumber = byId.get(fail.id) ?? -1\n        errorTracker.addError(rowNumber, fail.type, fail.reason, undefined, { id: fail.id })\n      }\n    }\n\n    if (onProgress) {\n      const elapsedSeconds = (Date.now() - startedAt) / 1000\n      onProgress({\n        rowsRead,\n        rowsSucceeded,\n        rowsFailed,\n        rowsSkipped,\n        batchesCompleted,\n        elapsedSeconds,\n        rowsPerSecond: elapsedSeconds > 0 ? rowsRead / elapsedSeconds : 0,\n        distinctErrorPatterns: errorTracker.getDistinctPatternCount(),\n      })\n    }\n  }\n\n  // Streaming heartbeat — sample every Nth row so the operator sees the\n  // streamer is alive even when a transform-rejected file would prevent\n  // any flush from firing. Without this, a feed that's 100% rejected\n  // looks identical to \"stuck\" until end-of-file. Sample frequency is\n  // batchSize so the cadence matches the natural batch rhythm.\n  const streamSampleEvery = batchSize\n\n  // First-error capture per error type — surface what's actually rejecting\n  // the rows when 100% of a feed is rejected. Without this, the only signal\n  // is `errorTracker.snapshot()` which only writes to import_run.errorSummary\n  // at the END of the run. Mid-run we want to know NOW.\n  const firstErrorByType = new Map<string, { rowNumber: number; message: string }>()\n\n  for await (const { rowNumber, row } of readFeed(feed)) {\n    if (signal?.aborted) break\n    if (rowLimit !== undefined && rowsRead >= rowLimit) break\n    rowsRead += 1\n\n    if (rowsRead === 1) {\n      logger?.info({ importRunId, rowNumber, sampleKeys: Object.keys(row) }, 'imports.runner: STREAM_FIRST_ROW')\n    }\n    if (rowsRead % streamSampleEvery === 0) {\n      const elapsedSec = (Date.now() - startedAt) / 1000\n      // Telemetry only — no row content, no error sample text.\n      // PR #262 review (M-5): the prior `firstErrors:\n      // Object.fromEntries(firstErrorByType)` payload included the\n      // raw error message captured from the transform, which for the\n      // carmaker feed embeds supplier codes + price fragments. The\n      // detailed first-error breakdown is already persisted on\n      // `import_run.errorSummary` via `errorTracker.snapshot()` —\n      // operators inspect it there, not in the worker log.\n      logger?.info(\n        {\n          importRunId,\n          rowsRead,\n          rowsSucceeded,\n          rowsFailed,\n          rowsSkipped,\n          pending: pending.length,\n          elapsedSec: Math.round(elapsedSec * 10) / 10,\n          rowsPerSecond: elapsedSec > 0 ? Math.round(rowsRead / elapsedSec) : 0,\n          distinctFirstErrorTypes: firstErrorByType.size,\n        },\n        'imports.runner: STREAM_TICK',\n      )\n    }\n\n    const ctx: TransformContext = { importRunId, params, runLabel, rowNumber }\n    let result: Awaited<ReturnType<typeof transform>>\n    try {\n      result = await transform(row, ctx)\n    } catch (err) {\n      // A throw from the transform is a programmer error — surface it as\n      // a row-level error so the run can continue. (If the bug is\n      // catastrophic, the operator sees the same message repeated and\n      // can stop the run.)\n      const reason = err instanceof Error ? err.message : String(err)\n      errorTracker.addError(rowNumber, 'transform_threw', reason, undefined, row)\n      if (!firstErrorByType.has('transform_threw')) {\n        firstErrorByType.set('transform_threw', { rowNumber, message: reason })\n        // PR #262 review (M-5): drop the `row` payload from the\n        // log line — supplier feeds carry pricing + internal codes.\n        // The full row is on `import_run.errorSummary.samples` for\n        // post-mortem review by operators with view permission.\n        logger?.warn(\n          { importRunId, rowNumber, errorType: 'transform_threw', message: reason },\n          'imports.runner: FIRST_ERROR transform_threw',\n        )\n      }\n      rowsFailed += 1\n      continue\n    }\n\n    if (result.kind === 'skip') {\n      rowsSkipped += 1\n      continue\n    }\n    if (result.kind === 'error') {\n      errorTracker.addError(\n        rowNumber,\n        result.error.errorType,\n        result.error.message,\n        result.error.field,\n        row,\n      )\n      if (!firstErrorByType.has(result.error.errorType)) {\n        firstErrorByType.set(result.error.errorType, {\n          rowNumber,\n          message: result.error.message,\n        })\n        logger?.warn(\n          {\n            importRunId,\n            rowNumber,\n            errorType: result.error.errorType,\n            field: result.error.field,\n            message: result.error.message,\n          },\n          `imports.runner: FIRST_ERROR ${result.error.errorType}`,\n        )\n      }\n      rowsFailed += 1\n      continue\n    }\n\n    pending.push({ id: result.id, doc: result.doc, rowNumber })\n    if (pending.length >= batchSize) {\n      await flush()\n    }\n  }\n\n  await flush()\n\n  const totalSec = (Date.now() - startedAt) / 1000\n  logger?.info(\n    {\n      importRunId,\n      rowsRead,\n      rowsSucceeded,\n      rowsFailed,\n      rowsSkipped,\n      batchesCompleted,\n      totalSec: Math.round(totalSec * 10) / 10,\n      rowsPerSecond: totalSec > 0 ? Math.round(rowsRead / totalSec) : 0,\n    },\n    'imports.runner: finished',\n  )\n\n  return {\n    rowsRead,\n    rowsSucceeded,\n    rowsFailed,\n    rowsSkipped,\n    batchesCompleted,\n    errors: errorTracker.snapshot(),\n  }\n}\n"],"mappings":"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"}

package/dist/transform-dO4z0Ze6.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transform-dO4z0Ze6.d.mts","names":[],"sources":["../src/transform.ts"],"mappings":";;AA0BA;;;;AAAyB;AAGzB;;;;;;;;;;AAQW;AAaX;;;;;;;;KAxBY,aAAA;;UAGK,gBAAA;EAwBX;EAtBJ,WAAA;EAsB0B;EApB1B,MAAA,EAAQ,MAAM;EAoBoB;EAlBlC,QAAA;EAqBuB;EAnBvB,SAAA;AAAA;;;;;AAsBK;AAQP;;;;;KAjBY,SAAA;EACN,IAAA;EAAiB,EAAA;EAAY,GAAA,EAAK,IAAA;AAAA;EAClC,IAAA;EAAc,MAAA;AAAA;EACd,IAAA;EAAe,KAAA,EAAO,QAAQ;AAAA;;UAGnB,QAAA;EACf,SAAA;EACA,OAAA;EACA,KAAA;AAAA;;;;;;UAQe,YAAA;EAAA,CACd,MAAA,EAAQ,MAAA,kBAAwB,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,SAAA,CAAU,IAAA;AAAA;;;;;;;;;;;;;;;;;;;cAqBhE,iBAAA;EAAA,iBACM,OAAA;EAiCZ;AAAA;AAyBP;;;;EAlDE,QAAA,MAAA,CAAe,IAAA,EAAM,aAAA,EAAe,SAAA,EAAW,YAAA,CAAa,IAAA;EAiE9C;EAvDd,GAAA,CAAI,IAAA,EAAM,aAAA,GAAgB,YAAA;EAuDW;EAlDrC,GAAA,CAAI,IAAA,EAAM,aAAA;EAoDc;EA/CxB,IAAA,CAAA,GAAQ,aAAA;EA+Ce;EA1CvB,KAAA,CAAA;AAAA;;iBAyBc,oBAAA,CAAA,GAAwB,iBAAiB;;;;;AAiB1B;iBAFf,uBAAA,MAAA,CACd,IAAA,EAAM,aAAA,EACN,SAAA,EAAW,YAAA,CAAa,IAAA"}

package/dist/worker-D2Pf-R9o.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker-D2Pf-R9o.d.mts","names":[],"sources":["../src/entities/import-run.ts","../src/error-tracker.ts","../src/streaming.ts","../src/read-feed.ts","../src/runner.ts","../src/worker.ts"],"mappings":"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"}