@vercel/factory 0.0.0

package/dist/index.js

@@ -0,0 +1,743 @@
+import {
+  SCHEMA_VERSION,
+  changeEvidenceSchema,
+  changeIdSchema,
+  changeSchema,
+  changeStateSchema,
+  factoryIdSchema,
+  harnessSchema,
+  isoDateTimeSchema,
+  levelSchema,
+  receiptIdSchema,
+  replyToSchema,
+  repositoryIdSchema,
+  repositoryIdsSchema,
+  schemaVersionSchema,
+  signalIdSchema,
+  standardTaskKinds,
+  taskDevboxSchema,
+  taskIdSchema,
+  taskKindSchema,
+  taskOriginSchema,
+  taskQuestionSchema,
+  taskSchema,
+  taskStateSchema,
+  usdSchema,
+  vocabularySchema
+} from "./chunk-BSDWPFKE.js";
+import {
+  RecordExistsError,
+  RecordNotFoundError,
+  VersionConflictError
+} from "./chunk-CEF6VJZC.js";
+
+// src/dispatch.ts
+var DispatchRefusedError = class extends Error {
+  taskId;
+  reason;
+  constructor(taskId, reason) {
+    super(`dispatch of "${taskId}" refused: ${reason}`);
+    this.name = "DispatchRefusedError";
+    this.taskId = taskId;
+    this.reason = reason;
+  }
+};
+async function dispatchTask(stores, taskId, options) {
+  const task = await stores.tasks.get(taskId);
+  if (task === null) {
+    throw new RecordNotFoundError("tasks", taskId);
+  }
+  if (task.kind === "question") {
+    throw new DispatchRefusedError(taskId, "question tasks are answered, not dispatched");
+  }
+  for (const dependencyId of task.dependsOn ?? []) {
+    const dependency = await stores.tasks.get(dependencyId);
+    if (dependency === null) {
+      throw new DispatchRefusedError(taskId, `dependency "${dependencyId}" does not exist`);
+    }
+    if (dependency.changeId === void 0) {
+      throw new DispatchRefusedError(
+        taskId,
+        `dependency "${dependencyId}" has not produced a change`
+      );
+    }
+  }
+  const running = await stores.tasks.transition(taskId, "running");
+  try {
+    await options.launch(running);
+  } catch (error) {
+    const reason = (error instanceof Error ? error.message : String(error)).slice(0, 500);
+    await stores.tasks.transition(taskId, "failed", { reason: `launch failed: ${reason}` }).catch(() => void 0);
+    throw error;
+  }
+  return running;
+}
+
+// src/schema/budget.ts
+import { z as z2 } from "zod";
+
+// src/schema/repository.ts
+import { z } from "zod";
+var repositorySlugSchema = z.string().regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?\/[a-z0-9._-]+$/).describe("owner/name, lowercase, e.g. acme/web.");
+var repositorySchema = z.strictObject({
+  schemaVersion: schemaVersionSchema,
+  id: repositoryIdSchema,
+  slug: repositorySlugSchema,
+  defaultBranch: z.string().min(1).describe("Branch changes land on, usually main."),
+  enabled: z.boolean().describe("Whether the factory may work on this repository."),
+  dependsOn: z.array(repositorySlugSchema).describe("Slugs of repositories this one consumes, for multi-repo work ordering."),
+  devbox: z.strictObject({
+    projectId: z.string().min(1),
+    teamId: z.string().min(1),
+    snapshot: z.string().min(1).optional().describe("Prebuilt snapshot to boot from.")
+  }).optional().describe("Devbox execution config. Absent when this repository never uses devboxes."),
+  connectedAt: isoDateTimeSchema
+});
+
+// src/schema/budget.ts
+var budgetMonthSchema = z2.string().regex(/^\d{4}-(0[1-9]|1[0-2])$/);
+var budgetSchema = z2.strictObject({
+  schemaVersion: schemaVersionSchema,
+  factoryId: factoryIdSchema,
+  month: budgetMonthSchema,
+  limits: z2.strictObject({
+    totalUsd: usdSchema,
+    investigationUsd: usdSchema,
+    perTaskReservationUsd: usdSchema,
+    warningPercent: z2.number().int().min(1).max(100),
+    perRepositoryUsd: z2.record(repositorySlugSchema, usdSchema).optional()
+  }),
+  notices: z2.strictObject({
+    warningAt: isoDateTimeSchema.optional(),
+    exhaustedAt: isoDateTimeSchema.optional()
+  })
+});
+
+// src/schema/receipt.ts
+import { z as z3 } from "zod";
+var standardReceiptStates = [
+  "dispatched",
+  "succeeded",
+  "failed",
+  "needs_human",
+  "cancelled",
+  "settled",
+  "merged",
+  "deployed",
+  "rolled_out",
+  "rolled_back"
+];
+var standardReceiptPhases = [
+  "budget",
+  "dispatch",
+  "implementation",
+  "verification",
+  "pull_request",
+  "cleanup"
+];
+var standardReceiptKinds = [...standardTaskKinds, "change"];
+var receiptStateSchema = vocabularySchema.describe(
+  "What happened, e.g. dispatched, settled, merged, or a custom event name."
+);
+var receiptPhaseSchema = vocabularySchema.describe(
+  "Where in the process it happened, e.g. dispatch or verification."
+);
+var receiptKindSchema = vocabularySchema.describe(
+  "What the receipt is about: a task kind, change, or a custom kind."
+);
+var costSchema = z3.strictObject({
+  totalUsd: usdSchema
+});
+var receiptSchema = z3.strictObject({
+  schemaVersion: schemaVersionSchema,
+  receiptId: receiptIdSchema,
+  repositoryIds: repositoryIdsSchema.describe("Repositories the recorded event concerns."),
+  taskId: taskIdSchema.optional(),
+  changeId: changeIdSchema.optional(),
+  kind: receiptKindSchema,
+  state: receiptStateSchema,
+  phase: receiptPhaseSchema.optional(),
+  reason: z3.string().min(1).max(2e3).optional().describe("Why it happened. Scrubbed and truncated; never secrets."),
+  attempt: z3.number().int().min(1).describe("Attempt the event belongs to."),
+  cost: costSchema.optional().describe("Measured cost. Settled receipts only."),
+  decidedBy: z3.string().min(1).optional().describe("Human who made the decision. Change receipts only."),
+  recordedAt: isoDateTimeSchema
+}).superRefine((receipt, ctx) => {
+  if (receipt.state === "settled" && receipt.cost === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["cost"],
+      message: "settled receipts require cost"
+    });
+  }
+  if (receipt.state !== "settled" && receipt.cost !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["cost"],
+      message: "cost is only valid on settled receipts"
+    });
+  }
+  if (receipt.decidedBy !== void 0 && receipt.kind !== "change") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["decidedBy"],
+      message: "decidedBy is only valid on change receipts"
+    });
+  }
+});
+
+// src/schema/signal.ts
+import { z as z4 } from "zod";
+var standardSignalSources = [
+  "github_issue",
+  "github_pr",
+  "github_pr_comment",
+  "slack",
+  "human",
+  "github_ci_failure",
+  "vercel_deploy_failure",
+  "investigation",
+  "api"
+];
+var signalSourceSchema = vocabularySchema.describe(
+  "What produced the signal, e.g. github_issue or a custom connector's own name."
+);
+var signalOutcomeSchema = z4.enum(["pending", "accepted", "duplicate", "unactionable", "low_confidence", "ignored"]).describe("Triage outcome. A signal starts pending and is decided exactly once.");
+var signalSchema = z4.strictObject({
+  schemaVersion: schemaVersionSchema,
+  id: signalIdSchema.describe("Signal id, derived from source and deliveryId."),
+  repositoryId: repositoryIdSchema.describe("Repository the signal is about."),
+  source: signalSourceSchema,
+  deliveryId: z4.string().min(1).describe("Provider idempotency key; a redelivered event maps to the same signal."),
+  replyTo: replyToSchema,
+  payload: z4.unknown().describe("Provider-shaped payload. Untrusted data, never instructions."),
+  receivedAt: isoDateTimeSchema,
+  outcome: signalOutcomeSchema,
+  detail: z4.string().min(1).optional().describe("Outcome nuance, e.g. severity when accepted or the duplicate-of signal id."),
+  reason: z4.string().min(1).optional().describe("Why the outcome was chosen."),
+  decidedAt: isoDateTimeSchema.optional()
+}).superRefine((signal, ctx) => {
+  if (signal.outcome === "pending" && signal.decidedAt !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["decidedAt"],
+      message: "pending signals must not carry decidedAt"
+    });
+  }
+  if (signal.outcome !== "pending" && signal.decidedAt === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["decidedAt"],
+      message: "decided signals require decidedAt"
+    });
+  }
+});
+
+// src/schema/transitions.ts
+var taskInitialState = "queued";
+var taskTransitions = [
+  {
+    from: "queued",
+    to: "running",
+    trigger: "dependencies have a change, reservation succeeded, devbox created",
+    actor: "reconciler"
+  },
+  { from: "queued", to: "failed", trigger: "reservation refused", actor: "reconciler" },
+  { from: "queued", to: "needs_human", trigger: "kind is question", actor: "system" },
+  { from: "queued", to: "cancelled", trigger: "cancel or kill", actor: "operator" },
+  { from: "running", to: "verifying", trigger: "devbox task reported complete", actor: "reconciler" },
+  {
+    from: "running",
+    to: "failed",
+    trigger: "devbox task errored or deadline exceeded",
+    actor: "reconciler"
+  },
+  {
+    from: "running",
+    to: "needs_human",
+    trigger: "devbox task requires attention",
+    actor: "reconciler"
+  },
+  { from: "running", to: "cancelled", trigger: "cancel or kill", actor: "operator" },
+  { from: "verifying", to: "succeeded", trigger: "kind criterion true", actor: "reconciler" },
+  {
+    from: "verifying",
+    to: "running",
+    trigger: "verification failed below attempt limit",
+    actor: "reconciler"
+  },
+  {
+    from: "verifying",
+    to: "failed",
+    trigger: "verification failed at attempt limit",
+    actor: "reconciler"
+  },
+  { from: "verifying", to: "cancelled", trigger: "cancel or kill", actor: "operator" },
+  { from: "needs_human", to: "succeeded", trigger: "question answered", actor: "operator" },
+  { from: "needs_human", to: "queued", trigger: "operator retry", actor: "operator" },
+  { from: "needs_human", to: "cancelled", trigger: "cancel or kill", actor: "operator" },
+  { from: "failed", to: "queued", trigger: "operator retry", actor: "operator" }
+];
+var changeInitialState = "verifying";
+var changeTransitions = [
+  {
+    from: "verifying",
+    to: "ready",
+    trigger: "verification task succeeded, risk and confidence written",
+    actor: "reconciler"
+  },
+  {
+    from: "verifying",
+    to: "closed",
+    trigger: "verification failed at attempt limit or pr closed upstream",
+    actor: "reconciler"
+  },
+  { from: "ready", to: "merged", trigger: "pr merged on github", actor: "webhook" },
+  { from: "ready", to: "closed", trigger: "pr closed without merge", actor: "webhook" },
+  {
+    from: "merged",
+    to: "deployed",
+    trigger: "production deployment ready containing the merge sha",
+    actor: "webhook"
+  },
+  {
+    from: "deployed",
+    to: "rolled_out",
+    trigger: "no flag, or flag ramped to full and held",
+    actor: "foreman"
+  },
+  { from: "deployed", to: "rolled_back", trigger: "rollback rule crossed", actor: "foreman" },
+  {
+    from: "rolled_out",
+    to: "rolled_back",
+    trigger: "rollback rule crossed or flag flipped off",
+    actor: "foreman"
+  },
+  { from: "rolled_back", to: "deployed", trigger: "human retried the ramp", actor: "human" }
+];
+var signalInitialOutcome = "pending";
+var signalOutcomeTransitions = [
+  { from: "pending", to: "accepted", trigger: "classified as actionable", actor: "reconciler" },
+  { from: "pending", to: "duplicate", trigger: "classified as duplicate", actor: "reconciler" },
+  {
+    from: "pending",
+    to: "unactionable",
+    trigger: "classified as unactionable",
+    actor: "reconciler"
+  },
+  {
+    from: "pending",
+    to: "low_confidence",
+    trigger: "classified below confidence threshold",
+    actor: "reconciler"
+  },
+  { from: "pending", to: "ignored", trigger: "classified as ignorable", actor: "reconciler" }
+];
+function isTransitionAllowed(transitions, from, to) {
+  return transitions.some((transition) => transition.from === from && transition.to === to);
+}
+function legalNextStates(transitions, from) {
+  return [
+    ...new Set(
+      transitions.filter((transition) => transition.from === from).map((t) => t.to)
+    )
+  ];
+}
+var InvalidTransitionError = class extends Error {
+  from;
+  to;
+  legalNextStates;
+  constructor(from, to, legal) {
+    super(
+      legal.length > 0 ? `invalid transition from "${from}" to "${to}"; legal next states: ${legal.map((state) => `"${state}"`).join(", ")}` : `invalid transition from "${from}" to "${to}"; "${from}" is terminal`
+    );
+    this.name = "InvalidTransitionError";
+    this.from = from;
+    this.to = to;
+    this.legalNextStates = legal;
+  }
+};
+function assertTransition(transitions, from, to) {
+  if (!isTransitionAllowed(transitions, from, to)) {
+    throw new InvalidTransitionError(from, to, legalNextStates(transitions, from));
+  }
+}
+function terminalStates(transitions) {
+  const states = /* @__PURE__ */ new Set();
+  for (const transition of transitions) {
+    states.add(transition.from);
+    states.add(transition.to);
+  }
+  return [...states].filter(
+    (state) => !transitions.some((transition) => transition.from === state)
+  );
+}
+
+// src/store/engine.ts
+import { createHash, randomUUID } from "crypto";
+var taskReceiptStates = {
+  running: "dispatched",
+  succeeded: "succeeded",
+  failed: "failed",
+  needs_human: "needs_human",
+  cancelled: "cancelled"
+};
+var changeReceiptStates = {
+  merged: "merged",
+  deployed: "deployed",
+  rolled_out: "rolled_out",
+  rolled_back: "rolled_back"
+};
+function randomId(prefix) {
+  return `${prefix}_${randomUUID().replaceAll("-", "")}`;
+}
+function derivedId(prefix, key) {
+  return `${prefix}_${createHash("sha256").update(key).digest("hex").slice(0, 32)}`;
+}
+function bumpsAttempt(from, to) {
+  return to === "queued" || from === "verifying" && to === "running";
+}
+function createStores(options) {
+  const { driver } = options;
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  async function read(collection, id, schema) {
+    const record = await driver.get(collection, id);
+    if (record === null) {
+      return null;
+    }
+    return { value: schema.parse(record.value), version: record.version };
+  }
+  async function mustRead(collection, id, schema) {
+    const record = await read(collection, id, schema);
+    if (record === null) {
+      throw new RecordNotFoundError(collection, id);
+    }
+    return record;
+  }
+  async function listAll(collection, schema) {
+    const entries = await driver.list(collection);
+    return entries.map((entry) => schema.parse(entry.record.value));
+  }
+  async function insertReceipt(receiptId, receipt) {
+    const full = receiptSchema.parse({
+      ...receipt,
+      schemaVersion: SCHEMA_VERSION,
+      receiptId,
+      recordedAt: now()
+    });
+    try {
+      await driver.insert("receipts", receiptId, full);
+      return full;
+    } catch (error) {
+      if (error instanceof RecordExistsError) {
+        const existing = await mustRead("receipts", receiptId, receiptSchema);
+        return existing.value;
+      }
+      throw error;
+    }
+  }
+  async function appendReceipt(key, receipt) {
+    await insertReceipt(derivedId("rcpt", key), receipt);
+  }
+  return {
+    driverName: driver.name,
+    repositories: {
+      async put(repository) {
+        const parsed = repositorySchema.parse(repository);
+        const existing = await read("repositories", parsed.id, repositorySchema);
+        if (existing === null) {
+          await driver.insert("repositories", parsed.id, parsed);
+        } else {
+          await driver.update("repositories", parsed.id, parsed, existing.version);
+        }
+        return parsed;
+      },
+      async get(id) {
+        const record = await read("repositories", id, repositorySchema);
+        return record === null ? null : record.value;
+      },
+      list() {
+        return listAll("repositories", repositorySchema);
+      }
+    },
+    signals: {
+      async create(input) {
+        const id = derivedId("sig", `${input.source}:${input.deliveryId}`);
+        const signal = signalSchema.parse({
+          schemaVersion: SCHEMA_VERSION,
+          id,
+          repositoryId: input.repositoryId,
+          source: input.source,
+          deliveryId: input.deliveryId,
+          replyTo: input.replyTo,
+          payload: input.payload,
+          receivedAt: now(),
+          outcome: "pending"
+        });
+        try {
+          await driver.insert("signals", id, signal);
+          return signal;
+        } catch (error) {
+          if (error instanceof RecordExistsError) {
+            const existing = await mustRead("signals", id, signalSchema);
+            return existing.value;
+          }
+          throw error;
+        }
+      },
+      async get(id) {
+        const record = await read("signals", id, signalSchema);
+        return record === null ? null : record.value;
+      },
+      async decide(id, outcome, decideOptions = {}) {
+        const existing = await mustRead("signals", id, signalSchema);
+        assertTransition(signalOutcomeTransitions, existing.value.outcome, outcome);
+        const next = signalSchema.parse({
+          ...existing.value,
+          outcome,
+          detail: decideOptions.detail,
+          reason: decideOptions.reason,
+          decidedAt: now()
+        });
+        await driver.update("signals", id, next, existing.version);
+        return next;
+      },
+      list() {
+        return listAll("signals", signalSchema);
+      }
+    },
+    tasks: {
+      async create(input) {
+        const timestamp = now();
+        const task = taskSchema.parse({
+          schemaVersion: SCHEMA_VERSION,
+          id: randomId("task"),
+          repositoryIds: input.repositoryIds,
+          kind: input.kind,
+          area: input.area,
+          state: taskInitialState,
+          origin: input.origin,
+          dependsOn: input.dependsOn,
+          replyTo: input.replyTo,
+          attempt: 1,
+          question: input.question,
+          createdAt: timestamp,
+          updatedAt: timestamp
+        });
+        await driver.insert("tasks", task.id, task);
+        return task;
+      },
+      async get(id) {
+        const record = await read("tasks", id, taskSchema);
+        return record === null ? null : record.value;
+      },
+      async transition(id, to, transitionOptions = {}) {
+        const existing = await mustRead("tasks", id, taskSchema);
+        assertTransition(taskTransitions, existing.value.state, to);
+        const attempt = bumpsAttempt(existing.value.state, to) ? existing.value.attempt + 1 : existing.value.attempt;
+        const next = taskSchema.parse({
+          ...existing.value,
+          ...transitionOptions.patch,
+          state: to,
+          attempt,
+          updatedAt: now()
+        });
+        const receiptState = taskReceiptStates[to];
+        if (receiptState !== void 0 && next.repositoryIds !== void 0) {
+          await appendReceipt(`task:${id}:${receiptState}:${attempt}`, {
+            repositoryIds: next.repositoryIds,
+            taskId: id,
+            changeId: next.changeId,
+            kind: next.kind,
+            state: receiptState,
+            reason: transitionOptions.reason,
+            attempt
+          });
+        }
+        await driver.update("tasks", id, next, existing.version);
+        return next;
+      },
+      list() {
+        return listAll("tasks", taskSchema);
+      }
+    },
+    changes: {
+      async create(input) {
+        const timestamp = now();
+        const change = changeSchema.parse({
+          schemaVersion: SCHEMA_VERSION,
+          id: randomId("chg"),
+          repositoryId: input.repositoryId,
+          taskId: input.taskId,
+          groupId: input.groupId,
+          prNumber: input.prNumber,
+          prUrl: input.prUrl,
+          author: input.author,
+          risk: input.risk,
+          confidence: input.confidence,
+          evidence: input.evidence,
+          state: changeInitialState,
+          createdAt: timestamp,
+          updatedAt: timestamp
+        });
+        await driver.insert("changes", change.id, change);
+        return change;
+      },
+      async get(id) {
+        const record = await read("changes", id, changeSchema);
+        return record === null ? null : record.value;
+      },
+      async transition(id, to, transitionOptions = {}) {
+        const existing = await mustRead("changes", id, changeSchema);
+        assertTransition(changeTransitions, existing.value.state, to);
+        const next = changeSchema.parse({
+          ...existing.value,
+          ...transitionOptions.patch,
+          state: to,
+          updatedAt: now()
+        });
+        const receiptState = changeReceiptStates[to];
+        if (receiptState !== void 0) {
+          await appendReceipt(`change:${id}:${receiptState}`, {
+            repositoryIds: [next.repositoryId],
+            taskId: next.taskId,
+            changeId: id,
+            kind: "change",
+            state: receiptState,
+            reason: transitionOptions.reason,
+            attempt: 1,
+            decidedBy: next.decidedBy
+          });
+        }
+        await driver.update("changes", id, next, existing.version);
+        return next;
+      },
+      list() {
+        return listAll("changes", changeSchema);
+      }
+    },
+    receipts: {
+      append(input) {
+        const { dedupeKey, attempt, ...fields } = input;
+        const receiptId = dedupeKey === void 0 ? randomId("rcpt") : derivedId("rcpt", `custom:${dedupeKey}`);
+        return insertReceipt(receiptId, { ...fields, attempt: attempt ?? 1 });
+      },
+      async get(id) {
+        const record = await read("receipts", id, receiptSchema);
+        return record === null ? null : record.value;
+      },
+      list() {
+        return listAll("receipts", receiptSchema);
+      }
+    }
+  };
+}
+
+// src/store/memory.ts
+function createInMemoryDriver() {
+  const collections = /* @__PURE__ */ new Map();
+  function collection(name) {
+    let existing = collections.get(name);
+    if (existing === void 0) {
+      existing = /* @__PURE__ */ new Map();
+      collections.set(name, existing);
+    }
+    return existing;
+  }
+  return {
+    name: "memory",
+    get(name, id) {
+      const record = collection(name).get(id);
+      return Promise.resolve(record === void 0 ? null : structuredClone(record));
+    },
+    insert(name, id, value) {
+      const records = collection(name);
+      if (records.has(id)) {
+        return Promise.reject(new RecordExistsError(name, id));
+      }
+      records.set(id, { value: structuredClone(value), version: 1 });
+      return Promise.resolve();
+    },
+    update(name, id, value, expectedVersion) {
+      const records = collection(name);
+      const existing = records.get(id);
+      if (existing === void 0) {
+        return Promise.reject(new RecordNotFoundError(name, id));
+      }
+      if (existing.version !== expectedVersion) {
+        return Promise.reject(new VersionConflictError(name, id, expectedVersion));
+      }
+      records.set(id, { value: structuredClone(value), version: existing.version + 1 });
+      return Promise.resolve();
+    },
+    list(name) {
+      const entries = [...collection(name)].map(([id, record]) => ({
+        id,
+        record: structuredClone(record)
+      }));
+      return Promise.resolve(entries);
+    }
+  };
+}
+export {
+  DispatchRefusedError,
+  InvalidTransitionError,
+  RecordExistsError,
+  RecordNotFoundError,
+  SCHEMA_VERSION,
+  VersionConflictError,
+  assertTransition,
+  budgetMonthSchema,
+  budgetSchema,
+  changeEvidenceSchema,
+  changeIdSchema,
+  changeInitialState,
+  changeSchema,
+  changeStateSchema,
+  changeTransitions,
+  costSchema,
+  createInMemoryDriver,
+  createStores,
+  dispatchTask,
+  factoryIdSchema,
+  harnessSchema,
+  isTransitionAllowed,
+  isoDateTimeSchema,
+  legalNextStates,
+  levelSchema,
+  receiptIdSchema,
+  receiptKindSchema,
+  receiptPhaseSchema,
+  receiptSchema,
+  receiptStateSchema,
+  replyToSchema,
+  repositoryIdSchema,
+  repositoryIdsSchema,
+  repositorySchema,
+  repositorySlugSchema,
+  schemaVersionSchema,
+  signalIdSchema,
+  signalInitialOutcome,
+  signalOutcomeSchema,
+  signalOutcomeTransitions,
+  signalSchema,
+  signalSourceSchema,
+  standardReceiptKinds,
+  standardReceiptPhases,
+  standardReceiptStates,
+  standardSignalSources,
+  standardTaskKinds,
+  taskDevboxSchema,
+  taskIdSchema,
+  taskInitialState,
+  taskKindSchema,
+  taskOriginSchema,
+  taskQuestionSchema,
+  taskSchema,
+  taskStateSchema,
+  taskTransitions,
+  terminalStates,
+  usdSchema,
+  vocabularySchema
+};
+//# sourceMappingURL=index.js.map