@tangle-network/agent-app 0.30.0 → 0.31.0

package/dist/intakes/api.d.ts

@@ -0,0 +1,59 @@
+import { I as IntakeAnswerValue, a as IntakeQuestion, b as IntakeGraph } from '../model-Cuj7d-xT.js';
+import { IntakeStore } from './drizzle.js';
+import 'drizzle-orm/sqlite-core';
+import './index.js';
+
+/**
+ * Framework-neutral intake API: the get-current / save-answer / complete logic,
+ * lifted out of any one app's route file. Each app mounts these in its own
+ * route with its own auth — the handlers take an already-resolved store (the
+ * caller built it from `createUserIntakeStore` / `createProjectIntakeStore`
+ * after running RBAC), the intake graph, and the parsed inputs. They return
+ * web-standard `Response`s (available in Workers, Node 18+, Deno, browsers), so
+ * "framework-neutral" is literal: no Remix/React-Router/Express import anywhere.
+ *
+ * The handlers own the graph→HTTP mapping the UI needs: `getCurrentIntake`
+ * returns the loaded state PLUS the next question to ask (the question-graph
+ * traversal from the `./intakes` leaf) and the progress counter, so the client
+ * renders one question at a time without re-deriving the graph. Store
+ * `IntakeError`s map to typed 4xx codes, never a generic 500 — an invalid
+ * answer is a 400, an incomplete-complete is a 409, never a silent success.
+ *
+ * Imports `drizzle-orm` transitively (through the store types), so this is a
+ * subpath, never re-exported from root.
+ */
+
+/** What the client renders: the saved state, the next prompt, and progress. */
+interface CurrentIntakeView {
+    graphId: string;
+    title: string;
+    description?: string;
+    answers: Record<string, IntakeAnswerValue>;
+    /** The next question to ask, or null when the interview is done. */
+    nextQuestion: IntakeQuestion | null;
+    completed: boolean;
+    completedAt: string | null;
+    progress: {
+        answered: number;
+        total: number;
+    };
+}
+interface IntakeApiOptions {
+    store: IntakeStore;
+    graph: IntakeGraph;
+}
+/**
+ * Build the intake API bound to one store + graph. Returns three handlers; an
+ * app maps its route methods onto them (GET→getCurrentIntake, POST→saveAnswer,
+ * a complete action→completeIntake).
+ */
+declare function createIntakeApi(opts: IntakeApiOptions): {
+    getCurrentIntake: () => Promise<Response>;
+    saveAnswer: (input: {
+        questionId?: string;
+        value?: IntakeAnswerValue;
+    }) => Promise<Response>;
+    completeIntake: () => Promise<Response>;
+};
+
+export { type CurrentIntakeView, type IntakeApiOptions, createIntakeApi };

package/dist/intakes/api.js

@@ -0,0 +1,63 @@
+import {
+  IntakeError
+} from "../chunk-4K7BZYO7.js";
+import "../chunk-USYXHDKE.js";
+import {
+  intakeProgress,
+  nextQuestion
+} from "../chunk-ND3XEGBE.js";
+
+// src/intakes/api.ts
+function createIntakeApi(opts) {
+  const { store, graph } = opts;
+  function view(state) {
+    return {
+      graphId: graph.id,
+      title: graph.title,
+      ...graph.description ? { description: graph.description } : {},
+      answers: state.payload.answers,
+      nextQuestion: nextQuestion(graph, state.payload.answers),
+      completed: state.completed,
+      completedAt: state.completedAt ? state.completedAt.toISOString() : null,
+      progress: intakeProgress(graph, state.payload.answers)
+    };
+  }
+  async function getCurrentIntake() {
+    const state = await store.get();
+    return Response.json(view(state));
+  }
+  async function saveAnswer(input) {
+    if (!input.questionId) return Response.json({ error: "Missing questionId" }, { status: 400 });
+    try {
+      const state = await store.save(input.questionId, input.value ?? null);
+      return Response.json(view(state));
+    } catch (err) {
+      return intakeErrorResponse(err);
+    }
+  }
+  async function completeIntake() {
+    try {
+      const state = await store.complete();
+      return Response.json(view(state));
+    } catch (err) {
+      return intakeErrorResponse(err);
+    }
+  }
+  return { getCurrentIntake, saveAnswer, completeIntake };
+}
+var ERROR_STATUS = {
+  "invalid-answer": 400,
+  "unknown-question": 404,
+  incomplete: 409,
+  "stale-graph": 409
+};
+function intakeErrorResponse(err) {
+  if (err instanceof IntakeError) {
+    return Response.json({ error: err.message, code: err.code }, { status: ERROR_STATUS[err.code] ?? 400 });
+  }
+  throw err;
+}
+export {
+  createIntakeApi
+};
+//# sourceMappingURL=api.js.map

