@sixb/core 0.1.1 → 0.1.3

package/dist/chunk-km4rkj4t.js

@@ -0,0 +1,402 @@
+// @bun
+import {
+  isOAuthConnectorDefinition
+} from "./chunk-8m5ejdpn.js";
+import {
+  createPrimitiveExecutionRecord,
+  ensureExecutionRecord,
+  executionRecordInputFromRuntime
+} from "./chunk-4aw0jwk0.js";
+import {
+  SYNC_RUN_FAILURE_CODES
+} from "./chunk-xmggaxg4.js";
+import {
+  SyncRunError
+} from "./chunk-62c7t4jc.js";
+import {
+  ConnectorConnectionStorageError
+} from "./chunk-5gd7tpv6.js";
+import {
+  reportRunFailure
+} from "./chunk-dsrkgtnh.js";
+import {
+  AuthorizationError,
+  assertAuthorized,
+  assertProviderAccess,
+  resolveExecutionScopeAuthorization
+} from "./chunk-4z3n1dzt.js";
+import {
+  createSixbError,
+  isSixbError,
+  toSixbFailure
+} from "./chunk-0172wgm9.js";
+
+// src/connectors/errors.ts
+class ConnectorError extends Error {
+  name = "ConnectorError";
+}
+
+class ConnectorNotFoundError extends ConnectorError {
+  connectorId;
+  name = "ConnectorNotFoundError";
+  constructor(connectorId) {
+    super(`Unknown connector '${connectorId}'`);
+    this.connectorId = connectorId;
+  }
+}
+
+class ConnectorOAuthError extends ConnectorError {
+  kind;
+  name = "ConnectorOAuthError";
+  constructor(kind, message, options) {
+    super(message, options);
+    this.kind = kind;
+  }
+}
+function createConnectorCodedError(code, message, options = {}) {
+  return createSixbError(code, message.startsWith("[Sixb]") ? message : `[Sixb] ${message}`, options);
+}
+function createAmbiguousProviderOperationError(options = {}) {
+  return createConnectorCodedError("connector.provider_failed", "Connector provider operation outcome is ambiguous.", options);
+}
+function oauthErrorKind(error) {
+  return error instanceof ConnectorOAuthError ? error.kind : "ambiguous";
+}
+function providerFailureCode(error) {
+  return oauthErrorKind(error) === "retryable" ? "connector.provider_unavailable" : "connector.provider_failed";
+}
+function providerBoundaryError(error, code, message) {
+  if (isSixbError(error) && error.code.startsWith("connector."))
+    return error;
+  return createConnectorCodedError(code, message, { cause: error });
+}
+function isConnectorStorageError(error, code) {
+  return error instanceof ConnectorConnectionStorageError && (code === undefined || error.code === code);
+}
+function storageBoundaryError(error, message) {
+  return createConnectorCodedError("internal.unexpected", message, { cause: error });
+}
+async function recoverConnectorFailure(primaryError, message, recovery) {
+  try {
+    return await recovery();
+  } catch (recoveryError) {
+    throw createConnectorCodedError("internal.unexpected", message, {
+      cause: new AggregateError([primaryError, recoveryError], message)
+    });
+  }
+}
+
+// src/syncs/errors.ts
+class SyncValidationError extends Error {
+  name = "SyncValidationError";
+}
+
+// src/syncs/run-dispatch.ts
+import { randomUUID } from "crypto";
+class SyncRunDispatcher {
+  dependencies;
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  async dispatch(input) {
+    assertAutomaticDispatchInput(input);
+    const sync = this.dependencies.definitions.syncs.getById(input.syncId);
+    if (!sync)
+      throw new SyncValidationError(`[Sixb] Unknown sync '${input.syncId}'`);
+    return dispatchSyncRun({
+      errorReporterHost: this.dependencies,
+      projectId: this.dependencies.id,
+      sync,
+      storage: this.dependencies.storage,
+      queue: this.dependencies.queues.syncRuns,
+      runId: input.runId,
+      expectedLatestVersionId: input.expectedLatestVersionId,
+      commitMessage: input.commitMessage,
+      metadata: input.metadata,
+      validateExistingRun: (run, storage) => assertAutomaticExecutionIdentity(storage, this.dependencies.id, input, run),
+      createExecution: async (executionId, runId) => createPrimitiveExecutionRecord({
+        id: executionId,
+        primitive: { kind: "sync", id: sync.id, runId },
+        origin: {
+          type: "automatic",
+          projectId: this.dependencies.id,
+          source: input.source,
+          correlationId: input.correlationId
+        }
+      })
+    });
+  }
+}
+async function dispatchSyncRun(input) {
+  const runId = createSyncRunId(input.runId);
+  const persisted = await persistSyncRun(input, runId);
+  if (!persisted.publish)
+    return existingSyncRunResult(persisted.run);
+  return publishSyncRun(input, persisted);
+}
+async function persistSyncRun(input, runId) {
+  const syncRuns = requireSyncRunStorage(input.storage);
+  const existing = await syncRuns.getById({ projectId: input.projectId, id: runId });
+  if (existing)
+    return reuseSyncRun(input, existing);
+  const execution = await input.createExecution(`exec_${randomUUID()}`, runId);
+  const queuedAt = new Date;
+  try {
+    return await input.storage.transaction(async (tx) => {
+      const transactionalRuns = requireSyncRunStorage(tx);
+      const raced = await transactionalRuns.getById({ projectId: input.projectId, id: runId });
+      if (raced) {
+        assertExistingRunMatchesRequest(raced, input);
+        await input.validateExistingRun?.(raced, tx);
+        return { publish: false, run: raced };
+      }
+      await tx.executions.create(execution);
+      const run = await transactionalRuns.queue({
+        projectId: input.projectId,
+        id: runId,
+        executionId: execution.id,
+        syncId: input.sync.id,
+        datasetId: input.sync.target.dataset.id,
+        mode: input.sync.config.mode,
+        queuedAt,
+        expectedLatestVersionId: input.expectedLatestVersionId,
+        commitMessage: input.commitMessage
+      });
+      return { publish: true, run, execution, queuedAt, created: true };
+    }, { isolation: "serializable" });
+  } catch (error) {
+    if (!(error instanceof SyncRunError))
+      throw error;
+    const raced = await syncRuns.getById({ projectId: input.projectId, id: runId });
+    if (!raced)
+      throw error;
+    assertExistingRunMatchesRequest(raced, input);
+    await input.validateExistingRun?.(raced, input.storage);
+    return { publish: false, run: raced };
+  }
+}
+async function reuseSyncRun(input, existing) {
+  assertExistingRunMatchesRequest(existing, input);
+  await input.validateExistingRun?.(existing, input.storage);
+  if (existing.status !== "failed" || existing.error?.code !== "queue.enqueue_failed" || !existing.error.retryable) {
+    return { publish: false, run: existing };
+  }
+  const execution = await input.storage.executions.getById({
+    projectId: input.projectId,
+    id: existing.executionId
+  });
+  if (!execution) {
+    throw new SyncRunError(`[Sixb] Execution '${existing.executionId}' for Sync run '${existing.id}' was not found.`);
+  }
+  const queuedAt = new Date;
+  const run = await requireSyncRunStorage(input.storage).queue({
+    projectId: input.projectId,
+    id: existing.id,
+    executionId: existing.executionId,
+    syncId: existing.syncId,
+    datasetId: existing.datasetId,
+    mode: existing.mode,
+    queuedAt,
+    expectedLatestVersionId: existing.expectedLatestVersionId,
+    commitMessage: existing.commitMessage
+  });
+  return { publish: true, run, execution, queuedAt, created: false };
+}
+async function publishSyncRun(input, persisted) {
+  try {
+    const [job] = await input.queue.enqueue({
+      projectId: input.projectId,
+      jobs: [
+        {
+          id: persisted.run.id,
+          type: "sync.run.requested",
+          payload: { runId: persisted.run.id },
+          ...input.metadata === undefined ? {} : { metadata: input.metadata }
+        }
+      ]
+    });
+    return {
+      syncId: persisted.run.syncId,
+      runId: persisted.run.id,
+      queuedAt: persisted.queuedAt.toISOString(),
+      ...job?.id ? { jobId: job.id } : {},
+      created: persisted.created
+    };
+  } catch (error) {
+    const failedAt = new Date;
+    const failure = toEnqueueFailure(error, persisted.run, failedAt);
+    const failed = await requireSyncRunStorage(input.storage).finish({
+      projectId: input.projectId,
+      id: persisted.run.id,
+      status: "failed",
+      finishedAt: failedAt,
+      error: failure
+    });
+    reportRunFailure(input.errorReporterHost, error, {
+      projectId: input.projectId,
+      runKind: "sync",
+      run: { runId: failed.id, syncId: failed.syncId },
+      failure
+    });
+    throw error;
+  }
+}
+function assertExistingRunMatchesRequest(existing, input) {
+  if (existing.syncId !== input.sync.id || existing.datasetId !== input.sync.target.dataset.id || existing.mode !== input.sync.config.mode || existing.expectedLatestVersionId !== input.expectedLatestVersionId || existing.commitMessage !== input.commitMessage) {
+    throw new SyncRunError(`[Sixb] Sync run '${existing.id}' already exists with a different request payload.`);
+  }
+}
+function existingSyncRunResult(existing) {
+  return {
+    syncId: existing.syncId,
+    runId: existing.id,
+    queuedAt: existing.queuedAt.toISOString(),
+    created: false
+  };
+}
+function requireSyncRunStorage(storage) {
+  if (!storage.syncRuns)
+    throw new SyncValidationError("[Sixb] Sync run storage is not configured.");
+  return storage.syncRuns;
+}
+function createSyncRunId(runId) {
+  if (runId === undefined)
+    return `run_${randomUUID()}`;
+  if (!runId.trim())
+    throw new SyncValidationError("[Sixb] Sync run id must not be empty");
+  return runId;
+}
+function assertAutomaticDispatchInput(input) {
+  assertNonBlank(input.syncId, "Sync id");
+  assertNonBlank(input.runId, "Sync run id");
+  assertNonBlank(input.source.eventId, "Sync source event id");
+  assertNonBlank(input.correlationId, "Sync correlation id");
+}
+async function assertAutomaticExecutionIdentity(storage, projectId, input, run) {
+  const execution = await storage.executions.getById({ projectId, id: run.executionId });
+  if (!execution || execution.source.type !== input.source.type || execution.source.eventId !== input.source.eventId || execution.correlationId !== input.correlationId || execution.requestedBy !== undefined) {
+    throw new SyncValidationError(`[Sixb] Sync run '${run.id}' already exists with different automatic provenance.`);
+  }
+}
+function toEnqueueFailure(error, run, at) {
+  const enqueueError = createSixbError("queue.enqueue_failed", `[Sixb] Could not enqueue Sync run '${run.id}'.`, {
+    cause: error,
+    details: { syncId: run.syncId, runId: run.id, phase: "enqueue" }
+  });
+  return toSixbFailure(enqueueError, { allowedCodes: SYNC_RUN_FAILURE_CODES, at });
+}
+function assertNonBlank(value, label) {
+  if (!value.trim())
+    throw new SyncValidationError(`[Sixb] ${label} must not be empty.`);
+}
+
+// src/syncs/request.ts
+async function requestSyncRun(runtime, execution, sync, options = {}) {
+  assertAuthorized(runtime, { kind: "sync.run", syncId: sync.id });
+  if (!runtime.storage.syncRuns) {
+    throw new SyncValidationError("[Sixb] Sync run storage is not configured.");
+  }
+  const queue = runtime.queues.syncRuns;
+  if (!queue) {
+    throw new SyncValidationError("[Sixb] Sync run queue is not configured.");
+  }
+  return dispatchSyncRun({
+    errorReporterHost: runtime,
+    projectId: runtime.projectId,
+    sync,
+    storage: runtime.storage,
+    queue,
+    ...options,
+    createExecution: async (executionId, runId) => {
+      const caller = await ensureExecutionRecord(runtime.storage.executions, executionRecordInputFromRuntime({
+        execution,
+        runtimeAuthorization: runtime.runtimeAuthorization
+      }));
+      return createPrimitiveExecutionRecord({
+        id: executionId,
+        primitive: { kind: "sync", id: sync.id, runId },
+        origin: { type: "execution", parent: caller }
+      });
+    }
+  });
+}
+
+// src/connectors/execution.ts
+var sourceResolvers = new WeakMap;
+function createConnectorRuntime(runtime, execution, service) {
+  const connector = (definition, selector) => {
+    if (isOAuthConnectorDefinition(definition)) {
+      assertConnectorConnectionAccess(runtime, execution);
+      if (!selector) {
+        throw createConnectorCodedError("connector.configuration_invalid", `[Sixb] Connector '${definition.id}' uses persistent connections and requires an explicit owner and slot.`);
+      }
+      return service.connectConnection(definition, selector);
+    }
+    if (selector) {
+      throw createConnectorCodedError("connector.configuration_invalid", `[Sixb] Static connector '${definition.id}' does not accept a connection.`);
+    }
+    assertProviderAccess(runtime, execution, "connector.connect");
+    return service.connect(definition);
+  };
+  registerConnectorExecutionSourceResolver(connector, {
+    async list(definition) {
+      if (!isOAuthConnectorDefinition(definition)) {
+        return [
+          {
+            connect: (_signal) => connector(definition)
+          }
+        ];
+      }
+      assertConnectorConnectionAccess(runtime, execution);
+      const connections = await service.listExecutionConnections(definition);
+      return connections.map((connection) => ({
+        connection: {
+          id: connection.id,
+          connectorId: connection.connectorId,
+          owner: connection.owner,
+          slot: connection.slot,
+          account: connection.account
+        },
+        connect: (signal) => service.connectExecutionConnection(definition, connection, signal)
+      }));
+    }
+  });
+  return connector;
+}
+function registerConnectorExecutionSourceResolver(connector, resolver) {
+  const registered = sourceResolvers.get(connector);
+  if (registered && registered !== resolver) {
+    throw new Error("[Sixb] Connector source resolver is already registered for this execution.");
+  }
+  sourceResolvers.set(connector, resolver);
+}
+function getConnectorExecutionSourceResolver(connector) {
+  const resolver = sourceResolvers.get(connector);
+  if (resolver)
+    return resolver;
+  return {
+    async list(definition) {
+      if (isOAuthConnectorDefinition(definition)) {
+        throw createConnectorCodedError("connector.configuration_invalid", `[Sixb] OAuth connector '${definition.id}' cannot be resolved without the managed connection runtime.`);
+      }
+      return [
+        {
+          connect: (_signal) => connector(definition)
+        }
+      ];
+    }
+  };
+}
+function assertConnectorConnectionAccess(runtime, execution) {
+  const resolved = resolveExecutionScopeAuthorization(runtime.projectId, {
+    execution,
+    authorization: runtime.runtimeAuthorization
+  });
+  if (resolved.type === "unrestricted" && resolved.ref.type === "trustedPrimitive")
+    return;
+  throw new AuthorizationError("privileged:connector-connection.connect", "[Sixb] Connector connection clients are restricted to trusted primitive executions.");
+}
+
+export { ConnectorError, ConnectorNotFoundError, ConnectorOAuthError, createConnectorCodedError, createAmbiguousProviderOperationError, oauthErrorKind, providerFailureCode, providerBoundaryError, isConnectorStorageError, storageBoundaryError, recoverConnectorFailure, createConnectorRuntime, getConnectorExecutionSourceResolver, SyncValidationError, SyncRunDispatcher, requestSyncRun };
+
+//# debugId=ED1A30ED8A438D8864756E2164756E21

package/dist/chunk-km4rkj4t.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": []
+}