@tangle-network/agent-app 0.60.208 → 0.60.210

package/dist/intakes/api.d.ts

@@ -1,54 +0,0 @@
-/**
- * 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.
- */
-import { type IntakeAnswerValue, type IntakeGraph, type IntakeQuestion } from './model';
-import { type IntakeStore } from './drizzle/store';
-/** What the client renders: the saved state, the next prompt, and progress. */
-export 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;
-    };
-}
-/** Define configuration options for initializing the intake API with store and graph components */
-export 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).
- */
-export declare function createIntakeApi(opts: IntakeApiOptions): {
-    getCurrentIntake: () => Promise<Response>;
-    saveAnswer: (input: {
-        questionId?: string;
-        value?: IntakeAnswerValue;
-    }) => Promise<Response>;
-    completeIntake: () => Promise<Response>;
-};

package/dist/intakes/api.js

@@ -1,63 +0,0 @@
-import {
-  IntakeError
-} from "../chunk-VWAEWOWK.js";
-import "../chunk-YZ6KQULN.js";
-import {
-  intakeProgress,
-  nextQuestion
-} from "../chunk-JDEGS53O.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

@@ -1 +0,0 @@
-{"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\n/** Define configuration options for initializing the intake API with store and graph components */\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":";;;;;;;;;;AAqDO,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-react/components/BrandMark.d.ts

@@ -1,10 +0,0 @@
-/**
- * Load the canonical Tangle knot only when an intakes surface renders it.
- * `/brand` imports the optional `@tangle-network/brand` peer, so a failed load
- * renders a fixed-size spacer instead of crashing the panel.
- */
-export interface BrandMarkProps {
-    size: number;
-    className?: string;
-}
-export declare function BrandMark({ size, className }: BrandMarkProps): import("react").JSX.Element;

package/dist/intakes-react/components/IntakeInterview.d.ts

@@ -1,15 +0,0 @@
-/**
- * Agent-led intake interview: asks one question at a time, advancing as each
- * answer is saved. Fully callback-driven — the host supplies the loaded `view`
- * and the async `onAnswer` / `onComplete` callbacks (backed by `./intakes/api`),
- * so this imports no app router, fetch client, or toast. Styled with the
- * shipped Tangle Quiet tokens (`var(--*)`).
- *
- * The server owns traversal: each `onAnswer` resolves with the next view (next
- * question + progress), so the component never re-derives the graph — it renders
- * `view.nextQuestion`, and when that is null and the view is completable it
- * shows the finish action. Local validation only gates the submit button; the
- * authoritative validation runs in the store.
- */
-import type { IntakeInterviewProps } from '../contracts';
-export declare function IntakeInterview({ view: initialView, onAnswer, onComplete, onDone, onNotice, }: IntakeInterviewProps): import("react").JSX.Element;

package/dist/intakes-react/components/index.d.ts

@@ -1 +0,0 @@
-export * from './IntakeInterview';

package/dist/intakes-react/contracts.d.ts

@@ -1,42 +0,0 @@
-/**
- * Seams between the intakes React surface and the host app. Everything here is
- * interface-only and callback-driven: the components never import an app's
- * router, fetch client, or toast system. The host passes the loaded view in and
- * supplies the async callbacks (which it backs with `./intakes/api` over fetch),
- * so the same interview mounts in any app and for either scope (user / project).
- */
-import type { IntakeAnswerValue, IntakeQuestion } from '../intakes/model';
-/** The state the interview renders — the shape `./intakes/api` returns. */
-export interface IntakeView {
-    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;
-    progress: {
-        answered: number;
-        total: number;
-    };
-}
-/** Define properties and callbacks for managing the intake interview flow and user interactions */
-export interface IntakeInterviewProps {
-    view: IntakeView;
-    /**
-     * Persist one answer; resolve with the next view (the server re-derives the
-     * next question + progress). The component re-renders from the returned view.
-     */
-    onAnswer(input: {
-        questionId: string;
-        value: IntakeAnswerValue;
-    }): Promise<IntakeView>;
-    /** Finish the interview; resolve with the final view. */
-    onComplete(): Promise<IntakeView>;
-    /** Called once when the interview is done (completed view), for navigation. */
-    onDone?(): void;
-    /** Optional toast/notice hook; defaults to a no-op (host owns its UX). */
-    onNotice?(notice: {
-        kind: 'success' | 'error';
-        message: string;
-    }): void;
-}

package/dist/intakes-react/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * React surface for the intakes module: the IntakeInterview (one question at a
- * time, agent-led), plus its seams. Everything is callback-driven — no app
- * router, fetch client, or toast import — so any app mounts it and wires it to
- * `./intakes/api` over fetch, for either the per-user onboarding scope or the
- * per-project intake scope.
- *
- * Never re-exported from the package root: `react` is an optional peer (the
- * `web-react` / `teams-react` precedent). DOM access begins only inside
- * component render. A `React.lazy` code-split entry lives at
- * `./intakes-react/lazy`.
- */
-export * from './contracts';
-export * from './components/index';

package/dist/intakes-react/index.js

@@ -1,8 +0,0 @@
-import {
-  IntakeInterview
-} from "../chunk-I2CA5N7V.js";
-import "../chunk-JDEGS53O.js";
-export {
-  IntakeInterview
-};
-//# sourceMappingURL=index.js.map

package/dist/intakes-react/index.js.map

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

package/dist/intakes-react/lazy.d.ts

@@ -1,10 +0,0 @@
-/**
- * Code-split entry for the intakes React surface. Products that don't need the
- * interview UI on initial load import this `React.lazy` handle instead of the
- * component directly, so the interview chunk loads on first render. Mount inside
- * a `<Suspense>` boundary; the product provides the fallback.
- */
-import type { IntakeInterviewProps } from './contracts';
-export type { IntakeInterviewProps };
-/** Load IntakeInterview component lazily to optimize initial application rendering */
-export declare const IntakeInterviewLazy: import("react").LazyExoticComponent<typeof import("./components").IntakeInterview>;

package/dist/intakes-react/lazy.js

@@ -1,9 +0,0 @@
-// src/intakes-react/lazy.tsx
-import { lazy } from "react";
-var IntakeInterviewLazy = lazy(
-  () => import("../IntakeInterview-OKT6DCBN.js").then((m) => ({ default: m.IntakeInterview }))
-);
-export {
-  IntakeInterviewLazy
-};
-//# sourceMappingURL=lazy.js.map

package/dist/intakes-react/lazy.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/intakes-react/lazy.tsx"],"sourcesContent":["/**\n * Code-split entry for the intakes React surface. Products that don't need the\n * interview UI on initial load import this `React.lazy` handle instead of the\n * component directly, so the interview chunk loads on first render. Mount inside\n * a `<Suspense>` boundary; the product provides the fallback.\n */\n\nimport { lazy } from 'react'\nimport type { IntakeInterviewProps } from './contracts'\n\nexport type { IntakeInterviewProps }\n\n/** Load IntakeInterview component lazily to optimize initial application rendering */\nexport const IntakeInterviewLazy = lazy(\n  () => import('./components/IntakeInterview').then((m) => ({ default: m.IntakeInterview })),\n)\n"],"mappings":";AAOA,SAAS,YAAY;AAMd,IAAM,sBAAsB;AAAA,EACjC,MAAM,OAAO,gCAA8B,EAAE,KAAK,CAAC,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE;AAC3F;","names":[]}