package/dist/intakes/api.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/intakes/api.ts"],"sourcesContent":["/**\n * Framework-neutral intake API: the get-current / save-answer / complete logic,\n * lifted out of any one app's route file. Each app mounts these in its own\n * route with its own auth — the handlers take an already-resolved store (the\n * caller built it from `createUserIntakeStore` / `createProjectIntakeStore`\n * after running RBAC), the intake graph, and the parsed inputs. They return\n * web-standard `Response`s (available in Workers, Node 18+, Deno, browsers), so\n * \"framework-neutral\" is literal: no Remix/React-Router/Express import anywhere.\n *\n * The handlers own the graph→HTTP mapping the UI needs: `getCurrentIntake`\n * returns the loaded state PLUS the next question to ask (the question-graph\n * traversal from the `./intakes` leaf) and the progress counter, so the client\n * renders one question at a time without re-deriving the graph. Store\n * `IntakeError`s map to typed 4xx codes, never a generic 500 — an invalid\n * answer is a 400, an incomplete-complete is a 409, never a silent success.\n *\n * Imports `drizzle-orm` transitively (through the store types), so this is a\n * subpath, never re-exported from root.\n */\n\nimport {\n  type IntakeAnswerValue,\n  type IntakeGraph,\n  type IntakeQuestion,\n  intakeProgress,\n  nextQuestion,\n} from './model'\nimport { type IntakeStore, IntakeError } from './drizzle/store'\n\n/** What the client renders: the saved state, the next prompt, and progress. */\nexport interface CurrentIntakeView {\n  graphId: string\n  title: string\n  description?: string\n  answers: Record<string, IntakeAnswerValue>\n  /** The next question to ask, or null when the interview is done. */\n  nextQuestion: IntakeQuestion | null\n  completed: boolean\n  completedAt: string | null\n  progress: { answered: number; total: number }\n}\n\nexport interface IntakeApiOptions {\n  store: IntakeStore\n  graph: IntakeGraph\n}\n\n/**\n * Build the intake API bound to one store + graph. Returns three handlers; an\n * app maps its route methods onto them (GET→getCurrentIntake, POST→saveAnswer,\n * a complete action→completeIntake).\n */\nexport function createIntakeApi(opts: IntakeApiOptions) {\n  const { store, graph } = opts\n\n  function view(state: Awaited<ReturnType<IntakeStore['get']>>): CurrentIntakeView {\n    return {\n      graphId: graph.id,\n      title: graph.title,\n      ...(graph.description ? { description: graph.description } : {}),\n      answers: state.payload.answers,\n      nextQuestion: nextQuestion(graph, state.payload.answers),\n      completed: state.completed,\n      completedAt: state.completedAt ? state.completedAt.toISOString() : null,\n      progress: intakeProgress(graph, state.payload.answers),\n    }\n  }\n\n  async function getCurrentIntake(): Promise<Response> {\n    const state = await store.get()\n    return Response.json(view(state))\n  }\n\n  async function saveAnswer(input: { questionId?: string; value?: IntakeAnswerValue }): Promise<Response> {\n    if (!input.questionId) return Response.json({ error: 'Missing questionId' }, { status: 400 })\n    try {\n      const state = await store.save(input.questionId, input.value ?? null)\n      return Response.json(view(state))\n    } catch (err) {\n      return intakeErrorResponse(err)\n    }\n  }\n\n  async function completeIntake(): Promise<Response> {\n    try {\n      const state = await store.complete()\n      return Response.json(view(state))\n    } catch (err) {\n      return intakeErrorResponse(err)\n    }\n  }\n\n  return { getCurrentIntake, saveAnswer, completeIntake }\n}\n\nconst ERROR_STATUS: Record<string, number> = {\n  'invalid-answer': 400,\n  'unknown-question': 404,\n  incomplete: 409,\n  'stale-graph': 409,\n}\n\nfunction intakeErrorResponse(err: unknown): Response {\n  if (err instanceof IntakeError) {\n    return Response.json({ error: err.message, code: err.code }, { status: ERROR_STATUS[err.code] ?? 400 })\n  }\n  throw err\n}\n"],"mappings":";;;;;;;;;;AAoDO,SAAS,gBAAgB,MAAwB;AACtD,QAAM,EAAE,OAAO,MAAM,IAAI;AAEzB,WAAS,KAAK,OAAmE;AAC/E,WAAO;AAAA,MACL,SAAS,MAAM;AAAA,MACf,OAAO,MAAM;AAAA,MACb,GAAI,MAAM,cAAc,EAAE,aAAa,MAAM,YAAY,IAAI,CAAC;AAAA,MAC9D,SAAS,MAAM,QAAQ;AAAA,MACvB,cAAc,aAAa,OAAO,MAAM,QAAQ,OAAO;AAAA,MACvD,WAAW,MAAM;AAAA,MACjB,aAAa,MAAM,cAAc,MAAM,YAAY,YAAY,IAAI;AAAA,MACnE,UAAU,eAAe,OAAO,MAAM,QAAQ,OAAO;AAAA,IACvD;AAAA,EACF;AAEA,iBAAe,mBAAsC;AACnD,UAAM,QAAQ,MAAM,MAAM,IAAI;AAC9B,WAAO,SAAS,KAAK,KAAK,KAAK,CAAC;AAAA,EAClC;AAEA,iBAAe,WAAW,OAA8E;AACtG,QAAI,CAAC,MAAM,WAAY,QAAO,SAAS,KAAK,EAAE,OAAO,qBAAqB,GAAG,EAAE,QAAQ,IAAI,CAAC;AAC5F,QAAI;AACF,YAAM,QAAQ,MAAM,MAAM,KAAK,MAAM,YAAY,MAAM,SAAS,IAAI;AACpE,aAAO,SAAS,KAAK,KAAK,KAAK,CAAC;AAAA,IAClC,SAAS,KAAK;AACZ,aAAO,oBAAoB,GAAG;AAAA,IAChC;AAAA,EACF;AAEA,iBAAe,iBAAoC;AACjD,QAAI;AACF,YAAM,QAAQ,MAAM,MAAM,SAAS;AACnC,aAAO,SAAS,KAAK,KAAK,KAAK,CAAC;AAAA,IAClC,SAAS,KAAK;AACZ,aAAO,oBAAoB,GAAG;AAAA,IAChC;AAAA,EACF;AAEA,SAAO,EAAE,kBAAkB,YAAY,eAAe;AACxD;AAEA,IAAM,eAAuC;AAAA,EAC3C,kBAAkB;AAAA,EAClB,oBAAoB;AAAA,EACpB,YAAY;AAAA,EACZ,eAAe;AACjB;AAEA,SAAS,oBAAoB,KAAwB;AACnD,MAAI,eAAe,aAAa;AAC9B,WAAO,SAAS,KAAK,EAAE,OAAO,IAAI,SAAS,MAAM,IAAI,KAAK,GAAG,EAAE,QAAQ,aAAa,IAAI,IAAI,KAAK,IAAI,CAAC;AAAA,EACxG;AACA,QAAM;AACR;","names":[]}

