@sixb/core 0.1.1 → 0.1.3

package/dist/chunk-4aw0jwk0.js

@@ -0,0 +1,118 @@
+// @bun
+import {
+  ExecutionStorageError
+} from "./chunk-h9kxd41f.js";
+import {
+  createTrustedPrimitiveRuntimeAuthorization,
+  getAuthorizationRef
+} from "./chunk-4z3n1dzt.js";
+
+// src/execution/durable.ts
+import { isDeepStrictEqual } from "util";
+function executionRecordInputFromRuntime(input) {
+  const execution = input.execution;
+  return {
+    id: execution.id,
+    projectId: execution.projectId,
+    ...execution.requestedBy === undefined ? {} : { requestedBy: structuredClone(execution.requestedBy) },
+    executor: durableExecutor(execution),
+    source: structuredClone(execution.source),
+    correlationId: execution.correlationId,
+    authorizationRef: getAuthorizationRef(input.runtimeAuthorization)
+  };
+}
+async function ensureExecutionRecord(storage, input) {
+  const existing = await storage.getById({ projectId: input.projectId, id: input.id });
+  if (existing) {
+    assertExecutionRecordMatches(existing, input);
+    return existing;
+  }
+  try {
+    return await storage.create(input);
+  } catch (error) {
+    if (!(error instanceof ExecutionStorageError) || error.code !== "duplicate_execution") {
+      throw error;
+    }
+    const raced = await storage.getById({ projectId: input.projectId, id: input.id });
+    if (!raced)
+      throw error;
+    assertExecutionRecordMatches(raced, input);
+    return raced;
+  }
+}
+function createPrimitiveExecutionRecord(input) {
+  const provenance = input.origin.type === "execution" ? {
+    projectId: input.origin.parent.projectId,
+    ...input.origin.parent.requestedBy === undefined ? {} : { requestedBy: structuredClone(input.origin.parent.requestedBy) },
+    source: { type: "execution", executionId: input.origin.parent.id },
+    correlationId: input.origin.parent.correlationId
+  } : {
+    projectId: input.origin.projectId,
+    ...input.origin.requestedBy === undefined ? {} : { requestedBy: structuredClone(input.origin.requestedBy) },
+    source: structuredClone(input.origin.source),
+    correlationId: input.origin.correlationId
+  };
+  return {
+    id: input.id,
+    ...provenance,
+    executor: {
+      type: "primitive",
+      kind: input.primitive.kind,
+      runId: input.primitive.runId
+    },
+    authorizationRef: {
+      type: "trustedPrimitive",
+      primitive: structuredClone(input.primitive)
+    }
+  };
+}
+function restoreTrustedPrimitiveExecutionScope(input) {
+  assertPrimitiveExecution(input.execution, input.primitive);
+  const context = Object.freeze({
+    id: input.execution.id,
+    projectId: input.execution.projectId,
+    ...input.execution.requestedBy === undefined ? {} : { requestedBy: Object.freeze(structuredClone(input.execution.requestedBy)) },
+    executor: Object.freeze({ type: "primitive", ...structuredClone(input.primitive) }),
+    source: Object.freeze(structuredClone(input.execution.source)),
+    correlationId: input.execution.correlationId
+  });
+  return Object.freeze({
+    execution: context,
+    authorization: createTrustedPrimitiveRuntimeAuthorization({
+      projectId: input.execution.projectId,
+      primitive: input.primitive
+    })
+  });
+}
+function durableExecutor(execution) {
+  switch (execution.executor.type) {
+    case "request":
+      return { type: "request", requestId: execution.executor.requestId };
+    case "primitive":
+      return {
+        type: "primitive",
+        kind: execution.executor.kind,
+        runId: execution.executor.runId
+      };
+    case "agent":
+      return { type: "agent", runId: execution.executor.runId };
+    case "kernel":
+      return { type: "kernel", operation: structuredClone(execution.executor.operation) };
+  }
+}
+function assertExecutionRecordMatches(existing, input) {
+  const { createdAt: _createdAt, ...stored } = existing;
+  if (!isDeepStrictEqual(stored, input)) {
+    throw new ExecutionStorageError("duplicate_execution", `[Sixb] Execution '${input.id}' already exists with different immutable provenance.`);
+  }
+}
+function assertPrimitiveExecution(execution, primitive) {
+  const authority = execution.authorizationRef;
+  if (execution.executor.type !== "primitive" || execution.executor.kind !== primitive.kind || execution.executor.runId !== primitive.runId || authority.type !== "trustedPrimitive" || authority.primitive.kind !== primitive.kind || authority.primitive.id !== primitive.id || authority.primitive.runId !== primitive.runId) {
+    throw new ExecutionStorageError("invalid_input", `[Sixb] Execution '${execution.id}' does not authorize ${primitive.kind} run '${primitive.runId}'.`);
+  }
+}
+
+export { executionRecordInputFromRuntime, ensureExecutionRecord, createPrimitiveExecutionRecord, restoreTrustedPrimitiveExecutionScope };
+
+//# debugId=FD635CE58B49306C64756E2164756E21

