@sixb/core 0.1.0 → 0.1.2

package/dist/chunk-bct7hmfc.js.map

@@ -0,0 +1,14 @@
+{
+  "version": 3,
+  "sources": ["../src/connectors/errors.ts", "../src/syncs/errors.ts", "../src/syncs/run-dispatch.ts", "../src/syncs/request.ts", "../src/connectors/execution.ts"],
+  "sourcesContent": [
+    "import {\n  createSixbError,\n  isSixbError,\n  type SixbCodedError,\n  type SixbErrorOptions,\n} from \"../errors/internal\"\nimport type { SixbErrorCode } from \"../errors/types\"\nimport { ConnectorConnectionStorageError } from \"../storage/connector-connections/errors\"\n\ntype ConnectorCodedErrorCode = Extract<SixbErrorCode, `connector.${string}`> | \"internal.unexpected\"\n\n/**\n * Legacy authoring error for static connector definitions and lookup.\n *\n * Persistent connection lifecycle failures use the global `SixbErrorCode` contract instead.\n * `ConnectorOAuthError` remains a class because adapters and Core need `instanceof` control flow at\n * the provider-effect boundary.\n */\nexport class ConnectorError extends Error {\n  readonly name: string = \"ConnectorError\"\n}\n\nexport class ConnectorNotFoundError extends ConnectorError {\n  override readonly name = \"ConnectorNotFoundError\"\n  constructor(readonly connectorId: string) {\n    super(`Unknown connector '${connectorId}'`)\n  }\n}\n\n/**\n * Provider mutation outcome reported by an OAuth adapter.\n *\n * `retryable` guarantees that the provider made no change. `terminal` means the current grant can\n * no longer progress. `ambiguous` means the provider may have changed state; Core fails closed.\n * This classifies the provider effect, not the final Sixb error retry policy: Core also accounts for\n * one-use state, consumed authorization codes, and durable mutation phase before choosing a code.\n */\nexport type ConnectorOAuthErrorKind = \"retryable\" | \"terminal\" | \"ambiguous\"\n\n/** Adapter signal used by Core to decide whether a provider operation can be retried safely. */\nexport class ConnectorOAuthError extends ConnectorError {\n  override readonly name = \"ConnectorOAuthError\"\n\n  constructor(\n    readonly kind: ConnectorOAuthErrorKind,\n    message: string,\n    options?: ErrorOptions\n  ) {\n    super(message, options)\n  }\n}\n\n/** Internal factory for connector failures that cross a Sixb boundary. */\nexport function createConnectorCodedError(\n  code: ConnectorCodedErrorCode,\n  message: string,\n  options: SixbErrorOptions = {}\n): SixbCodedError {\n  return createSixbError(\n    code,\n    message.startsWith(\"[Sixb]\") ? message : `[Sixb] ${message}`,\n    options\n  )\n}\n\n/** Internal failure used when a provider operation may have completed after Core lost its fence. */\nexport function createAmbiguousProviderOperationError(\n  options: SixbErrorOptions = {}\n): SixbCodedError {\n  return createConnectorCodedError(\n    \"connector.provider_failed\",\n    \"Connector provider operation outcome is ambiguous.\",\n    options\n  )\n}\n\nexport function oauthErrorKind(error: unknown): ConnectorOAuthErrorKind {\n  return error instanceof ConnectorOAuthError ? error.kind : \"ambiguous\"\n}\n\nexport function providerFailureCode(\n  error: unknown\n): \"connector.provider_failed\" | \"connector.provider_unavailable\" {\n  return oauthErrorKind(error) === \"retryable\"\n    ? \"connector.provider_unavailable\"\n    : \"connector.provider_failed\"\n}\n\nexport function providerBoundaryError(\n  error: unknown,\n  code: \"connector.provider_failed\" | \"connector.provider_unavailable\",\n  message: string\n): Error {\n  if (isSixbError(error) && error.code.startsWith(\"connector.\")) return error\n  return createConnectorCodedError(code, message, { cause: error })\n}\n\nexport function isConnectorStorageError(\n  error: unknown,\n  code?: ConnectorConnectionStorageError[\"code\"]\n): error is ConnectorConnectionStorageError {\n  return (\n    error instanceof ConnectorConnectionStorageError && (code === undefined || error.code === code)\n  )\n}\n\nexport function storageBoundaryError(error: unknown, message: string): SixbCodedError {\n  return createConnectorCodedError(\"internal.unexpected\", message, { cause: error })\n}\n\nexport async function recoverConnectorFailure<T>(\n  primaryError: unknown,\n  message: string,\n  recovery: () => Promise<T>\n): Promise<T> {\n  try {\n    return await recovery()\n  } catch (recoveryError) {\n    throw createConnectorCodedError(\"internal.unexpected\", message, {\n      cause: new AggregateError([primaryError, recoveryError], message),\n    })\n  }\n}\n",
+    "export class SyncValidationError extends Error {\n  readonly name = \"SyncValidationError\"\n}\n",
+    "import { randomUUID } from \"node:crypto\"\nimport { reportRunFailure } from \"../error-reporting/capability\"\nimport { createSixbError, toSixbFailure } from \"../errors/internal\"\nimport type { SixbFailure } from \"../errors/types\"\nimport type { RunDispatcher } from \"../execution/dispatch\"\nimport { createPrimitiveExecutionRecord } from \"../execution/durable\"\nimport type { Queues } from \"../queues\"\nimport type { SixbDefinitions } from \"../runtime/definitions\"\nimport type { CreateExecutionInput, Storage, SyncRunFailureCode, SyncRunRecord } from \"../storage\"\nimport { SYNC_RUN_FAILURE_CODES, SyncRunError } from \"../storage\"\nimport { SyncValidationError } from \"./errors\"\nimport type { SyncRunRequestOptions, SyncRunRequestResult } from \"./request\"\nimport type { SyncDefinition } from \"./types\"\n\nexport type AutomaticSyncExecutionSource =\n  | { readonly type: \"schedule\"; readonly eventId: string }\n  | { readonly type: \"event\"; readonly eventId: string }\n\nexport interface AutomaticSyncRunDispatchInput extends SyncRunRequestOptions {\n  readonly syncId: string\n  readonly runId: string\n  readonly source: AutomaticSyncExecutionSource\n  readonly correlationId: string\n  readonly metadata?: Readonly<Record<string, string>>\n}\n\nexport type SyncRunDispatchPort = RunDispatcher<AutomaticSyncRunDispatchInput, SyncRunRequestResult>\n\nexport interface SyncRunDispatcherDependencies {\n  readonly id: string\n  readonly definitions: Pick<SixbDefinitions, \"syncs\">\n  readonly storage: Storage\n  readonly queues: Pick<Queues, \"syncRuns\">\n}\n\ninterface DispatchSyncRunInput extends SyncRunRequestOptions {\n  readonly errorReporterHost: object\n  readonly projectId: string\n  readonly sync: SyncDefinition\n  readonly storage: Storage\n  readonly queue: Queues[\"syncRuns\"]\n  readonly metadata?: Readonly<Record<string, string>>\n  readonly createExecution: (executionId: string, runId: string) => Promise<CreateExecutionInput>\n  readonly validateExistingRun?: (run: SyncRunRecord, storage: Storage) => Promise<void>\n}\n\ntype PersistedSyncRun =\n  | { readonly publish: false; readonly run: SyncRunRecord }\n  | {\n      readonly publish: true\n      readonly run: SyncRunRecord\n      readonly execution: CreateExecutionInput\n      readonly queuedAt: Date\n      readonly created: boolean\n    }\n\n/** Core-owned durable dispatch boundary used by automatic Sync triggers. */\nexport class SyncRunDispatcher implements SyncRunDispatchPort {\n  constructor(private readonly dependencies: SyncRunDispatcherDependencies) {}\n\n  async dispatch(input: AutomaticSyncRunDispatchInput): Promise<SyncRunRequestResult> {\n    assertAutomaticDispatchInput(input)\n    const sync = this.dependencies.definitions.syncs.getById(input.syncId)\n    if (!sync) throw new SyncValidationError(`[Sixb] Unknown sync '${input.syncId}'`)\n\n    return dispatchSyncRun({\n      errorReporterHost: this.dependencies,\n      projectId: this.dependencies.id,\n      sync,\n      storage: this.dependencies.storage,\n      queue: this.dependencies.queues.syncRuns,\n      runId: input.runId,\n      expectedLatestVersionId: input.expectedLatestVersionId,\n      commitMessage: input.commitMessage,\n      metadata: input.metadata,\n      validateExistingRun: (run, storage) =>\n        assertAutomaticExecutionIdentity(storage, this.dependencies.id, input, run),\n      createExecution: async (executionId, runId) =>\n        createPrimitiveExecutionRecord({\n          id: executionId,\n          primitive: { kind: \"sync\", id: sync.id, runId },\n          origin: {\n            type: \"automatic\",\n            projectId: this.dependencies.id,\n            source: input.source,\n            correlationId: input.correlationId,\n          },\n        }),\n    })\n  }\n}\n\n/** Persist a Sync execution and queued run before publishing its queue job. */\nexport async function dispatchSyncRun(input: DispatchSyncRunInput): Promise<SyncRunRequestResult> {\n  const runId = createSyncRunId(input.runId)\n  const persisted = await persistSyncRun(input, runId)\n  if (!persisted.publish) return existingSyncRunResult(persisted.run)\n  return publishSyncRun(input, persisted)\n}\n\nasync function persistSyncRun(\n  input: DispatchSyncRunInput,\n  runId: string\n): Promise<PersistedSyncRun> {\n  const syncRuns = requireSyncRunStorage(input.storage)\n  const existing = await syncRuns.getById({ projectId: input.projectId, id: runId })\n  if (existing) return reuseSyncRun(input, existing)\n\n  const execution = await input.createExecution(`exec_${randomUUID()}`, runId)\n  const queuedAt = new Date()\n  try {\n    return await input.storage.transaction(\n      async (tx): Promise<PersistedSyncRun> => {\n        const transactionalRuns = requireSyncRunStorage(tx)\n        const raced = await transactionalRuns.getById({ projectId: input.projectId, id: runId })\n        if (raced) {\n          assertExistingRunMatchesRequest(raced, input)\n          await input.validateExistingRun?.(raced, tx)\n          return { publish: false, run: raced }\n        }\n\n        await tx.executions.create(execution)\n        const run = await transactionalRuns.queue({\n          projectId: input.projectId,\n          id: runId,\n          executionId: execution.id,\n          syncId: input.sync.id,\n          datasetId: input.sync.target.dataset.id,\n          mode: input.sync.config.mode,\n          queuedAt,\n          expectedLatestVersionId: input.expectedLatestVersionId,\n          commitMessage: input.commitMessage,\n        })\n        return { publish: true, run, execution, queuedAt, created: true }\n      },\n      { isolation: \"serializable\" }\n    )\n  } catch (error) {\n    if (!(error instanceof SyncRunError)) throw error\n    const raced = await syncRuns.getById({ projectId: input.projectId, id: runId })\n    if (!raced) throw error\n    assertExistingRunMatchesRequest(raced, input)\n    await input.validateExistingRun?.(raced, input.storage)\n    return { publish: false, run: raced }\n  }\n}\n\nasync function reuseSyncRun(\n  input: DispatchSyncRunInput,\n  existing: SyncRunRecord\n): Promise<PersistedSyncRun> {\n  assertExistingRunMatchesRequest(existing, input)\n  await input.validateExistingRun?.(existing, input.storage)\n  if (\n    existing.status !== \"failed\" ||\n    existing.error?.code !== \"queue.enqueue_failed\" ||\n    !existing.error.retryable\n  ) {\n    return { publish: false, run: existing }\n  }\n\n  const execution = await input.storage.executions.getById({\n    projectId: input.projectId,\n    id: existing.executionId,\n  })\n  if (!execution) {\n    throw new SyncRunError(\n      `[Sixb] Execution '${existing.executionId}' for Sync run '${existing.id}' was not found.`\n    )\n  }\n\n  const queuedAt = new Date()\n  const run = await requireSyncRunStorage(input.storage).queue({\n    projectId: input.projectId,\n    id: existing.id,\n    executionId: existing.executionId,\n    syncId: existing.syncId,\n    datasetId: existing.datasetId,\n    mode: existing.mode,\n    queuedAt,\n    expectedLatestVersionId: existing.expectedLatestVersionId,\n    commitMessage: existing.commitMessage,\n  })\n  return { publish: true, run, execution, queuedAt, created: false }\n}\n\nasync function publishSyncRun(\n  input: DispatchSyncRunInput,\n  persisted: Extract<PersistedSyncRun, { readonly publish: true }>\n): Promise<SyncRunRequestResult> {\n  try {\n    const [job] = await input.queue.enqueue({\n      projectId: input.projectId,\n      jobs: [\n        {\n          id: persisted.run.id,\n          type: \"sync.run.requested\",\n          payload: { runId: persisted.run.id },\n          ...(input.metadata === undefined ? {} : { metadata: input.metadata }),\n        },\n      ],\n    })\n    return {\n      syncId: persisted.run.syncId,\n      runId: persisted.run.id,\n      queuedAt: persisted.queuedAt.toISOString(),\n      ...(job?.id ? { jobId: job.id } : {}),\n      created: persisted.created,\n    }\n  } catch (error) {\n    const failedAt = new Date()\n    const failure = toEnqueueFailure(error, persisted.run, failedAt)\n    const failed = await requireSyncRunStorage(input.storage).finish({\n      projectId: input.projectId,\n      id: persisted.run.id,\n      status: \"failed\",\n      finishedAt: failedAt,\n      error: failure,\n    })\n    reportRunFailure(input.errorReporterHost, error, {\n      projectId: input.projectId,\n      runKind: \"sync\",\n      run: { runId: failed.id, syncId: failed.syncId },\n      failure,\n    })\n    throw error\n  }\n}\n\nfunction assertExistingRunMatchesRequest(\n  existing: SyncRunRecord,\n  input: Pick<DispatchSyncRunInput, \"sync\" | \"expectedLatestVersionId\" | \"commitMessage\">\n): void {\n  if (\n    existing.syncId !== input.sync.id ||\n    existing.datasetId !== input.sync.target.dataset.id ||\n    existing.mode !== input.sync.config.mode ||\n    existing.expectedLatestVersionId !== input.expectedLatestVersionId ||\n    existing.commitMessage !== input.commitMessage\n  ) {\n    throw new SyncRunError(\n      `[Sixb] Sync run '${existing.id}' already exists with a different request payload.`\n    )\n  }\n}\n\nfunction existingSyncRunResult(existing: SyncRunRecord): SyncRunRequestResult {\n  return {\n    syncId: existing.syncId,\n    runId: existing.id,\n    queuedAt: existing.queuedAt.toISOString(),\n    created: false,\n  }\n}\n\nfunction requireSyncRunStorage(storage: Storage): NonNullable<Storage[\"syncRuns\"]> {\n  if (!storage.syncRuns) throw new SyncValidationError(\"[Sixb] Sync run storage is not configured.\")\n  return storage.syncRuns\n}\n\nfunction createSyncRunId(runId: string | undefined): string {\n  if (runId === undefined) return `run_${randomUUID()}`\n  if (!runId.trim()) throw new SyncValidationError(\"[Sixb] Sync run id must not be empty\")\n  return runId\n}\n\nfunction assertAutomaticDispatchInput(input: AutomaticSyncRunDispatchInput): void {\n  assertNonBlank(input.syncId, \"Sync id\")\n  assertNonBlank(input.runId, \"Sync run id\")\n  assertNonBlank(input.source.eventId, \"Sync source event id\")\n  assertNonBlank(input.correlationId, \"Sync correlation id\")\n}\n\nasync function assertAutomaticExecutionIdentity(\n  storage: Storage,\n  projectId: string,\n  input: AutomaticSyncRunDispatchInput,\n  run: SyncRunRecord\n): Promise<void> {\n  const execution = await storage.executions.getById({ projectId, id: run.executionId })\n  if (\n    !execution ||\n    execution.source.type !== input.source.type ||\n    execution.source.eventId !== input.source.eventId ||\n    execution.correlationId !== input.correlationId ||\n    execution.requestedBy !== undefined\n  ) {\n    throw new SyncValidationError(\n      `[Sixb] Sync run '${run.id}' already exists with different automatic provenance.`\n    )\n  }\n}\n\nfunction toEnqueueFailure(\n  error: unknown,\n  run: SyncRunRecord,\n  at: Date\n): SixbFailure<SyncRunFailureCode> {\n  const enqueueError = createSixbError(\n    \"queue.enqueue_failed\",\n    `[Sixb] Could not enqueue Sync run '${run.id}'.`,\n    {\n      cause: error,\n      details: { syncId: run.syncId, runId: run.id, phase: \"enqueue\" },\n    }\n  )\n  return toSixbFailure(enqueueError, { allowedCodes: SYNC_RUN_FAILURE_CODES, at })\n}\n\nfunction assertNonBlank(value: string, label: string): void {\n  if (!value.trim()) throw new SyncValidationError(`[Sixb] ${label} must not be empty.`)\n}\n",
+    "import { assertAuthorized } from \"../authorization\"\nimport {\n  createPrimitiveExecutionRecord,\n  ensureExecutionRecord,\n  executionRecordInputFromRuntime,\n} from \"../execution/durable\"\nimport type { ExecutionContext } from \"../execution/types\"\nimport type { SixbRuntimeContext } from \"../runtime/types\"\nimport { SyncValidationError } from \"./errors\"\nimport { dispatchSyncRun } from \"./run-dispatch\"\nimport type { SyncDefinition } from \"./types\"\n\nexport interface SyncRunRequestOptions {\n  /** Stable identity used to make dispatch idempotent. */\n  readonly runId?: string\n  /** Optimistic concurrency guard: fail the run if the dataset moved past this version. */\n  readonly expectedLatestVersionId?: string\n  readonly commitMessage?: string\n}\n\nexport interface RequestSyncRunInput extends SyncRunRequestOptions {\n  readonly syncId: string\n}\n\nexport interface SyncRunRequestResult {\n  readonly syncId: string\n  readonly runId: string\n  /** Durable time at which the run entered the queue. */\n  readonly queuedAt: string\n  readonly jobId?: string\n  readonly created: boolean\n}\n\n/**\n * Authorize and queue a sync run request.\n *\n * Operates on an already-resolved definition and the shared runtime context, so the HTTP route and\n * the runtime verb cannot drift apart.\n *\n * The immutable child execution and queued run are persisted before queue publication.\n */\nexport async function requestSyncRun(\n  runtime: SixbRuntimeContext,\n  execution: ExecutionContext,\n  sync: SyncDefinition,\n  options: SyncRunRequestOptions = {}\n): Promise<SyncRunRequestResult> {\n  assertAuthorized(runtime, { kind: \"sync.run\", syncId: sync.id })\n  if (!runtime.storage.syncRuns) {\n    throw new SyncValidationError(\"[Sixb] Sync run storage is not configured.\")\n  }\n\n  const queue = runtime.queues.syncRuns\n  if (!queue) {\n    throw new SyncValidationError(\"[Sixb] Sync run queue is not configured.\")\n  }\n\n  return dispatchSyncRun({\n    errorReporterHost: runtime,\n    projectId: runtime.projectId,\n    sync,\n    storage: runtime.storage,\n    queue,\n    ...options,\n    createExecution: async (executionId, runId) => {\n      const caller = await ensureExecutionRecord(\n        runtime.storage.executions,\n        executionRecordInputFromRuntime({\n          execution,\n          runtimeAuthorization: runtime.runtimeAuthorization,\n        })\n      )\n      return createPrimitiveExecutionRecord({\n        id: executionId,\n        primitive: { kind: \"sync\", id: sync.id, runId },\n        origin: { type: \"execution\", parent: caller },\n      })\n    },\n  })\n}\n",
+    "import { AuthorizationError, assertProviderAccess } from \"../authorization\"\nimport type { ExecutionContext } from \"../execution\"\nimport { resolveExecutionScopeAuthorization } from \"../execution/authorization\"\nimport type { SixbRuntimeContext } from \"../runtime/types\"\nimport { createConnectorCodedError } from \"./errors\"\nimport type { ConnectorService } from \"./service\"\nimport type {\n  AnyConnectorAdapter,\n  ConnectorAdapter,\n  ConnectorClient,\n  ConnectorConnectionMetadata,\n  ConnectorConnectionSelector,\n  ConnectorDefinition,\n  OAuthConnectorAdapter,\n} from \"./types\"\nimport { isOAuthConnectorDefinition } from \"./types\"\n\n/** Resolve a registered connector through one authorized execution. */\nexport interface ConnectorRuntime {\n  <TAdapter extends ConnectorAdapter>(\n    definition: ConnectorDefinition<string, TAdapter>\n  ): Promise<ConnectorClient<TAdapter>>\n  <TAdapter extends OAuthConnectorAdapter>(\n    definition: ConnectorDefinition<string, TAdapter>,\n    selector: ConnectorConnectionSelector\n  ): Promise<ConnectorClient<TAdapter>>\n}\n\nexport interface ConnectorExecutionSource<\n  TAdapter extends AnyConnectorAdapter = AnyConnectorAdapter,\n> {\n  readonly connection?: ConnectorConnectionMetadata\n  connect(signal: AbortSignal): Promise<ConnectorClient<TAdapter>>\n}\n\nexport interface ConnectorExecutionSourceResolver {\n  list<TAdapter extends AnyConnectorAdapter>(\n    definition: ConnectorDefinition<string, TAdapter>\n  ): Promise<readonly ConnectorExecutionSource<TAdapter>[]>\n}\n\nconst sourceResolvers = new WeakMap<ConnectorRuntime, ConnectorExecutionSourceResolver>()\n\nexport function createConnectorRuntime(\n  runtime: SixbRuntimeContext,\n  execution: ExecutionContext,\n  service: ConnectorService\n): ConnectorRuntime {\n  const connector = ((definition: ConnectorDefinition, selector?: ConnectorConnectionSelector) => {\n    if (isOAuthConnectorDefinition(definition)) {\n      assertConnectorConnectionAccess(runtime, execution)\n      if (!selector) {\n        throw createConnectorCodedError(\n          \"connector.configuration_invalid\",\n          `[Sixb] Connector '${definition.id}' uses persistent connections and requires an explicit owner and slot.`\n        )\n      }\n      return service.connectConnection(definition, selector)\n    }\n    if (selector) {\n      throw createConnectorCodedError(\n        \"connector.configuration_invalid\",\n        `[Sixb] Static connector '${definition.id}' does not accept a connection.`\n      )\n    }\n    assertProviderAccess(runtime, execution, \"connector.connect\")\n    return service.connect(definition as ConnectorDefinition<string, ConnectorAdapter>)\n  }) as ConnectorRuntime\n\n  registerConnectorExecutionSourceResolver(connector, {\n    async list<TAdapter extends AnyConnectorAdapter>(\n      definition: ConnectorDefinition<string, TAdapter>\n    ): Promise<readonly ConnectorExecutionSource<TAdapter>[]> {\n      if (!isOAuthConnectorDefinition(definition)) {\n        return [\n          {\n            connect: (_signal) =>\n              connector(definition as ConnectorDefinition<string, ConnectorAdapter>) as Promise<\n                ConnectorClient<TAdapter>\n              >,\n          },\n        ]\n      }\n\n      assertConnectorConnectionAccess(runtime, execution)\n      const connections = await service.listExecutionConnections(definition)\n      return connections.map((connection) => ({\n        connection: {\n          id: connection.id,\n          connectorId: connection.connectorId,\n          owner: connection.owner,\n          slot: connection.slot,\n          account: connection.account,\n        },\n        connect: (signal) =>\n          service.connectExecutionConnection(definition, connection, signal) as Promise<\n            ConnectorClient<TAdapter>\n          >,\n      }))\n    },\n  })\n  return connector\n}\n\nfunction registerConnectorExecutionSourceResolver(\n  connector: ConnectorRuntime,\n  resolver: ConnectorExecutionSourceResolver\n): void {\n  const registered = sourceResolvers.get(connector)\n  if (registered && registered !== resolver) {\n    throw new Error(\"[Sixb] Connector source resolver is already registered for this execution.\")\n  }\n  sourceResolvers.set(connector, resolver)\n}\n\nexport function getConnectorExecutionSourceResolver(\n  connector: ConnectorRuntime\n): ConnectorExecutionSourceResolver {\n  const resolver = sourceResolvers.get(connector)\n  if (resolver) return resolver\n\n  return {\n    async list<TAdapter extends AnyConnectorAdapter>(\n      definition: ConnectorDefinition<string, TAdapter>\n    ): Promise<readonly ConnectorExecutionSource<TAdapter>[]> {\n      if (isOAuthConnectorDefinition(definition)) {\n        throw createConnectorCodedError(\n          \"connector.configuration_invalid\",\n          `[Sixb] OAuth connector '${definition.id}' cannot be resolved without the managed connection runtime.`\n        )\n      }\n      return [\n        {\n          connect: (_signal) =>\n            connector(definition as ConnectorDefinition<string, ConnectorAdapter>) as Promise<\n              ConnectorClient<TAdapter>\n            >,\n        },\n      ]\n    },\n  }\n}\n\nfunction assertConnectorConnectionAccess(\n  runtime: SixbRuntimeContext,\n  execution: ExecutionContext\n): void {\n  const resolved = resolveExecutionScopeAuthorization(runtime.projectId, {\n    execution,\n    authorization: runtime.runtimeAuthorization,\n  })\n  if (resolved.type === \"unrestricted\" && resolved.ref.type === \"trustedPrimitive\") return\n  throw new AuthorizationError(\n    \"privileged:connector-connection.connect\",\n    \"[Sixb] Connector connection clients are restricted to trusted primitive executions.\"\n  )\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "ED1A30ED8A438D8864756E2164756E21",
+  "names": []
+}

package/dist/chunk-bh6k3nc6.js

@@ -0,0 +1,164 @@
+// @bun
+import {
+  isScheduleDefinition,
+  isScheduleReference
+} from "./chunk-5sz8ta9r.js";
+import {
+  isDatasetDefinition
+} from "./chunk-a31h57d5.js";
+import {
+  PipelineError
+} from "./chunk-zg9yryhz.js";
+
+// src/lake-storage/sql-transforms.ts
+var SQL_DIALECT = {
+  duckdb: "duckdb"
+};
+var SQL_DIALECTS = Object.values(SQL_DIALECT);
+function isSqlDialect(value) {
+  return typeof value === "string" && SQL_DIALECTS.includes(value);
+}
+
+// src/pipelines/builders.ts
+function assertNonEmpty(value, field) {
+  if (!value.trim()) {
+    throw new PipelineError(`Pipeline ${field} must not be empty.`);
+  }
+}
+function assertDataset(dataset, field) {
+  assertNonEmpty(dataset.id, field);
+}
+function assertDatasetWriteMode(mode) {
+  if (mode !== "snapshot" && mode !== "append") {
+    throw new PipelineError(`Pipeline step output mode '${mode}' is not supported.`);
+  }
+}
+function assertInputs(inputs) {
+  const entries = Object.entries(inputs);
+  if (entries.length === 0) {
+    throw new PipelineError("Pipeline step input dataset must contain at least one entry.");
+  }
+  for (const [name, dataset] of entries) {
+    assertNonEmpty(name, "step input name");
+    assertDataset(dataset, "step input dataset");
+  }
+}
+function scheduleReference(schedule) {
+  if (!isScheduleDefinition(schedule)) {
+    throw new PipelineError("Pipeline .when(...) only accepts schedules.");
+  }
+  return { type: "schedule", scheduleId: schedule.id };
+}
+function createPipelineBuilder(definition) {
+  return {
+    ...definition,
+    when(schedule) {
+      return createPipelineBuilder({
+        ...definition,
+        triggers: [...definition.triggers, scheduleReference(schedule)]
+      });
+    },
+    then(step) {
+      const graph = {
+        kind: "sequence",
+        nodes: [...definition.graph.nodes, { kind: "step", step }]
+      };
+      return createPipelineBuilder({
+        ...definition,
+        graph
+      });
+    }
+  };
+}
+function definePipelineStep(id) {
+  assertNonEmpty(id, "step id");
+  return {
+    inputs(inputs) {
+      assertInputs(inputs);
+      return {
+        output(dataset, options = {}) {
+          assertDataset(dataset, "step output dataset");
+          const mode = options.mode ?? "snapshot";
+          assertDatasetWriteMode(mode);
+          return {
+            run(handler) {
+              return {
+                kind: "pipeline.step",
+                id,
+                inputs,
+                output: dataset,
+                mode,
+                executor: {
+                  kind: "run",
+                  handler
+                }
+              };
+            },
+            sql(sql) {
+              return {
+                kind: "pipeline.step",
+                id,
+                inputs,
+                output: dataset,
+                mode,
+                executor: {
+                  kind: "sql",
+                  dialect: SQL_DIALECT.duckdb,
+                  sql
+                }
+              };
+            }
+          };
+        }
+      };
+    }
+  };
+}
+function definePipeline(id) {
+  assertNonEmpty(id, "id");
+  return createPipelineBuilder({
+    kind: "pipeline",
+    id,
+    triggers: [],
+    graph: {
+      kind: "sequence",
+      nodes: []
+    }
+  });
+}
+// src/pipelines/types.ts
+function isPipelineDefinition(value) {
+  if (!isRecord(value))
+    return false;
+  return value.kind === "pipeline" && typeof value.id === "string" && Array.isArray(value.triggers) && value.triggers.every(isScheduleReference) && isPipelineGraph(value.graph);
+}
+function isPipelineStepDefinition(value) {
+  return isRecord(value) && value.kind === "pipeline.step" && typeof value.id === "string" && isInputsRecord(value.inputs) && isDatasetDefinition(value.output) && isDatasetWriteMode(value.mode) && isPipelineStepExecutor(value.executor);
+}
+function isPipelineGraph(value) {
+  return isRecord(value) && value.kind === "sequence" && Array.isArray(value.nodes) && value.nodes.every((node) => isRecord(node) && node.kind === "step" && isPipelineStepDefinition(node.step));
+}
+function isPipelineStepExecutor(value) {
+  if (!isRecord(value))
+    return false;
+  switch (value.kind) {
+    case "sql":
+      return isSqlDialect(value.dialect) && typeof value.sql === "function";
+    case "run":
+      return typeof value.handler === "function";
+    default:
+      return false;
+  }
+}
+function isInputsRecord(value) {
+  return isRecord(value) && Object.entries(value).every(([key, dataset]) => key.trim().length > 0 && isDatasetDefinition(dataset));
+}
+function isDatasetWriteMode(value) {
+  return value === "snapshot" || value === "append";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export { definePipelineStep, definePipeline, isPipelineDefinition, isPipelineStepDefinition };
+
+//# debugId=DB6590A92C7F169B64756E2164756E21

package/dist/chunk-bh6k3nc6.js.map

@@ -0,0 +1,12 @@
+{
+  "version": 3,
+  "sources": ["../src/lake-storage/sql-transforms.ts", "../src/pipelines/builders.ts", "../src/pipelines/types.ts"],
+  "sourcesContent": [
+    "import type { DatasetDefinition } from \"../datasets\"\nimport type {\n  DatasetProducer,\n  DatasetRow,\n  DatasetWriteCommitResult,\n  DatasetWriteMode,\n  LakeStorage,\n} from \"./types\"\n\nexport const SQL_DIALECT = {\n  duckdb: \"duckdb\",\n} as const\n\nexport const SQL_DIALECTS = Object.values(SQL_DIALECT)\nexport type SqlDialect = (typeof SQL_DIALECT)[keyof typeof SQL_DIALECT]\n\nexport interface LakeStorageWithSql<TSqlDialect extends SqlDialect = SqlDialect>\n  extends LakeStorage {\n  readonly sql: LakeSqlExecutor<TSqlDialect>\n}\n\nexport interface LakeSqlExecutor<TSqlDialect extends SqlDialect = SqlDialect> {\n  readonly dialect: TSqlDialect\n  readonly capabilities: LakeSqlTransformCapabilities\n\n  preview(input: PreviewSqlTransformInput<TSqlDialect>): AsyncIterable<DatasetRow>\n  execute(input: ExecuteSqlTransformInput<TSqlDialect>): Promise<DatasetWriteCommitResult>\n}\n\nexport interface LakeSqlTransformCapabilities {\n  readonly preview: boolean\n  readonly supportsAppend: boolean\n  readonly supportsSnapshot: boolean\n}\n\nexport interface ExecuteSqlTransformInput<TSqlDialect extends SqlDialect = SqlDialect> {\n  readonly sources: Readonly<Record<string, SqlTransformSource>>\n  readonly sql: SqlTransformBody<TSqlDialect>\n  readonly target: DatasetDefinition\n  readonly mode: DatasetWriteMode\n  readonly producer?: DatasetProducer\n  readonly expectedLatestVersionId?: string\n  readonly commitMessage?: string\n}\n\nexport interface PreviewSqlTransformInput<TSqlDialect extends SqlDialect = SqlDialect> {\n  readonly sources: Readonly<Record<string, SqlTransformSource>>\n  readonly sql: SqlTransformBody<TSqlDialect>\n  readonly limit?: number\n}\n\nexport interface SqlTransformSource {\n  readonly dataset: DatasetDefinition\n  readonly versionId?: string\n}\n\nexport interface SqlTransformRelation {\n  toString(): string\n}\n\nexport type SqlTransformBody<_TSqlDialect extends SqlDialect = SqlDialect> = (\n  relations: Readonly<Record<string, SqlTransformRelation>>\n) => string\n\nexport function isSqlDialect(value: unknown): value is SqlDialect {\n  return typeof value === \"string\" && SQL_DIALECTS.includes(value as SqlDialect)\n}\n",
+    "import type { DatasetDefinition } from \"../datasets\"\nimport type { DatasetWriteMode } from \"../lake-storage\"\nimport { SQL_DIALECT } from \"../lake-storage/sql-transforms\"\nimport type { ScheduleDefinition, ScheduleReference } from \"../schedules\"\nimport { isScheduleDefinition } from \"../schedules\"\nimport { PipelineError } from \"./errors\"\nimport type {\n  PipelineBuilder,\n  PipelineDefinition,\n  PipelineGraph,\n  PipelineStepDefinition,\n  PipelineStepExecutorBuilder,\n  PipelineStepInputBuilder,\n  PipelineStepOutputBuilder,\n  PipelineStepOutputOptions,\n  PipelineStepRunHandler,\n} from \"./types\"\n\nfunction assertNonEmpty(value: string, field: string): void {\n  if (!value.trim()) {\n    throw new PipelineError(`Pipeline ${field} must not be empty.`)\n  }\n}\n\nfunction assertDataset(dataset: DatasetDefinition, field: string): void {\n  assertNonEmpty(dataset.id, field)\n}\n\nfunction assertDatasetWriteMode(mode: DatasetWriteMode): void {\n  if (mode !== \"snapshot\" && mode !== \"append\") {\n    throw new PipelineError(`Pipeline step output mode '${mode}' is not supported.`)\n  }\n}\n\nfunction assertInputs(inputs: Readonly<Record<string, DatasetDefinition>>): void {\n  const entries = Object.entries(inputs)\n  if (entries.length === 0) {\n    throw new PipelineError(\"Pipeline step input dataset must contain at least one entry.\")\n  }\n\n  for (const [name, dataset] of entries) {\n    assertNonEmpty(name, \"step input name\")\n    assertDataset(dataset, \"step input dataset\")\n  }\n}\n\nfunction scheduleReference(schedule: ScheduleDefinition): ScheduleReference {\n  if (!isScheduleDefinition(schedule)) {\n    throw new PipelineError(\"Pipeline .when(...) only accepts schedules.\")\n  }\n  return { type: \"schedule\", scheduleId: schedule.id }\n}\n\nfunction createPipelineBuilder<TId extends string>(\n  definition: PipelineDefinition<TId>\n): PipelineBuilder<TId> {\n  return {\n    ...definition,\n    when(schedule: ScheduleDefinition): PipelineBuilder<TId> {\n      return createPipelineBuilder({\n        ...definition,\n        triggers: [...definition.triggers, scheduleReference(schedule)],\n      })\n    },\n    // biome-ignore lint/suspicious/noThenProperty: Pipeline composition intentionally uses `.then(step)`.\n    then(step: PipelineStepDefinition): PipelineBuilder<TId> {\n      const graph: PipelineGraph = {\n        kind: \"sequence\",\n        nodes: [...definition.graph.nodes, { kind: \"step\", step }],\n      }\n\n      return createPipelineBuilder({\n        ...definition,\n        graph,\n      })\n    },\n  }\n}\n\n/**\n * Define one dataset transform step.\n *\n * The returned definition is inert until referenced by a pipeline definition.\n */\nexport function definePipelineStep<TId extends string>(id: TId): PipelineStepInputBuilder<TId> {\n  assertNonEmpty(id, \"step id\")\n\n  return {\n    inputs<TInputs extends Record<string, DatasetDefinition>>(\n      inputs: TInputs\n    ): PipelineStepOutputBuilder<TId, TInputs> {\n      assertInputs(inputs)\n\n      return {\n        output(\n          dataset: DatasetDefinition,\n          options: PipelineStepOutputOptions = {}\n        ): PipelineStepExecutorBuilder<TId, TInputs> {\n          assertDataset(dataset, \"step output dataset\")\n          const mode = options.mode ?? \"snapshot\"\n          assertDatasetWriteMode(mode)\n\n          return {\n            run(handler): PipelineStepDefinition<TId, TInputs> {\n              return {\n                kind: \"pipeline.step\",\n                id,\n                inputs,\n                output: dataset,\n                mode,\n                executor: {\n                  kind: \"run\",\n                  handler: handler as unknown as PipelineStepRunHandler,\n                },\n              }\n            },\n            sql(sql): PipelineStepDefinition<TId, TInputs> {\n              return {\n                kind: \"pipeline.step\",\n                id,\n                inputs,\n                output: dataset,\n                mode,\n                executor: {\n                  kind: \"sql\",\n                  dialect: SQL_DIALECT.duckdb,\n                  sql,\n                },\n              }\n            },\n          }\n        },\n      }\n    },\n  }\n}\n\n/**\n * Define a sequential pipeline that composes dataset transform steps.\n *\n * The returned definition is inert and safe to export from `pipelines/` modules.\n */\nexport function definePipeline<TId extends string>(id: TId): PipelineBuilder<TId> {\n  assertNonEmpty(id, \"id\")\n\n  return createPipelineBuilder({\n    kind: \"pipeline\",\n    id,\n    triggers: [],\n    graph: {\n      kind: \"sequence\",\n      nodes: [],\n    },\n  })\n}\n",
+    "import type { DatasetDefinition } from \"../datasets\"\nimport { isDatasetDefinition } from \"../datasets\"\nimport type {\n  DatasetRow,\n  DatasetVersion,\n  DatasetWriteMode,\n  ReadDatasetRowsInput,\n} from \"../lake-storage\"\nimport {\n  isSqlDialect,\n  type SqlDialect,\n  type SqlTransformBody,\n} from \"../lake-storage/sql-transforms\"\nimport type { Logger } from \"../logging\"\nimport type { ScheduleDefinition, ScheduleReference } from \"../schedules\"\nimport { isScheduleReference } from \"../schedules\"\n\n// ── Step execution ─────────────────────────────────────────\n\nexport type PipelineStepExecutor =\n  | {\n      readonly kind: \"sql\"\n      readonly dialect: SqlDialect\n      readonly sql: SqlTransformBody<SqlDialect>\n    }\n  | {\n      readonly kind: \"run\"\n      readonly handler: PipelineStepRunHandler\n    }\n\nexport interface PipelineStepInput {\n  readonly dataset: DatasetDefinition\n  readonly version: DatasetVersion\n  readRows(input?: Omit<ReadDatasetRowsInput, \"datasetId\" | \"versionId\">): AsyncIterable<DatasetRow>\n}\n\nexport interface PipelineStepOutput {\n  writeRows(rows: Iterable<DatasetRow> | AsyncIterable<DatasetRow>): Promise<void>\n}\n\nexport interface PipelineStepRunContext<\n  TInputs extends Record<string, DatasetDefinition> = Record<string, DatasetDefinition>,\n> {\n  readonly projectId: string\n  readonly pipelineId: string\n  readonly stepId: string\n  readonly runId: string\n  readonly signal: AbortSignal\n  readonly inputs: { readonly [K in keyof TInputs]: PipelineStepInput }\n  readonly output: PipelineStepOutput\n  readonly logger: Logger\n}\n\nexport type PipelineStepRunHandler<\n  TInputs extends Record<string, DatasetDefinition> = Record<string, DatasetDefinition>,\n> = (ctx: PipelineStepRunContext<TInputs>) => Promise<void> | void\n\n// ── Step definition ────────────────────────────────────────\n\nexport interface PipelineStepDefinition<\n  TId extends string = string,\n  TInputs extends Record<string, DatasetDefinition> = Record<string, DatasetDefinition>,\n> {\n  readonly kind: \"pipeline.step\"\n  readonly id: TId\n  readonly inputs: Readonly<TInputs>\n  readonly output: DatasetDefinition\n  readonly mode: DatasetWriteMode\n  readonly executor: PipelineStepExecutor\n}\n\n// ── Pipeline definition ────────────────────────────────────\n\nexport interface PipelineStepNode {\n  readonly kind: \"step\"\n  readonly step: PipelineStepDefinition\n}\n\nexport interface PipelineSequenceGraph {\n  readonly kind: \"sequence\"\n  readonly nodes: readonly PipelineStepNode[]\n}\n\nexport type PipelineGraph = PipelineSequenceGraph\n\n/**\n * Inert pipeline definition registered with Sixb.\n *\n * V1 executes a single sequential graph. The graph shape leaves room for\n * parallel nodes later without changing step definitions.\n */\nexport interface PipelineDefinition<TId extends string = string> {\n  readonly kind: \"pipeline\"\n  readonly id: TId\n  readonly triggers: readonly ScheduleReference[]\n  readonly graph: PipelineGraph\n}\n\n// ── Builder interfaces ─────────────────────────────────────\n\nexport interface PipelineStepInputBuilder<TId extends string = string> {\n  inputs<TInputs extends Record<string, DatasetDefinition>>(\n    inputs: TInputs\n  ): PipelineStepOutputBuilder<TId, TInputs>\n}\n\nexport interface PipelineStepOutputBuilder<\n  TId extends string = string,\n  TInputs extends Record<string, DatasetDefinition> = Record<string, DatasetDefinition>,\n> {\n  output(\n    dataset: DatasetDefinition,\n    options?: PipelineStepOutputOptions\n  ): PipelineStepExecutorBuilder<TId, TInputs>\n}\n\nexport interface PipelineStepExecutorBuilder<\n  TId extends string = string,\n  TInputs extends Record<string, DatasetDefinition> = Record<string, DatasetDefinition>,\n> {\n  run(handler: PipelineStepRunHandler<TInputs>): PipelineStepDefinition<TId, TInputs>\n  sql(sql: SqlTransformBody<SqlDialect>): PipelineStepDefinition<TId, TInputs>\n}\n\nexport interface PipelineStepOutputOptions {\n  readonly mode?: DatasetWriteMode\n}\n\nexport interface PipelineBuilder<TId extends string = string> extends PipelineDefinition<TId> {\n  when(schedule: ScheduleDefinition): PipelineBuilder<TId>\n  then(step: PipelineStepDefinition): PipelineBuilder<TId>\n}\n\n// ── Type guards ────────────────────────────────────────────\n\n/** Runtime type guard for values discovered from `pipelines/` modules. */\nexport function isPipelineDefinition(value: unknown): value is PipelineDefinition {\n  if (!isRecord(value)) return false\n  return (\n    value.kind === \"pipeline\" &&\n    typeof value.id === \"string\" &&\n    Array.isArray(value.triggers) &&\n    value.triggers.every(isScheduleReference) &&\n    isPipelineGraph(value.graph)\n  )\n}\n\nexport function isPipelineStepDefinition(value: unknown): value is PipelineStepDefinition {\n  return (\n    isRecord(value) &&\n    value.kind === \"pipeline.step\" &&\n    typeof value.id === \"string\" &&\n    isInputsRecord(value.inputs) &&\n    isDatasetDefinition(value.output) &&\n    isDatasetWriteMode(value.mode) &&\n    isPipelineStepExecutor(value.executor)\n  )\n}\n\nfunction isPipelineGraph(value: unknown): value is PipelineGraph {\n  return (\n    isRecord(value) &&\n    value.kind === \"sequence\" &&\n    Array.isArray(value.nodes) &&\n    value.nodes.every(\n      (node) => isRecord(node) && node.kind === \"step\" && isPipelineStepDefinition(node.step)\n    )\n  )\n}\n\nfunction isPipelineStepExecutor(value: unknown): value is PipelineStepExecutor {\n  if (!isRecord(value)) return false\n\n  switch (value.kind) {\n    case \"sql\":\n      return isSqlDialect(value.dialect) && typeof value.sql === \"function\"\n    case \"run\":\n      return typeof value.handler === \"function\"\n    default:\n      return false\n  }\n}\n\nfunction isInputsRecord(value: unknown): value is Readonly<Record<string, DatasetDefinition>> {\n  return (\n    isRecord(value) &&\n    Object.entries(value).every(\n      ([key, dataset]) => key.trim().length > 0 && isDatasetDefinition(dataset)\n    )\n  )\n}\n\nfunction isDatasetWriteMode(value: unknown): value is DatasetWriteMode {\n  return value === \"snapshot\" || value === \"append\"\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value)\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "DB6590A92C7F169B64756E2164756E21",
+  "names": []
+}

package/dist/{chunk-t72dvahb.js → chunk-bhxaq2nn.js}

@@ -1,4 +1,8 @@
 // @bun
+import {
+  captureSixbFailure
+} from "./chunk-0172wgm9.js";
+
 // src/error-reporting/normalize.ts
 function safeString(value) {
   try {
@@ -41,9 +45,12 @@ class SixbErrorReporter {
     this.handler = handler;
   }
   report(error, context) {
-    if (!this.handler)
+    const normalizedError = normalizeReportedError(error);
+    if (!this.handler) {
+      reportToConsole(normalizedError, context);
       return;
-    const invocation = Promise.resolve().then(() => this.handler?.(normalizeReportedError(error), context)).then(() => {
+    }
+    const invocation = Promise.resolve().then(() => this.handler?.(normalizedError, context)).then(() => {
       return;
     }).catch((handlerError) => {
       try {
@@ -68,6 +75,11 @@ class SixbErrorReporter {
     }
   }
 }
+function reportToConsole(error, context) {
+  try {
+    console.error(`[Sixb] Unhandled ${context.type}:`, error, context);
+  } catch {}
+}
 async function settleWithin(promises, timeoutMs) {
   let timeout;
   try {
@@ -83,51 +95,49 @@ async function settleWithin(promises, timeoutMs) {
   }
 }
 
-// src/error-reporting/capability.ts
+// src/error-reporting/reports.ts
 import { randomUUID } from "crypto";
 function resolveOccurredAt(occurredAt) {
   if (occurredAt instanceof Date)
     return occurredAt.toISOString();
   return occurredAt ?? new Date().toISOString();
 }
-var ERROR_REPORTER = Symbol("sixb.error-reporter");
-function asHost(value) {
-  if (typeof value !== "object" && typeof value !== "function" || value === null) {
-    return null;
-  }
-  return value;
-}
-function attachSixbErrorReporter(host, handler) {
-  const reporter = new SixbErrorReporter(handler);
-  host[ERROR_REPORTER] = reporter;
-  return reporter;
-}
-function shareSixbErrorReporter(source, target) {
-  const reporter = source[ERROR_REPORTER];
-  if (reporter)
-    target[ERROR_REPORTER] = reporter;
-}
-function reportRunFailure(host, error, input) {
-  const reporter = asHost(host)?.[ERROR_REPORTER];
-  if (!reporter)
-    return;
-  const occurredAt = resolveOccurredAt(input.occurredAt);
+function reportRunFailure(reporter, error, input) {
+  const occurredAt = input.failure.at;
   reporter.report(error, {
+    ...input,
     type: "run.failed",
-    notificationId: `project:${input.projectId}:run:${input.run.kind}:${input.run.runId}:failed:${occurredAt}`,
+    notificationId: `project:${input.projectId}:run:${input.runKind}:${input.run.runId}:failed:${occurredAt}`,
+    occurredAt
+  });
+}
+function reportActionPhaseFailure(reporter, error, input) {
+  reporter.report(error, {
+    type: "action.phase.failed",
+    notificationId: `project:${input.projectId}:action:${input.actionId}:run:${input.runId}:phase:${input.phase}:failed:${input.failure.at}`,
     projectId: input.projectId,
-    occurredAt,
-    ...input.attempt === undefined ? {} : { attempt: input.attempt },
-    run: input.run
+    occurredAt: input.failure.at,
+    actionId: input.actionId,
+    runId: input.runId,
+    phase: input.phase,
+    failure: input.failure
   });
 }
-function reportEventDeliveryFailure(host, error, input) {
-  const reporter = asHost(host)?.[ERROR_REPORTER];
-  if (!reporter)
-    return;
-  const occurredAt = resolveOccurredAt(input.occurredAt);
+function reportEventDeliveryFailure(reporter, error, input) {
+  const occurredAt = input.failure?.at ?? resolveOccurredAt(input.occurredAt);
   const attempts = input.attempts ?? 1;
   const eventIds = input.eventIds === undefined ? undefined : [...input.eventIds].sort();
+  const eventTypes = [...input.eventTypes];
+  const failure = input.failure ?? captureSixbFailure(error, {
+    allowedCodes: ["event.delivery_failed"],
+    defaultCode: "event.delivery_failed",
+    details: {
+      attempts,
+      eventTypes,
+      ...eventIds === undefined ? {} : { eventIds }
+    },
+    at: new Date(occurredAt)
+  });
   const firstEventId = eventIds?.[0];
   const occurrence = firstEventId ? `events:${firstEventId}:attempt:${attempts}` : `emit:${input.occurrenceId ?? randomUUID()}`;
   reporter.report(error, {
@@ -135,33 +145,40 @@ function reportEventDeliveryFailure(host, error, input) {
     notificationId: `project:${input.projectId}:event-delivery:${occurrence}`,
     projectId: input.projectId,
     occurredAt,
+    failure,
     attempts,
-    eventTypes: input.eventTypes,
+    eventTypes,
     ...eventIds === undefined ? {} : { eventIds }
   });
 }
-function reportRuleEvaluationFailure(host, error, input) {
-  const reporter = asHost(host)?.[ERROR_REPORTER];
-  if (!reporter)
-    return;
+function reportRuleEvaluationFailure(reporter, error, input) {
   const occurredAt = resolveOccurredAt(input.occurredAt);
   const eventIds = [...input.eventIds ?? []].sort();
+  const failure = captureSixbFailure(error, {
+    allowedCodes: ["internal.unexpected"],
+    defaultCode: "internal.unexpected",
+    details: {
+      source: input.source,
+      eventIds,
+      ...input.ruleId === undefined ? {} : { ruleId: input.ruleId },
+      ...input.subject === undefined ? {} : { subject: input.subject }
+    },
+    at: new Date(occurredAt)
+  });
   const occurrence = input.ruleId && input.subject ? `${input.ruleId}:${input.subject.objectTypeId}:${input.subject.primaryId}` : eventIds[0] ?? "current-state";
   reporter.report(error, {
     type: "rule.evaluation.failed",
     notificationId: `project:${input.projectId}:rule-evaluation:${input.source}:${occurrence}:failed:${occurredAt}`,
     projectId: input.projectId,
     occurredAt,
+    failure,
     source: input.source,
     eventIds,
     ...input.ruleId === undefined ? {} : { ruleId: input.ruleId },
     ...input.subject === undefined ? {} : { subject: input.subject }
   });
 }
-async function flushSixbErrors(host, timeoutMs) {
-  await asHost(host)?.[ERROR_REPORTER]?.flush(timeoutMs);
-}
 
-export { normalizeReportedError, SixbErrorReporter, attachSixbErrorReporter, shareSixbErrorReporter, reportRunFailure, reportEventDeliveryFailure, reportRuleEvaluationFailure, flushSixbErrors };
+export { normalizeReportedError, SixbErrorReporter, reportRunFailure, reportActionPhaseFailure, reportEventDeliveryFailure, reportRuleEvaluationFailure };
 
-//# debugId=62C3DE138354F19B64756E2164756E21
+//# debugId=FF18AB4B4D55858D64756E2164756E21

package/dist/chunk-bhxaq2nn.js.map

@@ -0,0 +1,12 @@
+{
+  "version": 3,
+  "sources": ["../src/error-reporting/normalize.ts", "../src/error-reporting/reporter.ts", "../src/error-reporting/reports.ts"],
+  "sourcesContent": [
+    "function safeString(value: unknown): string {\n  try {\n    return String(value)\n  } catch {\n    return \"Unknown thrown value\"\n  }\n}\n\n/** Preserve native errors and safely wrap arbitrary thrown values. */\nexport function normalizeReportedError(value: unknown): Error {\n  if (value instanceof Error) {\n    return value\n  }\n\n  if (typeof value === \"object\" && value !== null) {\n    let message: unknown\n    let name: unknown\n    try {\n      message = Reflect.get(value, \"message\")\n      name = Reflect.get(value, \"name\")\n    } catch {\n      return new Error(\"Unknown thrown value\")\n    }\n\n    if (typeof message === \"string\") {\n      const error = new Error(message)\n      if (typeof name === \"string\" && name.trim()) {\n        error.name = name\n      }\n      return error\n    }\n  }\n\n  return new Error(safeString(value))\n}\n",
+    "import { normalizeReportedError } from \"./normalize\"\nimport type { SixbErrorContext, SixbErrorHandler } from \"./types\"\n\nconst DEFAULT_FLUSH_TIMEOUT_MS = 5_000\n\nexport interface ErrorReporter {\n  report(error: unknown, context: SixbErrorContext): void\n}\n\n/** Failure-isolated, non-blocking adapter around the configured callback. */\nexport class SixbErrorReporter implements ErrorReporter {\n  private readonly pending = new Set<Promise<void>>()\n\n  constructor(private readonly handler?: SixbErrorHandler) {}\n\n  report(error: unknown, context: SixbErrorContext): void {\n    const normalizedError = normalizeReportedError(error)\n    if (!this.handler) {\n      reportToConsole(normalizedError, context)\n      return\n    }\n\n    const invocation = Promise.resolve()\n      .then(() => this.handler?.(normalizedError, context))\n      .then(() => undefined)\n      .catch((handlerError) => {\n        try {\n          console.error(\"[Sixb] onError handler failed:\", handlerError)\n        } catch {\n          // Error reporting must never escape back into framework execution.\n        }\n      })\n\n    const tracked = invocation.finally(() => {\n      this.pending.delete(tracked)\n    })\n    this.pending.add(tracked)\n  }\n\n  async flush(timeoutMs = DEFAULT_FLUSH_TIMEOUT_MS): Promise<void> {\n    const deadline = Date.now() + Math.max(0, timeoutMs)\n    while (this.pending.size > 0) {\n      const remainingMs = deadline - Date.now()\n      if (remainingMs <= 0 || !(await settleWithin([...this.pending], remainingMs))) {\n        try {\n          console.error(\n            `[Sixb] Timed out after ${timeoutMs}ms waiting for ${this.pending.size} onError handler(s).`\n          )\n        } catch {\n          // Error reporting must never escape back into framework shutdown.\n        }\n        return\n      }\n    }\n  }\n}\n\nfunction reportToConsole(error: Error, context: SixbErrorContext): void {\n  try {\n    console.error(`[Sixb] Unhandled ${context.type}:`, error, context)\n  } catch {\n    // Error reporting must never escape back into framework execution.\n  }\n}\n\nasync function settleWithin(\n  promises: readonly Promise<void>[],\n  timeoutMs: number\n): Promise<boolean> {\n  let timeout: ReturnType<typeof setTimeout> | undefined\n  try {\n    return await Promise.race([\n      Promise.allSettled(promises).then(() => true),\n      new Promise<false>((resolve) => {\n        timeout = setTimeout(() => resolve(false), timeoutMs)\n      }),\n    ])\n  } finally {\n    if (timeout) clearTimeout(timeout)\n  }\n}\n",
+    "import { randomUUID } from \"node:crypto\"\nimport { captureSixbFailure } from \"../errors/internal\"\nimport type { SixbFailure } from \"../errors/types\"\nimport type { ActionRunFailure } from \"../storage/action-runs\"\nimport type { ErrorReporter } from \"./reporter\"\nimport type { SixbFailedRun } from \"./types\"\n\nfunction resolveOccurredAt(occurredAt?: Date | string): string {\n  if (occurredAt instanceof Date) return occurredAt.toISOString()\n  return occurredAt ?? new Date().toISOString()\n}\n\nexport type ReportRunFailureInput = SixbFailedRun & {\n  readonly projectId: string\n  readonly attempt?: number\n}\n\nexport function reportRunFailure(\n  reporter: ErrorReporter,\n  error: unknown,\n  input: ReportRunFailureInput\n): void {\n  const occurredAt = input.failure.at\n  reporter.report(error, {\n    ...input,\n    type: \"run.failed\",\n    notificationId: `project:${input.projectId}:run:${input.runKind}:${input.run.runId}:failed:${occurredAt}`,\n    occurredAt,\n  })\n}\n\nexport interface ReportActionPhaseFailureInput {\n  readonly projectId: string\n  readonly actionId: string\n  readonly runId: string\n  readonly phase: \"effects\"\n  readonly failure: ActionRunFailure<\"effects\">\n}\n\nexport function reportActionPhaseFailure(\n  reporter: ErrorReporter,\n  error: unknown,\n  input: ReportActionPhaseFailureInput\n): void {\n  reporter.report(error, {\n    type: \"action.phase.failed\",\n    notificationId: `project:${input.projectId}:action:${input.actionId}:run:${input.runId}:phase:${input.phase}:failed:${input.failure.at}`,\n    projectId: input.projectId,\n    occurredAt: input.failure.at,\n    actionId: input.actionId,\n    runId: input.runId,\n    phase: input.phase,\n    failure: input.failure,\n  })\n}\n\nexport interface ReportEventDeliveryFailureInput {\n  readonly projectId: string\n  /** Exact durable failure when this delivery was persisted by the ontology outbox. */\n  readonly failure?: SixbFailure<\"event.delivery_failed\">\n  /** Event types that never reached subscribers. Payloads must not be passed in. */\n  readonly eventTypes: readonly string[]\n  readonly occurredAt?: Date | string\n  /** Delivery attempts so far. Defaults to 1, which is right for a rejected emit. */\n  readonly attempts?: number\n  /** Envelope ids, when the events were persisted before delivery failed. */\n  readonly eventIds?: readonly string[]\n  /**\n   * Identity of this loss, used only when nothing was persisted. Defaults to a fresh id; pass one to\n   * make a report reproducible in a test.\n   */\n  readonly occurrenceId?: string\n}\n\n/**\n * Report that domain events were lost.\n *\n * Both delivery paths land here: the outbox dispatcher, which has persisted envelope ids and retries,\n * and a rejected `events.emit()`, which has only the types. Reporting must work for both — an earlier\n * version returned early on an empty `eventIds`, which silently dropped exactly the case this exists\n * to surface.\n *\n * Each path keys on the strongest identity it has. The outbox persisted its envelopes, so the ids plus\n * the attempt number name the loss exactly and stay stable if one report is delivered twice. A rejected\n * emit persisted nothing and is always terminal at attempt 1, so the type list alone was its whole\n * correlation — and two schedules losing `schedule.triggered` in the same broker outage are dispatched\n * concurrently, land in the same millisecond, and were therefore one notification. A timestamp does not\n * fix that; an identity does.\n */\nexport function reportEventDeliveryFailure(\n  reporter: ErrorReporter,\n  error: unknown,\n  input: ReportEventDeliveryFailureInput\n): void {\n  const occurredAt = input.failure?.at ?? resolveOccurredAt(input.occurredAt)\n  const attempts = input.attempts ?? 1\n  const eventIds = input.eventIds === undefined ? undefined : [...input.eventIds].sort()\n  const eventTypes = [...input.eventTypes]\n  const failure =\n    input.failure ??\n    captureSixbFailure(error, {\n      allowedCodes: [\"event.delivery_failed\"],\n      defaultCode: \"event.delivery_failed\",\n      details: {\n        attempts,\n        eventTypes,\n        ...(eventIds === undefined ? {} : { eventIds }),\n      },\n      at: new Date(occurredAt),\n    })\n  const firstEventId = eventIds?.[0]\n  const occurrence = firstEventId\n    ? `events:${firstEventId}:attempt:${attempts}`\n    : `emit:${input.occurrenceId ?? randomUUID()}`\n  reporter.report(error, {\n    type: \"event.delivery.failed\",\n    notificationId: `project:${input.projectId}:event-delivery:${occurrence}`,\n    projectId: input.projectId,\n    occurredAt,\n    failure,\n    attempts,\n    eventTypes,\n    ...(eventIds === undefined ? {} : { eventIds }),\n  })\n}\n\nexport interface ReportRuleEvaluationFailureInput {\n  readonly projectId: string\n  readonly source: \"live\" | \"reconciliation\"\n  readonly eventIds?: readonly string[]\n  readonly occurredAt?: Date | string\n  /** Set when the failure could be attributed to one rule/subject candidate. */\n  readonly ruleId?: string\n  readonly subject?: { readonly objectTypeId: string; readonly primaryId: string }\n}\n\nexport function reportRuleEvaluationFailure(\n  reporter: ErrorReporter,\n  error: unknown,\n  input: ReportRuleEvaluationFailureInput\n): void {\n  const occurredAt = resolveOccurredAt(input.occurredAt)\n  const eventIds = [...(input.eventIds ?? [])].sort()\n  const failure = captureSixbFailure(error, {\n    allowedCodes: [\"internal.unexpected\"],\n    defaultCode: \"internal.unexpected\",\n    details: {\n      source: input.source,\n      eventIds,\n      ...(input.ruleId === undefined ? {} : { ruleId: input.ruleId }),\n      ...(input.subject === undefined ? {} : { subject: input.subject }),\n    },\n    at: new Date(occurredAt),\n  })\n  // A candidate-level failure keys on the candidate, so two rules failing over the same batch stay\n  // two notifications rather than collapsing into one.\n  const occurrence =\n    input.ruleId && input.subject\n      ? `${input.ruleId}:${input.subject.objectTypeId}:${input.subject.primaryId}`\n      : (eventIds[0] ?? \"current-state\")\n  reporter.report(error, {\n    type: \"rule.evaluation.failed\",\n    notificationId: `project:${input.projectId}:rule-evaluation:${input.source}:${occurrence}:failed:${occurredAt}`,\n    projectId: input.projectId,\n    occurredAt,\n    failure,\n    source: input.source,\n    eventIds,\n    ...(input.ruleId === undefined ? {} : { ruleId: input.ruleId }),\n    ...(input.subject === undefined ? {} : { subject: input.subject }),\n  })\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "FF18AB4B4D55858D64756E2164756E21",
+  "names": []
+}