package/dist/intakes/drizzle.d.ts

@@ -0,0 +1,385 @@
+import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
+import { AnySQLiteTable, AnySQLiteColumn, BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+import { I as IntakeAnswerValue, b as IntakeGraph } from '../model-Cuj7d-xT.js';
+import { IntakePayload } from './index.js';
+
+/** A product table referenced by FK — only the `id` column is touched. */
+type IntakeParentTable = AnySQLiteTable & {
+    id: AnySQLiteColumn;
+};
+interface CreateIntakeTablesOptions {
+    /** The product's user table — user-intake rows reference `userTable.id`. */
+    userTable: IntakeParentTable;
+    /**
+     * The product's workspace table — project-intake rows reference
+     * `workspaceTable.id`. OPTIONAL: omit it for a single-user / non-workspace
+     * app that wants per-user onboarding only. When omitted, no `projectIntake`
+     * table is created.
+     */
+    workspaceTable?: IntakeParentTable;
+}
+declare function createUserIntakeTable(userTable: IntakeParentTable): drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+    name: "user_intake";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "id";
+            tableName: "user_intake";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        userId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "user_id";
+            tableName: "user_intake";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        graphId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "graph_id";
+            tableName: "user_intake";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        payload: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "payload";
+            tableName: "user_intake";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: unknown;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        completedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "completed_at";
+            tableName: "user_intake";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "created_at";
+            tableName: "user_intake";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "updated_at";
+            tableName: "user_intake";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+declare function createProjectIntakeTable(workspaceTable: IntakeParentTable): drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+    name: "project_intake";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "id";
+            tableName: "project_intake";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        workspaceId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "workspace_id";
+            tableName: "project_intake";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        graphId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "graph_id";
+            tableName: "project_intake";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        payload: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "payload";
+            tableName: "project_intake";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: unknown;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        completedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "completed_at";
+            tableName: "project_intake";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "created_at";
+            tableName: "project_intake";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "updated_at";
+            tableName: "project_intake";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+/**
+ * Build the intake tables wired to the product's tables. Always returns
+ * `userIntake`; returns `projectIntake` only when `workspaceTable` is passed.
+ * The return type carries `projectIntake?` so a consumer that passes no
+ * workspace table cannot reference a table that does not exist.
+ */
+declare function createIntakeTables<O extends CreateIntakeTablesOptions>(opts: O): IntakeTables<O>;
+type UserIntakeTable = ReturnType<typeof createUserIntakeTable>;
+type ProjectIntakeTable = ReturnType<typeof createProjectIntakeTable>;
+/**
+ * The tables returned for a given options shape: `projectIntake` is present in
+ * the type exactly when `workspaceTable` was provided.
+ */
+type IntakeTables<O extends CreateIntakeTablesOptions> = O extends {
+    workspaceTable: IntakeParentTable;
+} ? {
+    userIntake: UserIntakeTable;
+    projectIntake: ProjectIntakeTable;
+} : {
+    userIntake: UserIntakeTable;
+    projectIntake?: ProjectIntakeTable;
+};
+/** The union table shape, for code that handles either scope generically. */
+type AnyIntakeTables = {
+    userIntake: UserIntakeTable;
+    projectIntake?: ProjectIntakeTable;
+};
+type UserIntakeRow = UserIntakeTable['$inferSelect'];
+type ProjectIntakeRow = ProjectIntakeTable['$inferSelect'];
+
+/**
+ * Drizzle-backed store over the tables from `createIntakeTables`. One store
+ * builder per scope: `createUserIntakeStore` (keyed on userId) and
+ * `createProjectIntakeStore` (keyed on workspaceId). Each returns the same
+ * three-method surface — `get` / `save` / `complete` — so the api handlers and
+ * the UI talk to one shape regardless of scope.
+ *
+ * Works against any SQLite drizzle driver (better-sqlite3, D1, libsql): the
+ * builders are awaited, never `.run()`/`.all()`, so sync and async drivers
+ * behave identically.
+ *
+ * Validation is fail-loud and pure (from the `./intakes` leaf). `save` runs
+ * `validateAnswer` before writing, so an invalid answer can never enter the
+ * payload; `complete` runs `payloadComplete` and refuses to stamp an
+ * incomplete (or stale-graph) intake — it throws a typed `IntakeError` rather
+ * than silently writing a half-finished onboarding state.
+ *
+ * `getProjectIntakeStore` pins `workspaceId` in every WHERE clause; RBAC runs
+ * in the route before the store is built, but the scope key is enforced here
+ * too, so a leaked id can never read or write across the boundary.
+ *
+ * Imports `drizzle-orm`, so this is a subpath, never re-exported from root.
+ */
+
+/** Any SQLite drizzle database — `any` erases driver-specific generics so
+ *  better-sqlite3, D1, and libsql handles all fit. */
+type IntakeDatabase = BaseSQLiteDatabase<'sync' | 'async', any, any>;
+/** A loaded intake: the payload plus whether it is complete against the graph. */
+interface IntakeState {
+    payload: IntakePayload;
+    completed: boolean;
+    completedAt: Date | null;
+}
+type IntakeErrorCode = 'invalid-answer' | 'unknown-question' | 'incomplete' | 'stale-graph';
+/** Thrown by store mutations on a refused write — callers map it to a 4xx. */
+declare class IntakeError extends Error {
+    readonly code: IntakeErrorCode;
+    constructor(code: IntakeErrorCode, message: string);
+}
+/** The three-method store surface, identical for both scopes. */
+interface IntakeStore {
+    /** Load the current intake, or seed an empty payload when none exists yet. */
+    get(): Promise<IntakeState>;
+    /** Validate and persist one answer; returns the updated state. */
+    save(questionId: string, value: IntakeAnswerValue): Promise<IntakeState>;
+    /** Stamp the intake complete; throws IntakeError when not yet completable. */
+    complete(): Promise<IntakeState>;
+}
+interface CreateUserIntakeStoreOptions {
+    db: IntakeDatabase;
+    /** The user-intake table from createIntakeTables. */
+    table: UserIntakeTable;
+    /** The intake definition this store collects answers against. */
+    graph: IntakeGraph;
+    /** The user whose onboarding this is. */
+    userId: string;
+}
+/** Build the per-user onboarding store, scoped to one userId. */
+declare function createUserIntakeStore(opts: CreateUserIntakeStoreOptions): IntakeStore;
+interface CreateProjectIntakeStoreOptions {
+    db: IntakeDatabase;
+    /** The project-intake table from createIntakeTables (workspace scope). */
+    table: ProjectIntakeTable;
+    graph: IntakeGraph;
+    /** The workspace this intake is attached to. */
+    workspaceId: string;
+}
+/** Build the per-project store, scoped to one workspaceId. */
+declare function createProjectIntakeStore(opts: CreateProjectIntakeStoreOptions): IntakeStore;
+
+export { type AnyIntakeTables, type CreateIntakeTablesOptions, type CreateProjectIntakeStoreOptions, type CreateUserIntakeStoreOptions, type IntakeDatabase, IntakeError, type IntakeErrorCode, type IntakeParentTable, type IntakeState, type IntakeStore, type IntakeTables, type ProjectIntakeRow, type ProjectIntakeTable, type UserIntakeRow, type UserIntakeTable, createIntakeTables, createProjectIntakeStore, createUserIntakeStore };

package/dist/intakes/drizzle.js

@@ -0,0 +1,61 @@
+import {
+  IntakeError,
+  createProjectIntakeStore,
+  createUserIntakeStore
+} from "../chunk-4K7BZYO7.js";
+import "../chunk-USYXHDKE.js";
+import "../chunk-ND3XEGBE.js";
+
+// src/intakes/drizzle/schema.ts
+import { sql } from "drizzle-orm";
+import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+var hexId = () => text("id").primaryKey().default(sql`(lower(hex(randomblob(16))))`);
+var createdAt = () => integer("created_at", { mode: "timestamp" }).notNull().default(sql`(unixepoch())`);
+var updatedAt = () => integer("updated_at", { mode: "timestamp" }).notNull().default(sql`(unixepoch())`);
+function createUserIntakeTable(userTable) {
+  return sqliteTable("user_intake", {
+    id: hexId(),
+    userId: text("user_id").notNull().references(() => userTable.id, { onDelete: "cascade" }),
+    /** The intake definition id the payload was collected against. */
+    graphId: text("graph_id").notNull(),
+    /** The IntakePayload JSON blob. */
+    payload: text("payload", { mode: "json" }).notNull(),
+    /** Set when the user finishes the onboarding interview; null while open. */
+    completedAt: integer("completed_at", { mode: "timestamp" }),
+    createdAt: createdAt(),
+    updatedAt: updatedAt()
+  }, (table) => [
+    uniqueIndex("uniq_user_intake_user").on(table.userId)
+  ]);
+}
+function createProjectIntakeTable(workspaceTable) {
+  return sqliteTable("project_intake", {
+    id: hexId(),
+    workspaceId: text("workspace_id").notNull().references(() => workspaceTable.id, { onDelete: "cascade" }),
+    graphId: text("graph_id").notNull(),
+    payload: text("payload", { mode: "json" }).notNull(),
+    completedAt: integer("completed_at", { mode: "timestamp" }),
+    createdAt: createdAt(),
+    updatedAt: updatedAt()
+  }, (table) => [
+    uniqueIndex("uniq_project_intake_workspace").on(table.workspaceId),
+    index("idx_project_intake_graph").on(table.graphId)
+  ]);
+}
+function createIntakeTables(opts) {
+  const userIntake = createUserIntakeTable(opts.userTable);
+  const result = {
+    userIntake
+  };
+  if (opts.workspaceTable) {
+    result.projectIntake = createProjectIntakeTable(opts.workspaceTable);
+  }
+  return result;
+}
+export {
+  IntakeError,
+  createIntakeTables,
+  createProjectIntakeStore,
+  createUserIntakeStore
+};
+//# sourceMappingURL=drizzle.js.map

package/dist/intakes/drizzle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/intakes/drizzle/schema.ts"],"sourcesContent":["/**\n * Drizzle schema factory for the intake tables. The product owns the user (and\n * optionally workspace) tables; this factory creates the intake tables and\n * wires their foreign keys into the passed-in tables so the whole graph lives\n * in one drizzle schema with real cascade semantics.\n *\n * Two tables, two scopes:\n *   - `user_intake`    — the one-time onboarding interview, keyed on `user.id`\n *     (UNIQUE per user: one onboarding payload per user). ALWAYS created.\n *   - `project_intake` — the structured intake attached to a workspace, keyed\n *     on `workspace.id` (UNIQUE per workspace). Created ONLY when a\n *     `workspaceTable` is passed.\n *\n * `workspaceTable` is OPTIONAL by design: a non-workspace app (a single-user\n * tool, tax-without-workspaces) adopts per-user onboarding alone with zero\n * teams and zero workspace concept. When omitted, `createIntakeTables` returns\n * `{ userIntake }` and no `projectIntake` — the FK to a workspace table that\n * does not exist is never created.\n *\n * Imports `drizzle-orm` at module top — that is WHY this lives behind the\n * `/intakes/drizzle` sub-subpath. The pure `./intakes` leaf imports none of\n * this, so a consumer that never touches the DB never pulls the optional peer.\n */\n\nimport { sql } from 'drizzle-orm'\nimport { index, integer, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core'\nimport type { AnySQLiteColumn, AnySQLiteTable } from 'drizzle-orm/sqlite-core'\n\n/** A product table referenced by FK — only the `id` column is touched. */\nexport type IntakeParentTable = AnySQLiteTable & { id: AnySQLiteColumn }\n\nexport interface CreateIntakeTablesOptions {\n  /** The product's user table — user-intake rows reference `userTable.id`. */\n  userTable: IntakeParentTable\n  /**\n   * The product's workspace table — project-intake rows reference\n   * `workspaceTable.id`. OPTIONAL: omit it for a single-user / non-workspace\n   * app that wants per-user onboarding only. When omitted, no `projectIntake`\n   * table is created.\n   */\n  workspaceTable?: IntakeParentTable\n}\n\nconst hexId = () => text('id').primaryKey().default(sql`(lower(hex(randomblob(16))))`)\n\nconst createdAt = () => integer('created_at', { mode: 'timestamp' }).notNull().default(sql`(unixepoch())`)\n\nconst updatedAt = () => integer('updated_at', { mode: 'timestamp' }).notNull().default(sql`(unixepoch())`)\n\nfunction createUserIntakeTable(userTable: IntakeParentTable) {\n  return sqliteTable('user_intake', {\n    id: hexId(),\n    userId: text('user_id').notNull().references(() => userTable.id, { onDelete: 'cascade' }),\n    /** The intake definition id the payload was collected against. */\n    graphId: text('graph_id').notNull(),\n    /** The IntakePayload JSON blob. */\n    payload: text('payload', { mode: 'json' }).notNull(),\n    /** Set when the user finishes the onboarding interview; null while open. */\n    completedAt: integer('completed_at', { mode: 'timestamp' }),\n    createdAt: createdAt(),\n    updatedAt: updatedAt(),\n  }, (table) => [\n    uniqueIndex('uniq_user_intake_user').on(table.userId),\n  ])\n}\n\nfunction createProjectIntakeTable(workspaceTable: IntakeParentTable) {\n  return sqliteTable('project_intake', {\n    id: hexId(),\n    workspaceId: text('workspace_id').notNull().references(() => workspaceTable.id, { onDelete: 'cascade' }),\n    graphId: text('graph_id').notNull(),\n    payload: text('payload', { mode: 'json' }).notNull(),\n    completedAt: integer('completed_at', { mode: 'timestamp' }),\n    createdAt: createdAt(),\n    updatedAt: updatedAt(),\n  }, (table) => [\n    uniqueIndex('uniq_project_intake_workspace').on(table.workspaceId),\n    index('idx_project_intake_graph').on(table.graphId),\n  ])\n}\n\n/**\n * Build the intake tables wired to the product's tables. Always returns\n * `userIntake`; returns `projectIntake` only when `workspaceTable` is passed.\n * The return type carries `projectIntake?` so a consumer that passes no\n * workspace table cannot reference a table that does not exist.\n */\nexport function createIntakeTables<O extends CreateIntakeTablesOptions>(\n  opts: O,\n): IntakeTables<O> {\n  const userIntake = createUserIntakeTable(opts.userTable)\n  const result: { userIntake: ReturnType<typeof createUserIntakeTable>; projectIntake?: ReturnType<typeof createProjectIntakeTable> } = {\n    userIntake,\n  }\n  if (opts.workspaceTable) {\n    result.projectIntake = createProjectIntakeTable(opts.workspaceTable)\n  }\n  return result as IntakeTables<O>\n}\n\nexport type UserIntakeTable = ReturnType<typeof createUserIntakeTable>\nexport type ProjectIntakeTable = ReturnType<typeof createProjectIntakeTable>\n\n/**\n * The tables returned for a given options shape: `projectIntake` is present in\n * the type exactly when `workspaceTable` was provided.\n */\nexport type IntakeTables<O extends CreateIntakeTablesOptions> =\n  O extends { workspaceTable: IntakeParentTable }\n    ? { userIntake: UserIntakeTable; projectIntake: ProjectIntakeTable }\n    : { userIntake: UserIntakeTable; projectIntake?: ProjectIntakeTable }\n\n/** The union table shape, for code that handles either scope generically. */\nexport type AnyIntakeTables = { userIntake: UserIntakeTable; projectIntake?: ProjectIntakeTable }\n\nexport type UserIntakeRow = UserIntakeTable['$inferSelect']\nexport type ProjectIntakeRow = ProjectIntakeTable['$inferSelect']\n"],"mappings":";;;;;;;;;AAwBA,SAAS,WAAW;AACpB,SAAS,OAAO,SAAS,aAAa,MAAM,mBAAmB;AAkB/D,IAAM,QAAQ,MAAM,KAAK,IAAI,EAAE,WAAW,EAAE,QAAQ,iCAAiC;AAErF,IAAM,YAAY,MAAM,QAAQ,cAAc,EAAE,MAAM,YAAY,CAAC,EAAE,QAAQ,EAAE,QAAQ,kBAAkB;AAEzG,IAAM,YAAY,MAAM,QAAQ,cAAc,EAAE,MAAM,YAAY,CAAC,EAAE,QAAQ,EAAE,QAAQ,kBAAkB;AAEzG,SAAS,sBAAsB,WAA8B;AAC3D,SAAO,YAAY,eAAe;AAAA,IAChC,IAAI,MAAM;AAAA,IACV,QAAQ,KAAK,SAAS,EAAE,QAAQ,EAAE,WAAW,MAAM,UAAU,IAAI,EAAE,UAAU,UAAU,CAAC;AAAA;AAAA,IAExF,SAAS,KAAK,UAAU,EAAE,QAAQ;AAAA;AAAA,IAElC,SAAS,KAAK,WAAW,EAAE,MAAM,OAAO,CAAC,EAAE,QAAQ;AAAA;AAAA,IAEnD,aAAa,QAAQ,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAAA,IAC1D,WAAW,UAAU;AAAA,IACrB,WAAW,UAAU;AAAA,EACvB,GAAG,CAAC,UAAU;AAAA,IACZ,YAAY,uBAAuB,EAAE,GAAG,MAAM,MAAM;AAAA,EACtD,CAAC;AACH;AAEA,SAAS,yBAAyB,gBAAmC;AACnE,SAAO,YAAY,kBAAkB;AAAA,IACnC,IAAI,MAAM;AAAA,IACV,aAAa,KAAK,cAAc,EAAE,QAAQ,EAAE,WAAW,MAAM,eAAe,IAAI,EAAE,UAAU,UAAU,CAAC;AAAA,IACvG,SAAS,KAAK,UAAU,EAAE,QAAQ;AAAA,IAClC,SAAS,KAAK,WAAW,EAAE,MAAM,OAAO,CAAC,EAAE,QAAQ;AAAA,IACnD,aAAa,QAAQ,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAAA,IAC1D,WAAW,UAAU;AAAA,IACrB,WAAW,UAAU;AAAA,EACvB,GAAG,CAAC,UAAU;AAAA,IACZ,YAAY,+BAA+B,EAAE,GAAG,MAAM,WAAW;AAAA,IACjE,MAAM,0BAA0B,EAAE,GAAG,MAAM,OAAO;AAAA,EACpD,CAAC;AACH;AAQO,SAAS,mBACd,MACiB;AACjB,QAAM,aAAa,sBAAsB,KAAK,SAAS;AACvD,QAAM,SAAgI;AAAA,IACpI;AAAA,EACF;AACA,MAAI,KAAK,gBAAgB;AACvB,WAAO,gBAAgB,yBAAyB,KAAK,cAAc;AAAA,EACrE;AACA,SAAO;AACT;","names":[]}

package/dist/intakes/index.d.ts

@@ -0,0 +1,42 @@
+import { c as IntakeAnswers, b as IntakeGraph, I as IntakeAnswerValue } from '../model-Cuj7d-xT.js';
+export { A as AnswerRejectionReason, d as AnswerValidationResult, e as IntakeAnswerType, f as IntakeOption, a as IntakeQuestion, g as getQuestion, h as hasAnswer, i as intakeProgress, j as isComplete, n as nextQuestion, r as reachableQuestions, v as validateAnswer } from '../model-Cuj7d-xT.js';
+
+/**
+ * Pure completion-state helpers for an intake payload — the small algebra over
+ * the JSON blob the store persists. No I/O: the store reads/writes the row;
+ * these functions only build and judge the payload shape, so the same logic
+ * runs in the UI, the handlers, and the DB layer without divergence.
+ *
+ * A payload is `{ graphId, answers, completedAt? }`. It carries the answers
+ * and the id of the graph they were collected against, so a later graph
+ * revision can detect a stale payload (`graphId` mismatch) rather than
+ * silently mixing answers from two question sets.
+ */
+
+/** The persisted JSON for one intake (the `payload` column). */
+interface IntakePayload {
+    /** The graph id the answers were collected against — guards stale schemas. */
+    graphId: string;
+    answers: IntakeAnswers;
+    /** ISO-8601 instant the intake was completed, or undefined while in progress. */
+    completedAt?: string;
+}
+/** An empty payload for a fresh intake against `graph`. */
+declare function emptyPayload(graph: IntakeGraph): IntakePayload;
+/** A copy of `payload` with one answer set (does not mutate the input). */
+declare function withAnswer(payload: IntakePayload, questionId: string, value: IntakeAnswerValue): IntakePayload;
+/**
+ * True when the payload's answers complete the graph AND the payload was
+ * collected against THIS graph. A `graphId` mismatch is never "complete" —
+ * the answers belong to a different question set and must be re-collected.
+ */
+declare function payloadComplete(graph: IntakeGraph, payload: IntakePayload): boolean;
+/** True when the payload was collected against a DIFFERENT graph revision. */
+declare function payloadIsStale(graph: IntakeGraph, payload: IntakePayload): boolean;
+/**
+ * Stamp the payload complete at `at` (default now). Returns a copy; pure. The
+ * caller has already checked `payloadComplete` — this only records the instant.
+ */
+declare function markComplete(payload: IntakePayload, at?: Date): IntakePayload;
+
+export { IntakeAnswerValue, IntakeAnswers, IntakeGraph, type IntakePayload, emptyPayload, markComplete, payloadComplete, payloadIsStale, withAnswer };

package/dist/intakes/index.js

@@ -0,0 +1,31 @@
+import {
+  emptyPayload,
+  markComplete,
+  payloadComplete,
+  payloadIsStale,
+  withAnswer
+} from "../chunk-USYXHDKE.js";
+import {
+  getQuestion,
+  hasAnswer,
+  intakeProgress,
+  isComplete,
+  nextQuestion,
+  reachableQuestions,
+  validateAnswer
+} from "../chunk-ND3XEGBE.js";
+export {
+  emptyPayload,
+  getQuestion,
+  hasAnswer,
+  intakeProgress,
+  isComplete,
+  markComplete,
+  nextQuestion,
+  payloadComplete,
+  payloadIsStale,
+  reachableQuestions,
+  validateAnswer,
+  withAnswer
+};
+//# sourceMappingURL=index.js.map

package/dist/intakes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}