package/dist/chunk-4aw0jwk0.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/execution/durable.ts"],
+  "sourcesContent": [
+    "import { isDeepStrictEqual } from \"node:util\"\nimport {\n  type CreateExecutionInput,\n  type ExecutionRecord,\n  type ExecutionStorage,\n  ExecutionStorageError,\n} from \"../storage/executions\"\nimport { createTrustedPrimitiveRuntimeAuthorization, getAuthorizationRef } from \"./authorization\"\nimport type {\n  ExecutionContext,\n  ExecutionScope,\n  RuntimeAuthorization,\n  TrustedPrimitiveRef,\n} from \"./types\"\n\n/** Convert one currently bound execution to the immutable provider representation. */\nexport function executionRecordInputFromRuntime(input: {\n  readonly execution: ExecutionContext\n  readonly runtimeAuthorization: RuntimeAuthorization\n}): CreateExecutionInput {\n  const execution = input.execution\n  return {\n    id: execution.id,\n    projectId: execution.projectId,\n    ...(execution.requestedBy === undefined\n      ? {}\n      : { requestedBy: structuredClone(execution.requestedBy) }),\n    executor: durableExecutor(execution),\n    source: structuredClone(execution.source),\n    correlationId: execution.correlationId,\n    authorizationRef: getAuthorizationRef(input.runtimeAuthorization),\n  }\n}\n\n/**\n * Store a caller execution once. Repeated boundaries may observe the same immutable execution;\n * only an exact match is idempotent.\n */\nexport async function ensureExecutionRecord(\n  storage: ExecutionStorage,\n  input: CreateExecutionInput\n): Promise<ExecutionRecord> {\n  const existing = await storage.getById({ projectId: input.projectId, id: input.id })\n  if (existing) {\n    assertExecutionRecordMatches(existing, input)\n    return existing\n  }\n\n  try {\n    return await storage.create(input)\n  } catch (error) {\n    if (!(error instanceof ExecutionStorageError) || error.code !== \"duplicate_execution\") {\n      throw error\n    }\n\n    const raced = await storage.getById({ projectId: input.projectId, id: input.id })\n    if (!raced) throw error\n    assertExecutionRecordMatches(raced, input)\n    return raced\n  }\n}\n\ntype PrimitiveExecutionOrigin =\n  | {\n      readonly type: \"execution\"\n      readonly parent: ExecutionRecord\n    }\n  | {\n      readonly type: \"automatic\"\n      readonly projectId: string\n      readonly source: Extract<\n        CreateExecutionInput[\"source\"],\n        { readonly type: \"schedule\" | \"event\" | \"datasetVersion\" | \"webhook\" }\n      >\n      readonly correlationId: string\n      readonly requestedBy?: CreateExecutionInput[\"requestedBy\"]\n    }\n\n/** Build an immutable primitive execution from its parent execution or automatic trigger. */\nexport function createPrimitiveExecutionRecord(input: {\n  readonly id: string\n  readonly primitive: TrustedPrimitiveRef\n  readonly origin: PrimitiveExecutionOrigin\n}): CreateExecutionInput {\n  const provenance =\n    input.origin.type === \"execution\"\n      ? {\n          projectId: input.origin.parent.projectId,\n          ...(input.origin.parent.requestedBy === undefined\n            ? {}\n            : { requestedBy: structuredClone(input.origin.parent.requestedBy) }),\n          source: { type: \"execution\" as const, executionId: input.origin.parent.id },\n          correlationId: input.origin.parent.correlationId,\n        }\n      : {\n          projectId: input.origin.projectId,\n          ...(input.origin.requestedBy === undefined\n            ? {}\n            : { requestedBy: structuredClone(input.origin.requestedBy) }),\n          source: structuredClone(input.origin.source),\n          correlationId: input.origin.correlationId,\n        }\n\n  return {\n    id: input.id,\n    ...provenance,\n    executor: {\n      type: \"primitive\",\n      kind: input.primitive.kind,\n      runId: input.primitive.runId,\n    },\n    authorizationRef: {\n      type: \"trustedPrimitive\",\n      primitive: structuredClone(input.primitive),\n    },\n  }\n}\n\n/** Restore the trusted scope of a provider-validated primitive execution record. */\nexport function restoreTrustedPrimitiveExecutionScope(input: {\n  readonly execution: ExecutionRecord\n  readonly primitive: TrustedPrimitiveRef\n}): ExecutionScope {\n  assertPrimitiveExecution(input.execution, input.primitive)\n  const context: ExecutionContext = Object.freeze({\n    id: input.execution.id,\n    projectId: input.execution.projectId,\n    ...(input.execution.requestedBy === undefined\n      ? {}\n      : { requestedBy: Object.freeze(structuredClone(input.execution.requestedBy)) }),\n    executor: Object.freeze({ type: \"primitive\", ...structuredClone(input.primitive) }),\n    source: Object.freeze(structuredClone(input.execution.source)),\n    correlationId: input.execution.correlationId,\n  })\n  return Object.freeze({\n    execution: context,\n    authorization: createTrustedPrimitiveRuntimeAuthorization({\n      projectId: input.execution.projectId,\n      primitive: input.primitive,\n    }),\n  })\n}\n\nfunction durableExecutor(execution: ExecutionContext): CreateExecutionInput[\"executor\"] {\n  switch (execution.executor.type) {\n    case \"request\":\n      return { type: \"request\", requestId: execution.executor.requestId }\n    case \"primitive\":\n      return {\n        type: \"primitive\",\n        kind: execution.executor.kind,\n        runId: execution.executor.runId,\n      }\n    case \"agent\":\n      return { type: \"agent\", runId: execution.executor.runId }\n    case \"kernel\":\n      return { type: \"kernel\", operation: structuredClone(execution.executor.operation) }\n  }\n}\n\nfunction assertExecutionRecordMatches(\n  existing: ExecutionRecord,\n  input: CreateExecutionInput\n): void {\n  const { createdAt: _createdAt, ...stored } = existing\n  if (!isDeepStrictEqual(stored, input)) {\n    throw new ExecutionStorageError(\n      \"duplicate_execution\",\n      `[Sixb] Execution '${input.id}' already exists with different immutable provenance.`\n    )\n  }\n}\n\nfunction assertPrimitiveExecution(\n  execution: ExecutionRecord,\n  primitive: TrustedPrimitiveRef\n): void {\n  const authority = execution.authorizationRef\n  if (\n    execution.executor.type !== \"primitive\" ||\n    execution.executor.kind !== primitive.kind ||\n    execution.executor.runId !== primitive.runId ||\n    authority.type !== \"trustedPrimitive\" ||\n    authority.primitive.kind !== primitive.kind ||\n    authority.primitive.id !== primitive.id ||\n    authority.primitive.runId !== primitive.runId\n  ) {\n    throw new ExecutionStorageError(\n      \"invalid_input\",\n      `[Sixb] Execution '${execution.id}' does not authorize ${primitive.kind} run '${primitive.runId}'.`\n    )\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "FD635CE58B49306C64756E2164756E21",
+  "names": []
+}

package/dist/{chunk-md9jbrm9.js → chunk-4gz41why.js}

@@ -2,7 +2,7 @@
 import {
   isRecord,
   validateSchemaValue
-} from "./chunk-53s4asfm.js";
+} from "./chunk-rnshztfq.js";
 import {
   OntologyValidationError
 } from "./chunk-dktq02ne.js";

package/dist/chunk-4p9rh7jj.js

@@ -0,0 +1,164 @@
+// @bun
+import {
+  isScheduleDefinition,
+  isScheduleReference
+} from "./chunk-5sz8ta9r.js";
+import {
+  isDatasetDefinition
+} from "./chunk-a31h57d5.js";
+import {
+  PipelineError
+} from "./chunk-261ag4t4.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-4p9rh7jj.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": []
+}