@tangle-network/agent-app 0.43.56 → 0.43.57

package/dist/{chunk-5PTGEJZL.js → chunk-5SD6HT2V.js}

@@ -233,4 +233,4 @@ export {
   parseAssetSpec,
   safeParseAssetSpec
 };
-//# sourceMappingURL=chunk-5PTGEJZL.js.map
+//# sourceMappingURL=chunk-5SD6HT2V.js.map

package/dist/chunk-5SD6HT2V.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/assets/schema.ts"],"sourcesContent":["import { z } from 'zod'\nimport type { AssetSpec, AssetFormat } from './types'\n\n// --- Brand ---\n\n/** Validate brand token properties including colors, font, logo URL, business name, and voice */\nexport const BrandTokensSchema = z.object({\n  primaryColor: z.string(),\n  accentColor: z.string(),\n  textColor: z.string(),\n  fontFamily: z.string(),\n  logoUrl: z.string().optional(),\n  businessName: z.string(),\n  voice: z.string(),\n})\n\n// --- Email ---\n\nconst EmailHeroSectionSchema = z.object({\n  type: z.literal('hero'),\n  headline: z.string(),\n  subheadline: z.string().optional(),\n  imageUrl: z.string().optional(),\n  ctaLabel: z.string().optional(),\n  ctaUrl: z.string().optional(),\n})\n\nconst EmailBodySectionSchema = z.object({\n  type: z.literal('body'),\n  text: z.string(),\n})\n\nconst EmailFeatureSectionSchema = z.object({\n  type: z.literal('feature'),\n  headline: z.string(),\n  description: z.string(),\n  imageUrl: z.string().optional(),\n})\n\nconst EmailTestimonialSectionSchema = z.object({\n  type: z.literal('testimonial'),\n  quote: z.string(),\n  author: z.string(),\n  role: z.string().optional(),\n  avatarUrl: z.string().optional(),\n})\n\nconst EmailCtaSectionSchema = z.object({\n  type: z.literal('cta'),\n  label: z.string(),\n  url: z.string(),\n  subtext: z.string().optional(),\n})\n\nconst EmailDividerSectionSchema = z.object({\n  type: z.literal('divider'),\n})\n\nconst EmailSectionSchema = z.discriminatedUnion('type', [\n  EmailHeroSectionSchema,\n  EmailBodySectionSchema,\n  EmailFeatureSectionSchema,\n  EmailTestimonialSectionSchema,\n  EmailCtaSectionSchema,\n  EmailDividerSectionSchema,\n])\n\n/** Validate and parse email content objects with subject, optional preheader, and sections */\nexport const EmailContentSchema = z.object({\n  subject: z.string(),\n  preheader: z.string().optional(),\n  sections: z.array(EmailSectionSchema),\n})\n\n// --- Image ---\n\nconst ImageBackgroundSchema = z.discriminatedUnion('type', [\n  z.object({ type: z.literal('color'), value: z.string() }),\n  z.object({ type: z.literal('gradient'), from: z.string(), to: z.string(), direction: z.string().optional() }),\n  z.object({ type: z.literal('image'), url: z.string(), overlay: z.string().optional(), overlayOpacity: z.number().optional() }),\n])\n\nconst ImageTextLayerSchema = z.object({\n  type: z.literal('text'),\n  text: z.string(),\n  fontSize: z.number().optional(),\n  fontWeight: z.enum(['normal', 'bold']).optional(),\n  color: z.string().optional(),\n  x: z.number(),\n  y: z.number(),\n  width: z.number().optional(),\n  align: z.enum(['left', 'center', 'right']).optional(),\n})\n\nconst ImageImageLayerSchema = z.object({\n  type: z.literal('image'),\n  url: z.string(),\n  x: z.number(),\n  y: z.number(),\n  width: z.number(),\n  height: z.number(),\n  opacity: z.number().optional(),\n})\n\nconst ImageShapeLayerSchema = z.object({\n  type: z.literal('shape'),\n  shape: z.enum(['rect', 'circle', 'rounded-rect']),\n  x: z.number(),\n  y: z.number(),\n  width: z.number(),\n  height: z.number(),\n  fill: z.string().optional(),\n  opacity: z.number().optional(),\n})\n\nconst ImageLogoLayerSchema = z.object({\n  type: z.literal('logo'),\n  x: z.number(),\n  y: z.number(),\n  width: z.number().optional(),\n})\n\nconst ImageLayerSchema = z.discriminatedUnion('type', [\n  ImageTextLayerSchema,\n  ImageImageLayerSchema,\n  ImageShapeLayerSchema,\n  ImageLogoLayerSchema,\n])\n\nconst ImageSlideSchema = z.object({\n  background: ImageBackgroundSchema,\n  layers: z.array(ImageLayerSchema),\n})\n\n/** Validate image content with an array of one or more slides containing background details */\nexport const ImageContentSchema = z.object({\n  slides: z.array(ImageSlideSchema).min(1),\n})\n\n// --- Video ---\n\nconst VideoTextAnimationSceneSchema = z.object({\n  type: z.literal('text-animation'),\n  durationSeconds: z.number().positive(),\n  headline: z.string(),\n  subtext: z.string().optional(),\n  animation: z.enum(['fade', 'slide-up', 'typewriter']).optional(),\n  background: ImageBackgroundSchema.optional(),\n})\n\nconst VideoImageRevealSceneSchema = z.object({\n  type: z.literal('image-reveal'),\n  durationSeconds: z.number().positive(),\n  imageUrl: z.string(),\n  caption: z.string().optional(),\n})\n\nconst VideoSlideSceneSchema = z.object({\n  type: z.literal('slide'),\n  durationSeconds: z.number().positive(),\n  slide: ImageSlideSchema,\n})\n\nconst VideoCountdownSceneSchema = z.object({\n  type: z.literal('countdown'),\n  durationSeconds: z.number().positive(),\n  from: z.number().int().positive(),\n  label: z.string().optional(),\n})\n\nconst VideoSceneSchema = z.discriminatedUnion('type', [\n  VideoTextAnimationSceneSchema,\n  VideoImageRevealSceneSchema,\n  VideoSlideSceneSchema,\n  VideoCountdownSceneSchema,\n])\n\nconst VideoCaptionSchema = z.object({\n  startSeconds: z.number().nonnegative(),\n  endSeconds: z.number().positive(),\n  text: z.string(),\n})\n\n/** Define the schema for validating video content including duration, scenes, audio, captions, and rendered URL */\nexport const VideoContentSchema = z.object({\n  durationSeconds: z.number().positive(),\n  scenes: z.array(VideoSceneSchema).min(1),\n  audioUrl: z.string().optional(),\n  captions: z.array(VideoCaptionSchema).optional(),\n  renderedUrl: z.string().optional(),\n})\n\n// --- Copy ---\n\n/** Validate and parse copy content with headline, body, optional hashtags, platform, and character count */\nexport const CopyContentSchema = z.object({\n  headline: z.string(),\n  body: z.string(),\n  hashtags: z.array(z.string()).optional(),\n  platform: z.enum(['instagram', 'tiktok', 'x', 'linkedin', 'sms', 'email-subject']),\n  characterCount: z.number().optional(),\n})\n\n// --- Approval ---\n\n/** Validate approval event data including asset, action, user, timestamp, and optional fields */\nexport const ApprovalEventSchema = z.object({\n  assetId: z.string(),\n  variantId: z.string().optional(),\n  action: z.enum(['approved', 'rejected', 'edited', 'scheduled']),\n  editedFields: z.array(z.string()).optional(),\n  userId: z.string(),\n  timestamp: z.string(),\n})\n\n/** Validate conversion metrics with nonnegative impressions, clicks, conversions, CTR, and CVR fields */\nexport const ConversionMetricsSchema = z.object({\n  impressions: z.number().nonnegative(),\n  clicks: z.number().nonnegative(),\n  conversions: z.number().nonnegative(),\n  ctr: z.number().nonnegative(),\n  cvr: z.number().nonnegative(),\n})\n\n// --- Content map for discriminated parse ---\n\nconst AssetFormatValues = [\n  'email',\n  'image:feed',\n  'image:story',\n  'image:carousel',\n  'video:reel',\n  'video:feed',\n  'copy:caption',\n  'copy:headline',\n  'copy:sms',\n] as const\n\nconst ContentSchemaByFormat = {\n  email: EmailContentSchema,\n  'image:feed': ImageContentSchema,\n  'image:story': ImageContentSchema,\n  'image:carousel': ImageContentSchema,\n  'video:reel': VideoContentSchema,\n  'video:feed': VideoContentSchema,\n  'copy:caption': CopyContentSchema,\n  'copy:headline': CopyContentSchema,\n  'copy:sms': CopyContentSchema,\n} as const\n\nconst AssetSpecBaseSchema = z.object({\n  id: z.string(),\n  workspaceId: z.string(),\n  campaignId: z.string().optional(),\n  format: z.enum(AssetFormatValues),\n  brand: BrandTokensSchema,\n  status: z.enum(['draft', 'pending_review', 'approved', 'rejected', 'scheduled', 'published']),\n  scheduledAt: z.string().optional(),\n  createdAt: z.string(),\n  updatedAt: z.string(),\n})\n\n/**\n * Validates an unknown value as an AssetSpec, including format-specific\n * content validation. Throws ZodError on invalid input.\n */\nexport function parseAssetSpec(raw: unknown): AssetSpec {\n  const base = AssetSpecBaseSchema.parse(raw)\n  const contentSchema = ContentSchemaByFormat[base.format]\n  const content = contentSchema.parse((raw as Record<string, unknown>).content)\n  return { ...base, content } as AssetSpec\n}\n\n/**\n * Safe parse — returns null instead of throwing.\n */\nexport function safeParseAssetSpec(raw: unknown): AssetSpec | null {\n  try {\n    return parseAssetSpec(raw)\n  } catch {\n    return null\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-7C64WKAH.js → chunk-5SXS3YAB.js}

@@ -1,6 +1,6 @@
 import {
   hasWorkspaceRole
-} from "./chunk-63CE7FEZ.js";
+} from "./chunk-6XIAPIW6.js";
 
 // src/teams-react/components/InvitationsPanel.tsx
 import { useState } from "react";
@@ -209,4 +209,4 @@ function InvitationRow({ invitation, canManage, busy, onCopy, onResend, onRevoke
 export {
   InvitationsPanel
 };
-//# sourceMappingURL=chunk-7C64WKAH.js.map
+//# sourceMappingURL=chunk-5SXS3YAB.js.map

package/dist/{chunk-L2TG5DBW.js → chunk-5TESA4SN.js}

@@ -71,4 +71,4 @@ export {
   HubExecClient,
   invokeIntegrationHub
 };
-//# sourceMappingURL=chunk-L2TG5DBW.js.map
+//# sourceMappingURL=chunk-5TESA4SN.js.map

package/dist/chunk-5TESA4SN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/integrations/index.ts"],"sourcesContent":["/**\n * Integration-hub WIRING — the agent→hub invocation path every Tangle agent app\n * forks. The integration ENGINE (catalog, connectors, OAuth, policy) is\n * `@tangle-network/agent-integrations` (a peer dependency); this module is the\n * thin app-side wiring on top: a typed client over the platform hub's\n * `POST /v1/hub/exec`, MCP-tool-name → hub-action-path resolution, and the\n * per-turn invoke flow the `integration_invoke` tool calls.\n *\n * The product supplies its own catalog (which connectors it uses) and its own\n * per-user api-key resolver (the `apiKeyResolver` seam) — this module owns\n * neither credentials nor the action catalog.\n */\nimport { parseIntegrationToolName } from '@tangle-network/agent-integrations/catalog'\n\n/** `{ success: false }` codes the hub returns on `/exec`. */\nexport type HubExecErrorCode =\n  | 'HUB_APPROVAL_REQUIRED'\n  | 'HUB_POLICY_DENIED'\n  | 'HUB_CONNECTION_MISSING'\n  | 'HUB_CONNECTION_REVOKED'\n  | 'HUB_CONFIG_MISSING'\n  | 'HUB_NOT_FOUND'\n  | string\n\n/** Outcome of a hub `/exec` call. Callers MUST inspect `succeeded` before\n *  reading `result` — a denied or approval-gated write resolves with\n *  `succeeded: false` and a populated `code`, never a thrown silent failure. */\nexport type HubExecResult =\n  | { succeeded: true; result: unknown }\n  | { succeeded: false; code: HubExecErrorCode; message: string; approval?: unknown }\n\n/** Define configuration options for initializing a Hub execution client */\nexport interface HubExecClientOptions {\n  /** Platform base URL (e.g. `TANGLE_PLATFORM_URL`). */\n  baseUrl: string\n  /** Calling user's Tangle API key — the hub principal bearer. */\n  bearer: string\n  /** Test seam. Defaults to global `fetch`. */\n  fetchImpl?: typeof fetch\n}\n\n/** The provider/connector/action a hub action path addresses, plus the dotted\n *  `path` the hub `/exec` endpoint expects. */\nexport interface ParsedIntegrationAction {\n  providerId: string\n  connectorId: string\n  actionId: string\n  /** `provider.connector.action`. */\n  path: string\n}\n\n/**\n * Resolve an MCP tool name (the opaque `int_…` catalog name the agent calls)\n * into the dotted hub action path. Returns `undefined` when the name is not a\n * catalog integration tool, so the chat loop routes non-integration calls\n * elsewhere instead of misrouting them to the hub.\n */\nexport function resolveIntegrationAction(toolName: string): ParsedIntegrationAction | undefined {\n  let parsed: { providerId: string; connectorId: string; actionId: string }\n  try {\n    parsed = parseIntegrationToolName(toolName)\n  } catch {\n    return undefined\n  }\n  if (!parsed.providerId || !parsed.connectorId || !parsed.actionId) return undefined\n  return { ...parsed, path: `${parsed.providerId}.${parsed.connectorId}.${parsed.actionId}` }\n}\n\ninterface HubEnvelope {\n  success: boolean\n  data?: { result?: unknown }\n  error?: { code?: string; message?: string; details?: { approval?: unknown } }\n}\n\n/** Typed client over the platform hub `/v1/hub/exec`. The hub holds the user's\n *  credentials, resolves the connection from the bearer principal, evaluates\n *  per-action policy (read → allow, write/destructive → approval), and runs the\n *  action server-side. Never throws on a policy block — a gated write is a\n *  normal `succeeded: false` outcome. */\nexport class HubExecClient {\n  private readonly baseUrl: string\n  private readonly bearer: string\n  private readonly fetchImpl: typeof fetch\n\n  constructor(options: HubExecClientOptions) {\n    if (!options.baseUrl) throw new Error('HubExecClient: baseUrl is required')\n    if (!options.bearer) throw new Error('HubExecClient: bearer is required')\n    this.baseUrl = options.baseUrl.replace(/\\/+$/, '')\n    this.bearer = options.bearer\n    this.fetchImpl = options.fetchImpl ?? fetch\n  }\n\n  async exec(input: { path: string; actionInput?: unknown; connectionId?: string }): Promise<HubExecResult> {\n    const response = await this.fetchImpl(`${this.baseUrl}/v1/hub/exec`, {\n      method: 'POST',\n      headers: { Authorization: `Bearer ${this.bearer}`, 'Content-Type': 'application/json', Accept: 'application/json' },\n      body: JSON.stringify({ path: input.path, input: input.actionInput, connectionId: input.connectionId }),\n    })\n    const envelope = await this.readEnvelope(response)\n    if (response.ok && envelope.success) return { succeeded: true, result: envelope.data?.result }\n    return {\n      succeeded: false,\n      code: envelope.error?.code ?? `HUB_HTTP_${response.status}`,\n      message: envelope.error?.message ?? `Hub /exec returned ${response.status}`,\n      approval: envelope.error?.details?.approval,\n    }\n  }\n\n  private async readEnvelope(response: Response): Promise<HubEnvelope> {\n    const text = await response.text()\n    if (!text) return { success: false, error: { code: `HUB_HTTP_${response.status}`, message: `Hub returned ${response.status} with no body` } }\n    try {\n      return JSON.parse(text) as HubEnvelope\n    } catch {\n      return { success: false, error: { code: 'HUB_BAD_RESPONSE', message: `Hub returned non-JSON (${response.status}): ${text.slice(0, 200)}` } }\n    }\n  }\n}\n\n/** Define input parameters for invoking a hub tool with user ID, tool name, and optional arguments */\nexport interface HubInvokeInput {\n  userId: string\n  /** The MCP tool name the agent called (`int_<provider>_<connector>_<action>`). */\n  toolName: string\n  args?: Record<string, unknown>\n}\n/** Describe the outcome of a hub invocation including status and response body */\nexport interface HubInvokeOutcome {\n  status: number\n  body: Record<string, unknown>\n}\n/** Define dependencies for invoking hub operations including API key resolution and optional configuration */\nexport interface HubInvokeDeps {\n  /** Resolve the user's Tangle API key (the hub principal bearer). Required —\n   *  the product binds its own session-key resolver. Null → user not linked. */\n  apiKeyResolver: (userId: string) => Promise<string | null>\n  /** Platform base URL. Defaults to `env.TANGLE_PLATFORM_URL`. */\n  baseUrl?: string\n  fetchImpl?: typeof fetch\n  env?: Record<string, string | undefined>\n}\n\n/**\n * Resolve + execute one integration tool call through the hub: resolve the\n * per-user bearer, map the MCP tool name to the hub action path, forward to\n * `/v1/hub/exec`, and shape the route response (200 ok / 401 not-linked /\n * 400 unknown-tool / 409 approval-required / 502 hub-error). A write that's\n * approval-gated surfaces verbatim as 409, never silently executed.\n */\nexport async function invokeIntegrationHub(input: HubInvokeInput, deps: HubInvokeDeps): Promise<HubInvokeOutcome> {\n  const env = deps.env ?? (process.env as Record<string, string | undefined>)\n  const baseUrl = deps.baseUrl ?? env.TANGLE_PLATFORM_URL?.trim()\n  if (!baseUrl) return { status: 500, body: { error: 'TANGLE_PLATFORM_URL is not configured' } }\n\n  const action = resolveIntegrationAction(input.toolName)\n  if (!action) return { status: 400, body: { error: `Unsupported integration tool: ${input.toolName}` } }\n\n  const bearer = await deps.apiKeyResolver(input.userId)\n  if (!bearer) return { status: 401, body: { error: 'Tangle account not linked — connect integrations from the app first' } }\n\n  const client = new HubExecClient({ baseUrl, bearer, fetchImpl: deps.fetchImpl })\n  const outcome = await client.exec({ path: action.path, actionInput: input.args ?? {} })\n\n  if (outcome.succeeded) {\n    return { status: 200, body: { success: true, path: action.path, providerId: action.providerId, action: action.actionId, result: outcome.result } }\n  }\n  const status = outcome.code === 'HUB_APPROVAL_REQUIRED' ? 409 : 502\n  return {\n    status,\n    body: { success: false, path: action.path, code: outcome.code, error: outcome.message, ...(outcome.approval ? { approval: outcome.approval } : {}) },\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-63CE7FEZ.js → chunk-6XIAPIW6.js}

@@ -60,4 +60,4 @@ export {
   workspaceRoleToCollaborationAccess,
   workspaceRoleToSandboxRole
 };
-//# sourceMappingURL=chunk-63CE7FEZ.js.map
+//# sourceMappingURL=chunk-6XIAPIW6.js.map

package/dist/chunk-6XIAPIW6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/teams/roles.ts"],"sourcesContent":["/**\n * Pure role algebra for the teams capability — the tenancy/membership model\n * shared across the fleet. Zero dependencies: no drizzle, no env, no react, no\n * I/O. The DB layer (`./teams/drizzle`), the members API (`./teams/members-api`)\n * and the React surface (`./teams-react`) all build on these functions; this\n * leaf imports nothing back, so a consumer can pull just the role math.\n *\n * Two role ladders, deliberately distinct:\n *   - Organization roles rank the tenant (who owns/administers the org and its\n *     billing). An org owner/admin is an owner of every workspace under it.\n *   - Workspace roles rank a single workspace. They are the access primitive\n *     every route checks via `hasWorkspaceRole(actual, minimum)`.\n *\n * `resolveWorkspaceRole` is the bridge: it folds the org role and the\n * per-workspace role into the one effective workspace role a request runs at.\n */\n\nexport const WORKSPACE_ROLES = ['viewer', 'editor', 'admin', 'owner'] as const\n/** Resolve the union type of all possible workspace role string literals from WORKSPACE_ROLES array */\nexport type WorkspaceRole = typeof WORKSPACE_ROLES[number]\n\n/** Define the list of roles that can be assigned within a workspace */\nexport const ASSIGNABLE_WORKSPACE_ROLES = ['viewer', 'editor', 'admin'] as const\n/** Resolve the set of roles that can be assigned within a workspace */\nexport type AssignableWorkspaceRole = typeof ASSIGNABLE_WORKSPACE_ROLES[number]\n\n/** Define the set of fixed roles available within an organization */\nexport const ORGANIZATION_ROLES = ['owner', 'admin', 'member', 'billing'] as const\n/** Resolve a role string from the predefined list of organization roles */\nexport type OrganizationRole = typeof ORGANIZATION_ROLES[number]\n\n/** Define access levels for workspace collaboration as either read or write */\nexport type WorkspaceCollaborationAccess = 'read' | 'write'\n/** Define user roles available within a sandbox workspace environment */\nexport type SandboxWorkspaceRole = 'owner' | 'admin' | 'developer' | 'viewer'\n\n/** Map workspace roles to their corresponding hierarchical rank values */\nexport const WORKSPACE_ROLE_RANK: Record<WorkspaceRole, number> = {\n  viewer: 0,\n  editor: 1,\n  admin: 2,\n  owner: 3,\n}\n\n/** Map organization roles to their hierarchical rank for permission and access control purposes */\nexport const ORGANIZATION_ROLE_RANK: Record<OrganizationRole, number> = {\n  member: 0,\n  billing: 1,\n  admin: 2,\n  owner: 3,\n}\n\n/** True when `actual` is at least `minimum` on the workspace ladder. */\nexport function hasWorkspaceRole(actual: WorkspaceRole, minimum: WorkspaceRole): boolean {\n  return WORKSPACE_ROLE_RANK[actual] >= WORKSPACE_ROLE_RANK[minimum]\n}\n\n/** True when `actual` is at least `minimum` on the organization ladder. */\nexport function hasOrganizationRole(actual: OrganizationRole, minimum: OrganizationRole): boolean {\n  return ORGANIZATION_ROLE_RANK[actual] >= ORGANIZATION_ROLE_RANK[minimum]\n}\n\n/** Determine if a value is a valid assignable workspace role among viewer, editor, or admin */\nexport function isAssignableWorkspaceRole(value: unknown): value is AssignableWorkspaceRole {\n  return typeof value === 'string' && ASSIGNABLE_WORKSPACE_ROLES.includes(value as AssignableWorkspaceRole)\n}\n\n/** Org owners and admins are workspace owners across the whole org. */\nexport function organizationRoleGrantsWorkspaceOwner(role: OrganizationRole | string | null | undefined): boolean {\n  return role === 'owner' || role === 'admin'\n}\n\n/**\n * The effective workspace role a request runs at: org owner/admin → owner of\n * every workspace; otherwise the explicit per-workspace role (or null = no\n * access). This is the single fold every access check goes through.\n */\nexport function resolveWorkspaceRole(\n  organizationRole: OrganizationRole | string | null | undefined,\n  workspaceRole: WorkspaceRole | null | undefined,\n): WorkspaceRole | null {\n  return organizationRoleGrantsWorkspaceOwner(organizationRole) ? 'owner' : workspaceRole ?? null\n}\n\n/**\n * Whether `actorRole` may set/clear a member currently at `targetRole`. Owners\n * can manage anyone; everyone else can only manage members strictly below\n * their own rank (an admin cannot demote another admin or an owner).\n */\nexport function canManageWorkspaceMemberRole(actorRole: WorkspaceRole, targetRole: WorkspaceRole): boolean {\n  return actorRole === 'owner' || !hasWorkspaceRole(targetRole, actorRole)\n}\n\n/** Map a workspace role to the corresponding collaboration access level */\nexport function workspaceRoleToCollaborationAccess(role: WorkspaceRole): WorkspaceCollaborationAccess {\n  return role === 'viewer' ? 'read' : 'write'\n}\n\n/** Map a workspace role to its corresponding sandbox workspace role */\nexport function workspaceRoleToSandboxRole(role: WorkspaceRole): SandboxWorkspaceRole {\n  const mapping: Record<WorkspaceRole, SandboxWorkspaceRole> = {\n    owner: 'owner',\n    admin: 'admin',\n    editor: 'developer',\n    viewer: 'viewer',\n  }\n  return mapping[role]\n}\n"],"mappings":";AAiBO,IAAM,kBAAkB,CAAC,UAAU,UAAU,SAAS,OAAO;AAK7D,IAAM,6BAA6B,CAAC,UAAU,UAAU,OAAO;AAK/D,IAAM,qBAAqB,CAAC,SAAS,SAAS,UAAU,SAAS;AAUjE,IAAM,sBAAqD;AAAA,EAChE,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,OAAO;AAAA,EACP,OAAO;AACT;AAGO,IAAM,yBAA2D;AAAA,EACtE,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,OAAO;AAAA,EACP,OAAO;AACT;AAGO,SAAS,iBAAiB,QAAuB,SAAiC;AACvF,SAAO,oBAAoB,MAAM,KAAK,oBAAoB,OAAO;AACnE;AAGO,SAAS,oBAAoB,QAA0B,SAAoC;AAChG,SAAO,uBAAuB,MAAM,KAAK,uBAAuB,OAAO;AACzE;AAGO,SAAS,0BAA0B,OAAkD;AAC1F,SAAO,OAAO,UAAU,YAAY,2BAA2B,SAAS,KAAgC;AAC1G;AAGO,SAAS,qCAAqC,MAA6D;AAChH,SAAO,SAAS,WAAW,SAAS;AACtC;AAOO,SAAS,qBACd,kBACA,eACsB;AACtB,SAAO,qCAAqC,gBAAgB,IAAI,UAAU,iBAAiB;AAC7F;AAOO,SAAS,6BAA6B,WAA0B,YAAoC;AACzG,SAAO,cAAc,WAAW,CAAC,iBAAiB,YAAY,SAAS;AACzE;AAGO,SAAS,mCAAmC,MAAmD;AACpG,SAAO,SAAS,WAAW,SAAS;AACtC;AAGO,SAAS,2BAA2B,MAA2C;AACpF,QAAM,UAAuD;AAAA,IAC3D,OAAO;AAAA,IACP,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,QAAQ;AAAA,EACV;AACA,SAAO,QAAQ,IAAI;AACrB;","names":[]}

package/dist/{chunk-MFRCM32T.js → chunk-7CTIUCQ4.js}

@@ -185,4 +185,4 @@ export {
   outcomeStatus,
   createAppToolRuntimeExecutor
 };
-//# sourceMappingURL=chunk-MFRCM32T.js.map
+//# sourceMappingURL=chunk-7CTIUCQ4.js.map

package/dist/chunk-7CTIUCQ4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tools/errors.ts","../src/tools/openai.ts","../src/tools/registry.ts","../src/tools/dispatch.ts","../src/tools/runtime.ts"],"sourcesContent":["/** A correctable bad-input error a tool handler throws; the HTTP layer maps it\n *  to a 4xx with the code, the runtime layer to a failed tool_result. So the\n *  agent learns the call failed and can correct, instead of a silent success. */\nexport class ToolInputError extends Error {\n  constructor(\n    public code: string,\n    message: string,\n    public status = 400,\n  ) {\n    super(message)\n    this.name = 'ToolInputError'\n  }\n}\n","import type { AppToolTaxonomy, BuildAppToolsOptions } from './types'\n\n/** The four canonical app-tool names. Stable identifiers the model calls in\n *  both the sandbox (MCP server name) and runtime (function-tool name) paths. */\nexport const APP_TOOL_NAMES = ['submit_proposal', 'schedule_followup', 'render_ui', 'add_citation'] as const\n/** Resolve a valid application tool name from the predefined list of tool names */\nexport type AppToolName = (typeof APP_TOOL_NAMES)[number]\n\nconst NAME_SET = new Set<string>(APP_TOOL_NAMES)\n/** Determine if a string matches a valid application tool name */\nexport function isAppToolName(name: string): name is AppToolName {\n  return NAME_SET.has(name)\n}\n\n/** A minimal OpenAI Chat Completions function-tool shape — structurally\n *  compatible with `@tangle-network/agent-runtime`'s `OpenAIChatTool` without\n *  importing it (keeps this package runtime-free). */\nexport interface OpenAIFunctionTool {\n  type: 'function'\n  function: {\n    name: string\n    description: string\n    parameters: Record<string, unknown>\n  }\n}\n\n/**\n * Build the four app tools in OpenAI function-tool shape. `submit_proposal`'s\n * `type` enum is the product's {@link AppToolTaxonomy.proposalTypes}; the\n * model-facing descriptions and the follow-up priority enum default to the\n * Tangle reference vocabulary and can be retuned via {@link BuildAppToolsOptions}\n * (the tool names + JSON-Schema shapes stay fixed — they are mechanism). Pass\n * the result to the agent-runtime backend's `tools`.\n */\nexport function buildAppToolOpenAITools(\n  taxonomy: AppToolTaxonomy,\n  opts?: BuildAppToolsOptions,\n): OpenAIFunctionTool[] {\n  const d = opts?.descriptions\n  const priorityValues = opts?.priorityValues ?? ['low', 'medium', 'high']\n  const custom: OpenAIFunctionTool[] = (opts?.customTools ?? []).map((t) => ({\n    type: 'function',\n    function: { name: t.name, description: t.description, parameters: t.parameters },\n  }))\n  return [\n    {\n      type: 'function',\n      function: {\n        name: 'submit_proposal',\n        description:\n          d?.submit_proposal ??\n          'Route a regulated or state-changing action to a human for approval (a recommendation, contacting/soliciting a contact, outreach, a record/account change, scheduling). Queues it for a named certified human to approve before it executes.',\n        parameters: {\n          type: 'object',\n          properties: {\n            type: { type: 'string', enum: [...taxonomy.proposalTypes] },\n            title: { type: 'string', description: 'Short label for the approval queue.' },\n            description: { type: 'string', description: 'The full drafted message/recommendation, with sources.' },\n          },\n          required: ['type', 'title'],\n        },\n      },\n    },\n    {\n      type: 'function',\n      function: {\n        name: 'schedule_followup',\n        description:\n          d?.schedule_followup ??\n          'Register a dated cadence step (a reminder, chase, or check-in) on the follow-up calendar. Executes immediately.',\n        parameters: {\n          type: 'object',\n          properties: {\n            title: { type: 'string' },\n            dueDate: { type: 'string', description: 'ISO date YYYY-MM-DD.' },\n            priority: { type: 'string', enum: [...priorityValues] },\n          },\n          required: ['title', 'dueDate'],\n        },\n      },\n    },\n    {\n      type: 'function',\n      function: {\n        name: 'render_ui',\n        description:\n          d?.render_ui ??\n          'Show a generated view live in the workspace. Validates the OpenUI JSON and persists the artifact. Executes immediately.',\n        parameters: {\n          type: 'object',\n          properties: {\n            title: { type: 'string' },\n            schema: { type: 'object', description: 'The OpenUI JSON object.' },\n          },\n          required: ['title', 'schema'],\n        },\n      },\n    },\n    {\n      type: 'function',\n      function: {\n        name: 'add_citation',\n        description:\n          d?.add_citation ??\n          'Anchor a grounding reference: the exact quote from a file backing a figure or claim. Verifies the quote appears in the file. Executes immediately.',\n        parameters: {\n          type: 'object',\n          properties: {\n            path: { type: 'string', description: 'The vault file path.' },\n            quote: { type: 'string', description: 'The exact text from it.' },\n          },\n          required: ['path', 'quote'],\n        },\n      },\n    },\n    ...custom,\n  ]\n}\n","import { isAppToolName } from './openai'\nimport type { AppToolContext } from './types'\nimport type { OpenAIFunctionTool } from './openai'\n\n/**\n * A product-defined app tool — the open registration seam.\n *\n * The four built-ins (`submit_proposal`/`schedule_followup`/`render_ui`/\n * `add_citation`) are mechanism and stay hard-typed. This is how a product adds\n * a fifth+ tool (e.g. gtm-agent's `set_config`) WITHOUT forking the shell: the\n * `name` + JSON-Schema `parameters` are what the model sees, and `execute` is\n * dispatched through the SAME validation/outcome path as the built-ins — a\n * thrown {@link ToolInputError} becomes a correctable 4xx, any other throw an\n * internal error, and a tool call never silently \"succeeds\" without its effect.\n */\nexport interface AppToolDefinition<Args = Record<string, unknown>> {\n  /** Stable identifier the model calls (and the MCP server name). Must not\n   *  collide with a built-in app tool. */\n  name: string\n  /** Model-facing description. */\n  description: string\n  /** JSON-Schema for the parameters (the OpenAI `function.parameters` object). */\n  parameters: Record<string, unknown>\n  /** Default route path the per-turn MCP server / HTTP handler is mounted at.\n   *  Overridable per call via `paths`/`buildHttpMcpServer`. */\n  path?: string\n  /** Fulfil the call; the return value is the tool result the model sees.\n   *  `ctx` is the trusted per-turn identity (never from tool args). */\n  execute: (args: Args, ctx: AppToolContext) => Promise<unknown> | unknown\n}\n\n/**\n * Validate + brand a product tool definition. Throws when the name is empty or\n * collides with a built-in (those are reserved mechanism). Identity otherwise —\n * call it at module scope so a bad definition fails at boot, not first use.\n */\nexport function defineAppTool<Args = Record<string, unknown>>(def: AppToolDefinition<Args>): AppToolDefinition<Args> {\n  const name = def.name?.trim()\n  if (!name) throw new Error('defineAppTool: name is required')\n  if (isAppToolName(name)) throw new Error(`defineAppTool: \"${name}\" is a built-in app tool — choose a different name`)\n  if (typeof def.execute !== 'function') throw new Error(`defineAppTool: \"${name}\" needs an execute() handler`)\n  return def\n}\n\n/** The OpenAI function-tool def for a custom tool — appended to the built-ins by\n *  `buildAppToolOpenAITools`. */\nexport function customToolToOpenAI(def: AppToolDefinition): OpenAIFunctionTool {\n  return { type: 'function', function: { name: def.name, description: def.description, parameters: def.parameters } }\n}\n\n/** Find a registered custom tool by the name the model called. */\nexport function findCustomTool(\n  name: string,\n  tools: readonly AppToolDefinition[] | undefined,\n): AppToolDefinition | undefined {\n  return tools?.find((t) => t.name === name)\n}\n","import { ToolInputError } from './errors'\nimport { isAppToolName } from './openai'\nimport { findCustomTool, type AppToolDefinition } from './registry'\nimport type {\n  AppToolContext,\n  AppToolHandlers,\n  AppToolOutcome,\n  AppToolProducedEvent,\n  AppToolTaxonomy,\n} from './types'\n\n/** Define options for dispatching tools including handlers, taxonomy, custom tools, and approval policies */\nexport interface DispatchOptions {\n  handlers: AppToolHandlers\n  taxonomy: AppToolTaxonomy\n  /** Product-registered tools beyond the four built-ins. A called name that is\n   *  not a built-in is dispatched to the matching {@link AppToolDefinition.execute}\n   *  through this same validation/outcome path. */\n  customTools?: readonly AppToolDefinition[]\n  /** Per-call approval policy. When provided it OVERRIDES the static\n   *  `taxonomy.regulatedTypes` membership check, so products can gate by\n   *  cost threshold, environment, or first-use instead of always/never.\n   *  Fail-closed: a predicate that throws counts as \"approval required\". */\n  needsApproval?: (type: string, args: { title: string; description: string | null }, ctx: AppToolContext) => boolean | Promise<boolean>\n  /** Called at the real side-effect site for proposals (proposal_created) and\n   *  generated views (artifact) so a consumer's completion oracle credits\n   *  persisted state. Omit when produced state isn't tracked. */\n  onProduced?: (event: AppToolProducedEvent) => void\n}\n\n/**\n * The ONE place an app-tool call is validated, dispatched to the product's\n * handler, and turned into an {@link AppToolOutcome} + produced events. Shared\n * by the HTTP route layer and the agent-runtime executor so both paths apply\n * identical validation and identical side effects. A {@link ToolInputError}\n * (bad input the agent can correct) and any other throw both become\n * `{ ok: false }` — a tool call never silently \"succeeds\" without its effect.\n */\nexport async function dispatchAppTool(\n  toolName: string,\n  rawArgs: Record<string, unknown>,\n  ctx: AppToolContext,\n  opts: DispatchOptions,\n): Promise<AppToolOutcome> {\n  try {\n    if (!isAppToolName(toolName)) {\n      const custom = findCustomTool(toolName, opts.customTools)\n      if (!custom) return { ok: false, code: 'unknown_tool', message: `${toolName} is not an app tool.` }\n      // Custom tools own their own arg validation (their execute throws\n      // ToolInputError for correctable input); the outer try/catch maps it.\n      const result = await custom.execute(rawArgs, ctx)\n      return { ok: true, result }\n    }\n\n    if (toolName === 'submit_proposal') {\n      const type = String(rawArgs.type ?? '').trim()\n      const title = String(rawArgs.title ?? '').trim()\n      if (!type || !opts.taxonomy.proposalTypes.includes(type)) {\n        return { ok: false, code: 'invalid_type', message: `type must be one of: ${opts.taxonomy.proposalTypes.join(', ')}.` }\n      }\n      if (!title) return { ok: false, code: 'missing_title', message: 'title is required.' }\n      const description = rawArgs.description == null ? null : String(rawArgs.description)\n      // Approval policy runs BEFORE the handler so the decision can gate the\n      // side effect itself, not merely re-label it afterwards.\n      let regulated = opts.taxonomy.regulatedTypes.includes(type)\n      if (opts.needsApproval) {\n        try {\n          regulated = await opts.needsApproval(type, { title, description }, ctx)\n        } catch {\n          regulated = true // fail-closed: a broken policy means approval required\n        }\n      }\n      const r = await opts.handlers.submitProposal({ type, title, description, regulated }, ctx)\n      // Pass the handler's result through: products with immediate-execute\n      // proposal types return status 'executed' plus their own fields\n      // (e.g. datasetId) — the model must see what actually happened, not a\n      // hard-coded \"queued for approval\".\n      const { proposalId, deduped, status, ...extra } = r\n      const effectiveStatus = status ?? 'queued_for_approval'\n      opts.onProduced?.({\n        type: 'proposal_created',\n        proposalId,\n        title,\n        status: effectiveStatus === 'executed' ? 'executed' : 'pending',\n        content: description ?? undefined,\n      })\n      return { ok: true, result: { ...extra, status: effectiveStatus, proposalId, deduped, regulated } }\n    }\n\n    if (toolName === 'schedule_followup') {\n      const r = await opts.handlers.scheduleFollowup(\n        { title: String(rawArgs.title ?? ''), dueDate: String(rawArgs.dueDate ?? ''), priority: rawArgs.priority as string | undefined },\n        ctx,\n      )\n      return { ok: true, result: { followupId: r.id, dueDate: r.dueDate, deduped: r.deduped } }\n    }\n\n    if (toolName === 'render_ui') {\n      const r = await opts.handlers.renderUi({ title: String(rawArgs.title ?? ''), schema: rawArgs.schema }, ctx)\n      opts.onProduced?.({ type: 'artifact', path: r.path, content: r.content })\n      return { ok: true, result: { path: r.path } }\n    }\n\n    // add_citation\n    const r = await opts.handlers.addCitation(\n      { path: String(rawArgs.path ?? ''), quote: String(rawArgs.quote ?? ''), label: rawArgs.label as string | undefined },\n      ctx,\n    )\n    return { ok: true, result: { citationId: r.citationId, path: r.path } }\n  } catch (err) {\n    if (err instanceof ToolInputError) return { ok: false, code: err.code, message: err.message, status: err.status }\n    return { ok: false, code: 'app_tool_error', message: err instanceof Error ? err.message : String(err), status: 500 }\n  }\n}\n\n/** HTTP status for a failed outcome — the handler's `ToolInputError.status`\n *  when present, else 400 for a validation reject. */\nexport function outcomeStatus(outcome: Extract<AppToolOutcome, { ok: false }>): number {\n  return outcome.status ?? 400\n}\n","import { dispatchAppTool, type DispatchOptions } from './dispatch'\nimport type { AppToolContext, AppToolOutcome } from './types'\n\n/** Executes an app-tool call the model emits on the agent-runtime chat path.\n *  Plug into `runChatThroughRuntime({ appToolExecutor })` (or any loop that\n *  dispatches function tool_calls). */\nexport type AppToolRuntimeExecutor = (call: {\n  toolName: string\n  args: Record<string, unknown>\n}) => Promise<AppToolOutcome>\n\n/** Define options for executing runtime tasks with a trusted per-turn context */\nexport interface RuntimeExecutorOptions extends DispatchOptions {\n  /** The trusted per-turn context — supplied directly (not from headers), since\n   *  the runtime path has no HTTP request. */\n  ctx: AppToolContext\n}\n\n/**\n * Build the runtime executor for one turn. The agent-runtime backend must also\n * advertise the tools (`buildAppToolOpenAITools(taxonomy)` on the backend's\n * `tools`) for the model to call them; this executor fulfils each call against\n * the product's handlers and emits produced events via `opts.onProduced`.\n */\nexport function createAppToolRuntimeExecutor(opts: RuntimeExecutorOptions): AppToolRuntimeExecutor {\n  return ({ toolName, args }) => dispatchAppTool(toolName, args, opts.ctx, opts)\n}\n"],"mappings":"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","names":["r"]}

package/dist/{chunk-6KVH5SP5.js → chunk-7YW6EBDX.js}

@@ -2,7 +2,7 @@ import {
   interactionFromWireRequest,
   isSafeInteractionFieldKey,
   questionInteractionContentSignature
-} from "./chunk-XAWFPMAR.js";
+} from "./chunk-YKOM4ZLQ.js";
 
 // src/interactions/sidecar.ts
 var DEFAULT_TIMEOUT_MS = 5e3;
@@ -304,4 +304,4 @@ export {
   mapInteractionRespondFailure,
   createInteractionAnswerRoute
 };
-//# sourceMappingURL=chunk-6KVH5SP5.js.map
+//# sourceMappingURL=chunk-7YW6EBDX.js.map

package/dist/chunk-7YW6EBDX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/interactions/sidecar.ts","../src/interactions/route.ts"],"sourcesContent":["/**\n * Server-side client for the sandbox sidecar's generic interaction routes\n * (`GET/POST {runtimeUrl}/agents/sessions/{sessionId}/interactions`). The\n * pinned sandbox SDK exposes only the question-specific `session().answer()`\n * convenience; these raw calls are backend-agnostic (question/permission/plan,\n * any harness) and carry explicit outcomes (accepted/declined).\n *\n * Server-only: the sidecar bearer must never reach browser code. The caller\n * supplies the connection as a structural value (runtime URL + bearer +\n * session id) — no sandbox-SDK import, so any box-resolution strategy works.\n */\n\nimport type { InteractionData, InteractionOutcome, InteractionRequestWire } from './contract'\n\n/** Describe error details including code, message, and upstream HTTP status for sidecar interactions */\nexport interface SidecarInteractionsError {\n  code: string\n  message: string\n  /** Upstream HTTP status; 0 when the sidecar was unreachable. */\n  status: number\n}\n\n/** Represent the outcome of sidecar interactions with success or error details */\nexport type SidecarInteractionsResult<T> =\n  | { succeeded: true; value: T }\n  | { succeeded: false; error: SidecarInteractionsError }\n\n/** Where and how to reach one session's interaction registry. */\nexport interface SidecarInteractionsConnection {\n  runtimeUrl: string\n  authToken?: string\n  /** The sidecar agent-session id (the chat thread's session). */\n  sessionId: string\n  /** Request deadline. A pending interaction means the box is up and the\n   *  sidecar responsive; a short default keeps a wedged runtime from stalling\n   *  the answering request. */\n  timeoutMs?: number\n  /** Injection seam for tests; defaults to global fetch. */\n  fetchImpl?: typeof fetch\n}\n\nconst DEFAULT_TIMEOUT_MS = 5_000\n\n/** Strips bearer tokens / key material before an upstream message is logged\n *  or surfaced. */\nfunction sanitizeUpstreamMessage(input: unknown): string {\n  const message = input instanceof Error ? input.message : String(input)\n  return message\n    .replace(/Bearer\\s+[^\\s]+/gi, 'Bearer [redacted]')\n    .replace(/\\b(?:sk|pk|tc)[_-][A-Za-z0-9_-]{8,}\\b/g, '[redacted-key]')\n}\n\nasync function interactionsFetch(\n  connection: SidecarInteractionsConnection,\n  init: { method: 'GET' } | { method: 'POST'; body: Record<string, unknown> },\n): Promise<SidecarInteractionsResult<Record<string, unknown>>> {\n  const doFetch = connection.fetchImpl ?? fetch\n  const url = `${connection.runtimeUrl.replace(/\\/$/, '')}/agents/sessions/${encodeURIComponent(connection.sessionId)}/interactions`\n  let response: Response\n  try {\n    response = await doFetch(url, {\n      method: init.method,\n      headers: {\n        ...(connection.authToken ? { Authorization: `Bearer ${connection.authToken}` } : {}),\n        ...(init.method === 'POST' ? { 'Content-Type': 'application/json' } : {}),\n      },\n      ...(init.method === 'POST' ? { body: JSON.stringify(init.body) } : {}),\n      signal: AbortSignal.timeout(connection.timeoutMs ?? DEFAULT_TIMEOUT_MS),\n    })\n  } catch (err) {\n    return {\n      succeeded: false,\n      error: { code: 'UPSTREAM_UNREACHABLE', message: sanitizeUpstreamMessage(err), status: 0 },\n    }\n  }\n  const raw = await response.text().catch(() => '')\n  let parsed: Record<string, unknown> = {}\n  try {\n    parsed = raw ? (JSON.parse(raw) as Record<string, unknown>) : {}\n  } catch {\n    // Non-JSON error bodies (proxy 502 pages) fall through to the status check.\n  }\n  if (!response.ok) {\n    const upstreamError = (parsed.error ?? {}) as { code?: unknown; message?: unknown }\n    return {\n      succeeded: false,\n      error: {\n        code: typeof upstreamError.code === 'string' && upstreamError.code ? upstreamError.code : 'UPSTREAM_ERROR',\n        message: sanitizeUpstreamMessage(\n          typeof upstreamError.message === 'string' && upstreamError.message\n            ? upstreamError.message\n            : `sidecar interactions ${init.method} failed (${response.status})`,\n        ),\n        status: response.status,\n      },\n    }\n  }\n  return { succeeded: true, value: parsed }\n}\n\n/** Outstanding (unanswered) interactions for the session — the sidecar's\n *  registry is authoritative, so this is the reconnect/reload source of truth. */\nexport async function listSessionInteractions(\n  connection: SidecarInteractionsConnection,\n): Promise<SidecarInteractionsResult<InteractionRequestWire[]>> {\n  const result = await interactionsFetch(connection, { method: 'GET' })\n  if (!result.succeeded) return result\n  const data = result.value.data as { interactions?: unknown } | undefined\n  if (!Array.isArray(data?.interactions)) {\n    return {\n      succeeded: false,\n      error: { code: 'MALFORMED_RESPONSE', message: 'sidecar list returned no interactions array', status: 200 },\n    }\n  }\n  return { succeeded: true, value: data.interactions as InteractionRequestWire[] }\n}\n\n/** Resolves one interaction. `data` is required by the sidecar only for\n *  `accepted` outcomes and is validated fail-closed against the answerSpec\n *  (400 INVALID_INTERACTION_ANSWER on mismatch). */\nexport async function respondToSessionInteraction(\n  connection: SidecarInteractionsConnection,\n  response: { id: string; outcome: InteractionOutcome; data?: InteractionData },\n): Promise<SidecarInteractionsResult<void>> {\n  const result = await interactionsFetch(connection, {\n    method: 'POST',\n    body: {\n      id: response.id,\n      outcome: response.outcome,\n      ...(response.data ? { data: response.data } : {}),\n    },\n  })\n  if (!result.succeeded) return result\n  return { succeeded: true, value: undefined }\n}\n","/**\n * Framework-neutral interaction-answer endpoints, lifted out of the per-app\n * route files (gtm `api.chat.interactions`, legal `api.chat.interactions`,\n * tax `api.sessions.$id.interactions` — three byte-similar forks):\n *\n *   list(request)   — GET: outstanding asks for a live turn (reload restore)\n *   answer(request) — POST `{ id, outcome, data? }`: resolve one ask\n *\n * The product supplies ONE seam, `resolveConnection`: authenticate the caller,\n * authorize the thread/session, and resolve the sidecar connection. Everything\n * behind the seam is mechanism the forks kept re-fixing:\n *\n *   - body validation (safe field keys, typed values),\n *   - sidecar error → client contract mapping (every \"the ask is gone\" shape\n *     becomes 410 so the card flips to its expired state),\n *   - duplicate resolution: after answering, every other outstanding ask with\n *     the same content signature (a re-emitted duplicate) gets the same answer,\n *   - unblock verification: re-list and fail loud (503 INTERACTION_STILL_PENDING)\n *     when the sidecar accepted the POST but the ask is still open,\n *   - best-effort list: sidecar failures return `{ interactions: [],\n *     unavailable }` so a reload restore never breaks the live stream.\n *\n * Handlers return web-standard `Response`s (Workers, Node 18+, Deno) — no\n * router import anywhere.\n */\n\nimport {\n  interactionFromWireRequest,\n  isSafeInteractionFieldKey,\n  questionInteractionContentSignature,\n  type InteractionData,\n  type InteractionRequestWire,\n} from './contract'\nimport {\n  listSessionInteractions,\n  respondToSessionInteraction,\n  type SidecarInteractionsConnection,\n  type SidecarInteractionsError,\n} from './sidecar'\n\n// A client resolves an ask by answering (`accepted`) or refusing (`declined`).\n// Withdrawal (`cancelled`) is an agent/broker outcome delivered via the\n// `interaction.cancel` event, never a client POST, so it is not accepted here.\n/** Define possible outcomes for an interaction client as accepted or declined */\nexport type InteractionClientOutcome = 'accepted' | 'declined'\n\n/** Validate interaction answer body and return success with data or failure with error message */\nexport type InteractionAnswerBodyValidation =\n  | { ok: true; id: string; outcome: InteractionClientOutcome; data?: InteractionData }\n  | { ok: false; error: string }\n\n/** Validates the client POST body: `{ id, outcome, data? }` with\n *  identifier-safe field keys and primitive/string-array values only. */\nexport function validateInteractionAnswerBody(body: Record<string, unknown>): InteractionAnswerBodyValidation {\n  const id = typeof body.id === 'string' && body.id ? body.id : null\n  if (!id) return { ok: false, error: 'Missing interaction id' }\n  const outcome = body.outcome\n  if (outcome !== 'accepted' && outcome !== 'declined') {\n    return { ok: false, error: 'Invalid outcome: expected accepted or declined' }\n  }\n  if (body.data === undefined) return { ok: true, id, outcome }\n  if (!body.data || typeof body.data !== 'object' || Array.isArray(body.data)) {\n    return { ok: false, error: 'Invalid data: expected an object of field values' }\n  }\n  const data: InteractionData = {}\n  for (const [key, value] of Object.entries(body.data)) {\n    if (!isSafeInteractionFieldKey(key)) {\n      return { ok: false, error: 'Invalid data: field names must contain only letters, numbers, underscores, or hyphens' }\n    }\n    const validValue =\n      typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' ||\n      (Array.isArray(value) && value.every((item) => typeof item === 'string'))\n    if (!validValue) {\n      return { ok: false, error: 'Invalid data: field values must be strings, numbers, booleans, or string arrays' }\n    }\n    data[key] = value as InteractionData[string]\n  }\n  return { ok: true, id, outcome, data }\n}\n\n/** Provide logging methods for warnings and errors in interaction routes */\nexport type InteractionRouteLogger = Pick<Console, 'warn' | 'error'>\n\n/** Sidecar error → the client-actionable contract. Every \"the ask is gone\"\n *  shape maps to 410 so the card flips to its expired state — a raw 404/409\n *  must never surface. */\nexport function mapInteractionRespondFailure(\n  error: SidecarInteractionsError,\n  logger: InteractionRouteLogger = console,\n): Response {\n  if (error.code === 'INVALID_INTERACTION_ANSWER') {\n    return Response.json(\n      { code: 'INVALID_INTERACTION_ANSWER', error: 'This question needs an answer from the card above — pick one of the listed options.' },\n      { status: 400 },\n    )\n  }\n  if (error.status === 404) {\n    return Response.json(\n      { code: 'INTERACTION_EXPIRED', error: 'This question is no longer waiting for an answer.' },\n      { status: 410 },\n    )\n  }\n  if (error.status === 501 || error.code === 'NOT_IMPLEMENTED') {\n    return Response.json(\n      { code: 'INTERACTIONS_UNSUPPORTED', error: 'This agent backend cannot accept answers this way.' },\n      { status: 501 },\n    )\n  }\n  logger.error('[interactions] respond failed:', error)\n  return Response.json(\n    { code: 'INTERACTION_UPSTREAM_FAILED', error: 'Could not reach the agent. Try again.' },\n    { status: 503 },\n  )\n}\n\n/** The product seam's verdict for one request. `response` short-circuits with\n *  a product-authored Response (401/404/429…); `unavailable` means the caller\n *  is fine but the sandbox runtime is not reachable — the factory shapes that\n *  per intent (empty list for `list`, 503 for `answer`). */\nexport type InteractionConnectionResolution =\n  | { ok: true; connection: SidecarInteractionsConnection }\n  | { ok: false; response: Response }\n  | { ok: false; unavailable: string }\n\n/** Define arguments required to resolve interaction connections based on request and intent */\nexport interface ResolveInteractionConnectionArgs {\n  request: Request\n  intent: 'list' | 'answer'\n  /** The parsed, validated POST body (answer intent only) so the resolver can\n   *  read product routing fields (workspaceId/threadId) without re-parsing. */\n  body?: Record<string, unknown>\n}\n\n/** Describe the arguments provided before processing an interaction answer including request, body, and connection details */\nexport interface BeforeInteractionAnswerArgs {\n  request: Request\n  /** Original parsed body, including product routing fields. */\n  body: Record<string, unknown>\n  /** Shared validation result; products never need to parse the answer again. */\n  answer: Extract<InteractionAnswerBodyValidation, { ok: true }>\n  connection: SidecarInteractionsConnection\n  /** The route's single authoritative pre-answer sidecar snapshot. */\n  outstanding: InteractionRequestWire[]\n  answeredRequest?: InteractionRequestWire\n  /** Content-identical questions that the shared route will also answer. */\n  duplicateRequests: InteractionRequestWire[]\n}\n\n/** Define arguments for durable interaction routes including a stable caller-created attempt key */\nexport interface DurableInteractionRouteArgs extends BeforeInteractionAnswerArgs {\n  /** Caller-created opaque identifier, stable across an ambiguous retry. */\n  attemptKey: string\n}\n\n/** Crash-recoverable persistence lifecycle for the answer route. The product\n * binds this structural port to `/durable-chat` (or an equivalent durable\n * store). Existing `beforeAnswer` behavior remains independent and unchanged. */\nexport interface DurableInteractionRoutePersistence<TPrepared = unknown> {\n  guarantee: 'reconciled' | 'best-effort'\n  prepare(args: DurableInteractionRouteArgs): TPrepared | Promise<TPrepared>\n  /** Resolve an ambiguous retry (for example, the sidecar says the ask is\n   * already gone). Only `settled:true` permits the route to report success. */\n  reconcile(args: DurableInteractionRouteArgs & { prepared: TPrepared }):\n    | { settled: boolean }\n    | Promise<{ settled: boolean }>\n  /** Record the authority acknowledgement before terminal projection. */\n  acknowledge(args: DurableInteractionRouteArgs & {\n    prepared: TPrepared\n    duplicateIds: string[]\n  }): void | Promise<void>\n  /** Idempotently materialize terminal status and accepted values. */\n  finalize(args: DurableInteractionRouteArgs & {\n    prepared: TPrepared\n    duplicateIds: string[]\n  }): void | Promise<void>\n  fail?(args: DurableInteractionRouteArgs & { prepared: TPrepared; error: unknown }): void | Promise<void>\n}\n\n/** Define options to authenticate, authorize, and manage persistence for interaction answer routes */\nexport interface InteractionAnswerRouteOptions {\n  /** Authenticate + authorize the caller and resolve the sidecar connection.\n   *  This is the only product-supplied step: session auth, workspace/thread\n   *  access, rate limiting, and box resolution all live here. */\n  resolveConnection: (args: ResolveInteractionConnectionArgs) => Promise<InteractionConnectionResolution>\n  /** Product persistence seam that runs before the answer can unblock and\n   * finalize the agent turn. A throw aborts the request before any answer POST. */\n  beforeAnswer?: (args: BeforeInteractionAnswerArgs) => void | Promise<void>\n  /** Additive crash-recoverable settlement. When configured, POST requires an\n   * `attemptKey`; accepted values are finalized only after sidecar ack. */\n  durable?: DurableInteractionRoutePersistence\n  logger?: InteractionRouteLogger\n}\n\n/** Define routes to list outstanding interactions and resolve answers for live turns */\nexport interface InteractionAnswerRoute {\n  /** GET — outstanding interactions for a live turn. Failures return an empty\n   *  list with an explicit `unavailable` code: the caller is a best-effort\n   *  reload restore, and the live/replayed stream must stay untouched when the\n   *  sidecar cannot answer. */\n  list: (request: Request) => Promise<Response>\n  /** POST `{ id, outcome, data?, ...productFields }` — resolve one ask, answer\n   *  content-identical duplicates the same way, then re-list to prove the run\n   *  actually unblocked. */\n  answer: (request: Request) => Promise<Response>\n}\n\n/** Create an interaction answer route that handles listing and resolving interaction requests */\nexport function createInteractionAnswerRoute(options: InteractionAnswerRouteOptions): InteractionAnswerRoute {\n  const logger = options.logger ?? console\n\n  async function list(request: Request): Promise<Response> {\n    const resolution = await options.resolveConnection({ request, intent: 'list' })\n    if (!resolution.ok) {\n      if ('response' in resolution) return resolution.response\n      return Response.json({ interactions: [], unavailable: resolution.unavailable })\n    }\n    const result = await listSessionInteractions(resolution.connection)\n    if (!result.succeeded) {\n      logger.warn('[interactions] list failed:', result.error)\n      return Response.json({ interactions: [], unavailable: result.error.code })\n    }\n    return Response.json({ interactions: result.value })\n  }\n\n  async function answer(request: Request): Promise<Response> {\n    const body = await request.json().catch(() => null) as Record<string, unknown> | null\n    if (!body || typeof body !== 'object' || Array.isArray(body)) {\n      return Response.json({ error: 'Invalid JSON body' }, { status: 400 })\n    }\n    const validation = validateInteractionAnswerBody(body)\n    if (!validation.ok) return Response.json({ error: validation.error }, { status: 400 })\n    const attemptKey = typeof body.attemptKey === 'string' ? body.attemptKey.trim() : ''\n    if (options.durable && !attemptKey) {\n      return Response.json({ error: 'Missing attemptKey for durable interaction answer' }, { status: 400 })\n    }\n\n    const resolution = await options.resolveConnection({ request, intent: 'answer', body })\n    if (!resolution.ok) {\n      if ('response' in resolution) return resolution.response\n      return mapInteractionRespondFailure(\n        { code: resolution.unavailable, message: 'sandbox runtime unavailable', status: 0 },\n        logger,\n      )\n    }\n    const connection = resolution.connection\n    const answerPayload = {\n      outcome: validation.outcome,\n      ...(validation.data ? { data: validation.data } : {}),\n    }\n\n    // Snapshot the answered ask's content signature BEFORE resolving it, so any\n    // content-identical duplicates still outstanding afterwards (the agent may\n    // have re-emitted the same question N times) can be answered the same way.\n    const before = await listSessionInteractions(connection)\n    if (!before.succeeded && (options.beforeAnswer || options.durable)) {\n      return mapInteractionRespondFailure(before.error, logger)\n    }\n    const answeredRequest = before.succeeded ? before.value.find((item) => item.id === validation.id) : undefined\n    if (options.beforeAnswer && !options.durable && !answeredRequest) {\n      return mapInteractionRespondFailure(\n        { code: 'NOT_FOUND', message: 'interaction not found', status: 404 },\n        logger,\n      )\n    }\n    const answeredSignature = answeredRequest\n      ? questionInteractionContentSignature(interactionFromWireRequest(answeredRequest))\n      : null\n    const duplicateRequests = before.succeeded && answeredSignature\n      ? before.value.filter((item) => item.id !== validation.id && (\n          questionInteractionContentSignature(interactionFromWireRequest(item)) === answeredSignature\n        ))\n      : []\n\n    const lifecycleArgs: BeforeInteractionAnswerArgs = {\n      request,\n      body,\n      answer: validation,\n      connection,\n      outstanding: before.succeeded ? before.value : [],\n      ...(answeredRequest ? { answeredRequest } : {}),\n      duplicateRequests,\n    }\n\n    if (options.beforeAnswer && answeredRequest) {\n      try {\n        await options.beforeAnswer(lifecycleArgs)\n      } catch (error) {\n        logger.error('[interactions] beforeAnswer failed:', error)\n        return Response.json(\n          { code: 'INTERACTION_BEFORE_ANSWER_FAILED', error: 'Could not save the answer. Try again.' },\n          { status: 503 },\n        )\n      }\n    }\n\n    let prepared: unknown\n    const durableArgs = options.durable\n      ? { ...lifecycleArgs, attemptKey }\n      : null\n    if (options.durable && durableArgs) {\n      try {\n        prepared = await options.durable.prepare(durableArgs)\n      } catch (error) {\n        logger.error('[interactions] durable prepare failed:', error)\n        return Response.json(\n          { code: 'INTERACTION_PREPARE_FAILED', error: 'Could not prepare the answer. Try again.' },\n          { status: 503 },\n        )\n      }\n      if (!answeredRequest) {\n        let reconciled: { settled: boolean }\n        try {\n          reconciled = await options.durable.reconcile({ ...durableArgs, prepared })\n        } catch (error) {\n          logger.error('[interactions] durable reconcile failed:', error)\n          reconciled = { settled: false }\n        }\n        if (reconciled.settled) return Response.json({ ok: true, idempotent: true })\n        return Response.json(\n          { code: 'INTERACTION_RECONCILIATION_PENDING', error: 'The answer status is still being checked. Retry with the same attempt.' },\n          { status: 503 },\n        )\n      }\n    }\n\n    const result = await respondToSessionInteraction(connection, { id: validation.id, ...answerPayload })\n    if (!result.succeeded) {\n      if (options.durable && durableArgs) {\n        let reconciled: { settled: boolean }\n        try {\n          reconciled = await options.durable.reconcile({ ...durableArgs, prepared })\n        } catch {\n          reconciled = { settled: false }\n        }\n        if (reconciled.settled) return Response.json({ ok: true, idempotent: true })\n        if (result.error.status === 404) {\n          return Response.json(\n            { code: 'INTERACTION_RECONCILIATION_PENDING', error: 'The answer status is still being checked. Retry with the same attempt.' },\n            { status: 503 },\n          )\n        }\n        try {\n          await options.durable.fail?.({ ...durableArgs, prepared, error: result.error })\n        } catch {\n          // The upstream failure remains authoritative; a persistence cleanup\n          // failure must not replace its client-facing mapping.\n        }\n      }\n      return mapInteractionRespondFailure(result.error, logger)\n    }\n\n    let remaining = await listSessionInteractions(connection)\n    const acknowledgedDuplicateIds: string[] = []\n    if (remaining.succeeded && answeredSignature) {\n      const remainingDuplicates = remaining.value.filter((item) => {\n        if (item.id === validation.id) return false\n        return questionInteractionContentSignature(interactionFromWireRequest(item)) === answeredSignature\n      })\n      for (const duplicate of remainingDuplicates) {\n        const duplicateResult = await respondToSessionInteraction(connection, { id: duplicate.id, ...answerPayload })\n        if (!duplicateResult.succeeded) break\n        acknowledgedDuplicateIds.push(duplicate.id)\n      }\n      if (remainingDuplicates.length > 0) remaining = await listSessionInteractions(connection)\n    }\n\n    // Prove the run actually unblocked: neither the answered id nor any\n    // content-duplicate may still be outstanding. If one is, the sidecar\n    // accepted the POST but did not release the run — report it rather than\n    // tell the user it was answered.\n    if (remaining.succeeded && remaining.value.some((item) => item.id === validation.id || (\n      answeredSignature && questionInteractionContentSignature(interactionFromWireRequest(item)) === answeredSignature\n    ))) {\n      logger.error('[interactions] respond returned ok but interaction is still pending:', {\n        sessionId: connection.sessionId,\n        interactionId: validation.id,\n      })\n      return Response.json(\n        { code: 'INTERACTION_STILL_PENDING', error: 'The agent did not accept the answer. Try answering again.' },\n        { status: 503 },\n      )\n    }\n\n    if (options.durable && durableArgs) {\n      try {\n        await options.durable.acknowledge({\n          ...durableArgs,\n          prepared,\n          duplicateIds: acknowledgedDuplicateIds,\n        })\n        await options.durable.finalize({\n          ...durableArgs,\n          prepared,\n          duplicateIds: acknowledgedDuplicateIds,\n        })\n      } catch (error) {\n        logger.error('[interactions] durable finalize failed:', error)\n        return Response.json(\n          { code: 'INTERACTION_FINALIZE_FAILED', error: 'The answer was accepted but is still being saved. Retry to reconcile it.' },\n          { status: 503 },\n        )\n      }\n    }\n\n    return Response.json({ ok: true })\n  }\n\n  return { list, answer }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-ZXNXAQAH.js → chunk-AP2UXKUK.js}

@@ -66,4 +66,4 @@ export {
   buildKnowledgeRequirements,
   deriveSignals
 };
-//# sourceMappingURL=chunk-ZXNXAQAH.js.map
+//# sourceMappingURL=chunk-AP2UXKUK.js.map

package/dist/chunk-AP2UXKUK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/knowledge/index.ts"],"sourcesContent":["/**\n * Declarative knowledge-requirement gate.\n *\n * Every agent product hand-rolls the same pair: a `buildXKnowledgeRequirements`\n * declaring the requirements that gate its control loop, and a\n * `deriveXRuntimeKnowledge` that scores each one from workspace state. Across\n * the fleet those derives are uniformly \"is a config field set\" / \"are there\n * >= N rows in table T (optionally with a status filter)\" / \"any/all of the\n * above\" — data, not logic. This module makes both DATA: a spec list with\n * declarative `satisfiedBy` rules, plus a per-spec `derive` escape hatch for\n * the rare rule a declarative form can't express (e.g. an aggregate over a\n * JSON column).\n *\n * Substrate-free: the only seam is `KnowledgeStateAccessor` (a config lookup +\n * a row count), which the consumer's backend — or `agent-app/preset-cloudflare`\n * — implements. Emits `@tangle-network/agent-eval`'s `KnowledgeRequirement[]`,\n * exactly what the agent-runtime control loop consumes.\n */\n\nimport type {\n  KnowledgeAcquisitionMode,\n  KnowledgeFreshness,\n  KnowledgeImportance,\n  KnowledgeRequirement,\n  KnowledgeRequirementCategory,\n  KnowledgeSensitivity,\n} from '@tangle-network/agent-eval'\n\n/** A declarative rule for satisfying a requirement from workspace state. */\nexport type SatisfiedByRule =\n  /** A workspace-config field (dot-path) is set. `nonEmpty` requires a\n   *  non-empty array/string rather than mere presence. */\n  | { config: string; nonEmpty?: boolean }\n  /** At least `minRows` (default 1) rows exist in `table` for the workspace,\n   *  optionally filtered to `statusIn`. `where` names the workspace fk column\n   *  the accessor scopes on (default: the accessor's convention). */\n  | { table: string; where?: string; statusIn?: string[]; minRows?: number }\n  | { anyOf: SatisfiedByRule[] }\n  | { allOf: SatisfiedByRule[] }\n\n/** Define the criteria and conditions required to satisfy a specific knowledge requirement */\nexport interface KnowledgeRequirementSpec {\n  id: string\n  description: string\n  category: KnowledgeRequirementCategory\n  acquisitionMode: KnowledgeAcquisitionMode\n  importance?: KnowledgeImportance\n  freshness?: KnowledgeFreshness\n  sensitivity?: KnowledgeSensitivity\n  confidenceNeeded?: number\n  requiredFor?: string[]\n  /** The data path — evaluated against the `KnowledgeStateAccessor`. */\n  satisfiedBy?: SatisfiedByRule\n  /** The escape hatch — a code derive for what a rule can't express. Wins\n   *  over `satisfiedBy` when both are present. Returns confidence in [0, 1]. */\n  derive?: (ctx: KnowledgeStateAccessor) => number | Promise<number>\n  /** Evidence id attached when satisfied (default: a description of the rule). */\n  evidence?: string\n}\n\n/** The single seam a backend implements. `preset-cloudflare` provides a D1\n *  implementation; a custom stack supplies its own. */\nexport interface KnowledgeStateAccessor {\n  /** Resolve a workspace-config field value (dot-path), or undefined. */\n  config: (path: string) => unknown\n  /** Count rows in `table` for the active workspace, optionally status-filtered. */\n  count: (query: { table: string; where?: string; statusIn?: string[] }) => number | Promise<number>\n}\n\n/** Define a signal representing knowledge with confidence level and optional supporting evidence */\nexport interface KnowledgeSignal {\n  confidence: number\n  evidence?: string\n}\n\nfunction clamp(value: number): number {\n  if (!Number.isFinite(value)) return 0\n  if (value < 0) return 0\n  if (value > 1) return 1\n  return value\n}\n\n/**\n * Map specs -> the runtime's `KnowledgeRequirement[]`, folding in per-spec\n * confidence from `signals` (default 0). Pure + sync: an eval harness can pass\n * hand-authored signals; production passes the output of {@link deriveSignals}.\n */\nexport function buildKnowledgeRequirements(\n  specs: KnowledgeRequirementSpec[],\n  signals: Record<string, KnowledgeSignal> = {},\n): KnowledgeRequirement[] {\n  return specs.map((spec) => {\n    const signal = signals[spec.id]\n    return {\n      id: spec.id,\n      description: spec.description,\n      requiredFor: spec.requiredFor ?? [],\n      category: spec.category,\n      acquisitionMode: spec.acquisitionMode,\n      importance: spec.importance ?? 'blocking',\n      freshness: spec.freshness ?? 'static',\n      sensitivity: spec.sensitivity ?? 'private',\n      confidenceNeeded: spec.confidenceNeeded ?? 1,\n      currentConfidence: clamp(signal?.confidence ?? 0),\n      evidenceIds: signal?.evidence ? [signal.evidence] : [],\n      fallbackPolicy: spec.acquisitionMode === 'ask_user' ? 'ask' : 'block',\n    }\n  })\n}\n\n/**\n * Score every spec from workspace state. `derive` (code) wins; otherwise the\n * declarative `satisfiedBy` rule is evaluated through the accessor; a spec with\n * neither scores 0 (an acquisition gate, e.g. `search_web`).\n */\nexport async function deriveSignals(\n  specs: KnowledgeRequirementSpec[],\n  ctx: KnowledgeStateAccessor,\n): Promise<Record<string, KnowledgeSignal>> {\n  const out: Record<string, KnowledgeSignal> = {}\n  for (const spec of specs) {\n    if (spec.derive) {\n      out[spec.id] = { confidence: clamp(await spec.derive(ctx)), evidence: spec.evidence }\n    } else if (spec.satisfiedBy) {\n      const ok = await evalRule(spec.satisfiedBy, ctx)\n      out[spec.id] = ok\n        ? { confidence: 1, evidence: spec.evidence ?? describeRule(spec.satisfiedBy) }\n        : { confidence: 0 }\n    } else {\n      out[spec.id] = { confidence: 0 }\n    }\n  }\n  return out\n}\n\nasync function evalRule(rule: SatisfiedByRule, ctx: KnowledgeStateAccessor): Promise<boolean> {\n  if ('anyOf' in rule) {\n    for (const sub of rule.anyOf) if (await evalRule(sub, ctx)) return true\n    return false\n  }\n  if ('allOf' in rule) {\n    for (const sub of rule.allOf) if (!(await evalRule(sub, ctx))) return false\n    return true\n  }\n  if ('config' in rule) {\n    const value = ctx.config(rule.config)\n    if (rule.nonEmpty) return Array.isArray(value) ? value.length > 0 : value != null && value !== ''\n    return value != null && value !== '' && value !== false\n  }\n  const rows = await ctx.count({ table: rule.table, where: rule.where, statusIn: rule.statusIn })\n  return rows >= (rule.minRows ?? 1)\n}\n\nfunction describeRule(rule: SatisfiedByRule): string {\n  if ('anyOf' in rule) return `anyOf(${rule.anyOf.map(describeRule).join(',')})`\n  if ('allOf' in rule) return `allOf(${rule.allOf.map(describeRule).join(',')})`\n  if ('config' in rule) return `config:${rule.config}`\n  return `${rule.table}${rule.statusIn ? `[${rule.statusIn.join('|')}]` : ''}>=${rule.minRows ?? 1}`\n}\n"],"mappings":";AA2EA,SAAS,MAAM,OAAuB;AACpC,MAAI,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACpC,MAAI,QAAQ,EAAG,QAAO;AACtB,MAAI,QAAQ,EAAG,QAAO;AACtB,SAAO;AACT;AAOO,SAAS,2BACd,OACA,UAA2C,CAAC,GACpB;AACxB,SAAO,MAAM,IAAI,CAAC,SAAS;AACzB,UAAM,SAAS,QAAQ,KAAK,EAAE;AAC9B,WAAO;AAAA,MACL,IAAI,KAAK;AAAA,MACT,aAAa,KAAK;AAAA,MAClB,aAAa,KAAK,eAAe,CAAC;AAAA,MAClC,UAAU,KAAK;AAAA,MACf,iBAAiB,KAAK;AAAA,MACtB,YAAY,KAAK,cAAc;AAAA,MAC/B,WAAW,KAAK,aAAa;AAAA,MAC7B,aAAa,KAAK,eAAe;AAAA,MACjC,kBAAkB,KAAK,oBAAoB;AAAA,MAC3C,mBAAmB,MAAM,QAAQ,cAAc,CAAC;AAAA,MAChD,aAAa,QAAQ,WAAW,CAAC,OAAO,QAAQ,IAAI,CAAC;AAAA,MACrD,gBAAgB,KAAK,oBAAoB,aAAa,QAAQ;AAAA,IAChE;AAAA,EACF,CAAC;AACH;AAOA,eAAsB,cACpB,OACA,KAC0C;AAC1C,QAAM,MAAuC,CAAC;AAC9C,aAAW,QAAQ,OAAO;AACxB,QAAI,KAAK,QAAQ;AACf,UAAI,KAAK,EAAE,IAAI,EAAE,YAAY,MAAM,MAAM,KAAK,OAAO,GAAG,CAAC,GAAG,UAAU,KAAK,SAAS;AAAA,IACtF,WAAW,KAAK,aAAa;AAC3B,YAAM,KAAK,MAAM,SAAS,KAAK,aAAa,GAAG;AAC/C,UAAI,KAAK,EAAE,IAAI,KACX,EAAE,YAAY,GAAG,UAAU,KAAK,YAAY,aAAa,KAAK,WAAW,EAAE,IAC3E,EAAE,YAAY,EAAE;AAAA,IACtB,OAAO;AACL,UAAI,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE;AAAA,IACjC;AAAA,EACF;AACA,SAAO;AACT;AAEA,eAAe,SAAS,MAAuB,KAA+C;AAC5F,MAAI,WAAW,MAAM;AACnB,eAAW,OAAO,KAAK,MAAO,KAAI,MAAM,SAAS,KAAK,GAAG,EAAG,QAAO;AACnE,WAAO;AAAA,EACT;AACA,MAAI,WAAW,MAAM;AACnB,eAAW,OAAO,KAAK,MAAO,KAAI,CAAE,MAAM,SAAS,KAAK,GAAG,EAAI,QAAO;AACtE,WAAO;AAAA,EACT;AACA,MAAI,YAAY,MAAM;AACpB,UAAM,QAAQ,IAAI,OAAO,KAAK,MAAM;AACpC,QAAI,KAAK,SAAU,QAAO,MAAM,QAAQ,KAAK,IAAI,MAAM,SAAS,IAAI,SAAS,QAAQ,UAAU;AAC/F,WAAO,SAAS,QAAQ,UAAU,MAAM,UAAU;AAAA,EACpD;AACA,QAAM,OAAO,MAAM,IAAI,MAAM,EAAE,OAAO,KAAK,OAAO,OAAO,KAAK,OAAO,UAAU,KAAK,SAAS,CAAC;AAC9F,SAAO,SAAS,KAAK,WAAW;AAClC;AAEA,SAAS,aAAa,MAA+B;AACnD,MAAI,WAAW,KAAM,QAAO,SAAS,KAAK,MAAM,IAAI,YAAY,EAAE,KAAK,GAAG,CAAC;AAC3E,MAAI,WAAW,KAAM,QAAO,SAAS,KAAK,MAAM,IAAI,YAAY,EAAE,KAAK,GAAG,CAAC;AAC3E,MAAI,YAAY,KAAM,QAAO,UAAU,KAAK,MAAM;AAClD,SAAO,GAAG,KAAK,KAAK,GAAG,KAAK,WAAW,IAAI,KAAK,SAAS,KAAK,GAAG,CAAC,MAAM,EAAE,KAAK,KAAK,WAAW,CAAC;AAClG;","names":[]}

package/dist/{chunk-K63OWUDJ.js → chunk-BPSV5AA2.js}

@@ -1,6 +1,6 @@
 import {
   formatBytes
-} from "./chunk-XKBIYSSM.js";
+} from "./chunk-DTSPS2HV.js";
 
 // src/chat-routes/binary-sniff.ts
 function bytesStartWith(bytes, offset, signature) {
@@ -236,4 +236,4 @@ export {
   attachmentTotalSizeErrorMessage,
   createSandboxFileIndexRoute
 };
-//# sourceMappingURL=chunk-K63OWUDJ.js.map
+//# sourceMappingURL=chunk-BPSV5AA2.js.map

package/dist/chunk-BPSV5AA2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/chat-routes/binary-sniff.ts","../src/chat-routes/attachment-validation.ts","../src/chat-routes/file-index.ts"],"sourcesContent":["/**\n * Content-based binary/text classification, shared by the attachment upload\n * route (server) and the composer's client-side pre-validation (browser) —\n * both sides must agree on what counts as binary before a byte ever leaves\n * the client. Extension-based allowlists lie (a renamed `.docx`, a PNG saved\n * as `.txt`), so classification reads the actual bytes: a magic-byte table\n * for common binary formats first, then a UTF-8 decode attempt for\n * everything else.\n *\n * Lifted near-verbatim from gtm-agent's `src/lib/binary-sniff.ts` (the\n * source PRs hardened this against real corruption/gate bugs: gtm#584,\n * gtm#592). Import-free by design — `/web-react` re-exports `/chat-routes`\n * modules into browser bundles (`tests/browser-safe-subpaths.test.ts` walks\n * the graph), so nothing here may reach a Node builtin or an engine package.\n */\n\nexport interface SniffResult {\n  binary: boolean\n  mime: string | null\n}\n\nfunction bytesStartWith(bytes: Uint8Array, offset: number, signature: number[]): boolean {\n  if (bytes.length < offset + signature.length) return false\n  for (let i = 0; i < signature.length; i++) {\n    if (bytes[offset + i] !== signature[i]) return false\n  }\n  return true\n}\n\nfunction asciiAt(bytes: Uint8Array, offset: number, text: string): boolean {\n  if (bytes.length < offset + text.length) return false\n  for (let i = 0; i < text.length; i++) {\n    if (bytes[offset + i] !== text.charCodeAt(i)) return false\n  }\n  return true\n}\n\n/** RIFF containers (WebP, WAV) share the `RIFF....<TYPE>` header; the type\n *  tag at byte offset 8 distinguishes them. */\nfunction sniffRiff(bytes: Uint8Array): string | null {\n  if (!asciiAt(bytes, 0, 'RIFF')) return null\n  if (asciiAt(bytes, 8, 'WEBP')) return 'image/webp'\n  if (asciiAt(bytes, 8, 'WAVE')) return 'audio/wav'\n  return null\n}\n\n/** MP4/MOV/AVIF/HEIC containers share an `ftyp` box at byte offset 4; the\n *  major brand at offset 8 tells them apart within the shared ISO-BMFF\n *  family. Brands outside this table (mp4, m4a, m4v, etc) fall back to\n *  `video/mp4`, the family's most common member. */\nfunction sniffFtyp(bytes: Uint8Array): string | null {\n  if (!asciiAt(bytes, 4, 'ftyp')) return null\n  if (asciiAt(bytes, 8, 'qt  ')) return 'video/quicktime'\n  if (asciiAt(bytes, 8, 'avif') || asciiAt(bytes, 8, 'avis')) return 'image/avif'\n  if (asciiAt(bytes, 8, 'heic') || asciiAt(bytes, 8, 'heix') || asciiAt(bytes, 8, 'hevc') || asciiAt(bytes, 8, 'hevx')) return 'image/heic'\n  if (asciiAt(bytes, 8, 'mif1') || asciiAt(bytes, 8, 'msf1')) return 'image/heif'\n  return 'video/mp4'\n}\n\n/** `BM` alone matches ordinary prose (\"BMW…\"), so require the BMP header's\n *  reserved bytes (offsets 6-9), which the format mandates to be zero. */\nfunction sniffBmp(bytes: Uint8Array): boolean {\n  return asciiAt(bytes, 0, 'BM')\n    && bytes.length >= 10\n    && bytes[6] === 0 && bytes[7] === 0 && bytes[8] === 0 && bytes[9] === 0\n}\n\n/** `ID3` alone matches ordinary prose (\"ID3 tags…\"), so require the ID3v2\n *  header shape: a plausible version byte and sync-safe size bytes. */\nfunction sniffId3(bytes: Uint8Array): boolean {\n  return asciiAt(bytes, 0, 'ID3')\n    && bytes.length >= 10\n    && bytes[3]! < 0x10\n    && bytes[6]! < 0x80 && bytes[7]! < 0x80 && bytes[8]! < 0x80 && bytes[9]! < 0x80\n}\n\nfunction sniffMagicBytes(bytes: Uint8Array): string | null {\n  if (bytesStartWith(bytes, 0, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) return 'image/png'\n  if (bytesStartWith(bytes, 0, [0xff, 0xd8, 0xff])) return 'image/jpeg'\n  if (asciiAt(bytes, 0, 'GIF87a') || asciiAt(bytes, 0, 'GIF89a')) return 'image/gif'\n  if (sniffBmp(bytes)) return 'image/bmp'\n  if (bytesStartWith(bytes, 0, [0x49, 0x49, 0x2a, 0x00])) return 'image/tiff' // little-endian\n  if (bytesStartWith(bytes, 0, [0x4d, 0x4d, 0x00, 0x2a])) return 'image/tiff' // big-endian\n  if (bytesStartWith(bytes, 0, [0x00, 0x00, 0x01, 0x00])) return 'image/x-icon'\n  if (asciiAt(bytes, 0, '%PDF-')) return 'application/pdf'\n  // OOXML (.docx/.xlsx/.pptx) is a zip archive; the container format is all\n  // that matters here, so no attempt is made to distinguish the payload.\n  if (bytesStartWith(bytes, 0, [0x50, 0x4b, 0x03, 0x04])) return 'application/zip'\n  if (bytesStartWith(bytes, 0, [0x1f, 0x8b])) return 'application/gzip'\n  if (sniffId3(bytes) || bytesStartWith(bytes, 0, [0xff, 0xfb])) return 'audio/mpeg'\n  if (asciiAt(bytes, 0, 'OggS')) return 'audio/ogg'\n\n  const riff = sniffRiff(bytes)\n  if (riff) return riff\n\n  const ftyp = sniffFtyp(bytes)\n  if (ftyp) return ftyp\n\n  return null\n}\n\n/** SVG is valid UTF-8 but must round-trip byte-identical (image tools read\n *  it from the box as a file), so it is classified binary. Conservative\n *  match: the document's first element is `<svg`, or an `<?xml` prolog is\n *  followed by an `<svg` element within the first ~1KB (comments/doctype may\n *  sit between). Plain XML without an svg root, or prose that merely\n *  mentions \"<svg\", stays text. */\nfunction sniffSvgText(decoded: string): boolean {\n  let text = decoded\n  if (text.charCodeAt(0) === 0xfeff) text = text.slice(1)\n  text = text.trimStart()\n  if (/^<svg[\\s>/]/.test(text)) return true\n  if (!text.startsWith('<?xml')) return false\n  return /<svg[\\s>/]/.test(text.slice(0, 1024))\n}\n\n/** Decide whether uploaded bytes are binary or text, and identify the mime\n *  type when it can be determined from content. Magic bytes are checked\n *  first; anything unmatched falls back to a fatal UTF-8 decode. A NUL byte\n *  or a decode failure means binary. Valid UTF-8 that is an SVG document is\n *  binary (byte-identity matters for image tooling). Content that matches\n *  nothing and does not decode as text is binary with an unknown mime —\n *  extension-based guessing happens at the call site, not here. */\nexport function sniffBinary(bytes: Uint8Array): SniffResult {\n  const mime = sniffMagicBytes(bytes)\n  if (mime) return { binary: true, mime }\n\n  if (bytes.includes(0x00)) return { binary: true, mime: null }\n\n  let decoded: string\n  try {\n    decoded = new TextDecoder('utf-8', { fatal: true }).decode(bytes)\n  } catch {\n    return { binary: true, mime: null }\n  }\n  if (sniffSvgText(decoded)) return { binary: true, mime: 'image/svg+xml' }\n  return { binary: false, mime: null }\n}\n","/**\n * Shared attachment validation core — constants, type-gate, and filename\n * sanitization used by BOTH the (server) attachment upload route and the\n * (browser) composer's client-side pre-validation, so a rejection never\n * differs depending on which side classified the bytes first.\n *\n * ≈ gtm-agent's `src/lib/attachment-limits.ts`, minus what agent-app already\n * has (`ATTACHMENT_MAX_COUNT`/`MAX_ATTACHMENT_TOTAL_BYTES`/\n * `attachmentTotalSizeErrorMessage` lived in `./resolve-attachments` and are\n * re-homed here so the whole validation vocabulary — count cap, size caps,\n * and type gate — has one address). Import-free besides `./wire`\n * (`formatBytes`) and `./binary-sniff` (`SniffResult`): `/web-react`\n * re-exports `/chat-routes` modules into browser bundles\n * (`tests/browser-safe-subpaths.test.ts` walks the graph), so nothing here\n * may reach a Node builtin or an engine package.\n */\n\nimport { formatBytes } from './wire'\nimport type { SniffResult } from './binary-sniff'\n\n/** Ceiling on a binary attachment's raw (pre-encoding) byte size. */\nexport const MAX_BINARY_ATTACHMENT_BYTES = 10 * 1024 * 1024\n\n/** Ceiling on a text attachment's raw byte size. Text hydrates through\n *  inline prompt parts, a separate path that remains proxy-capped (see\n *  `INLINE_PARTS_MAX_BYTES` in `./wire`). */\nexport const MAX_TEXT_ATTACHMENT_BYTES = 950 * 1024\n\n/** Most files a single request may carry: the composer staging cap, the\n *  upload route's per-request cap, and the chat body's `attachments` cap. */\nexport const ATTACHMENT_MAX_COUNT = 10\n\n/** Aggregate raw-byte ceiling across one message's attachments. */\nexport const MAX_ATTACHMENT_TOTAL_BYTES = 25 * 1024 * 1024\n\n/**\n * Accept list for the composer file picker + type validation, same grammar as\n * the native `<input accept>` attribute. Images plus the text/doc types a\n * product's store actually reads.\n */\nexport const ATTACHMENT_ACCEPT =\n  'image/*,.pdf,.txt,.md,.csv,.json,.yaml,.yml,.html'\n\n/** Sniffed-mime counterpart of `ATTACHMENT_ACCEPT`: the binary formats\n *  `sniffBinary` can identify from magic bytes among the accepted types.\n *  Values must match `sniffBinary`'s output strings verbatim, or every\n *  upload of that format fails the type gate. */\nexport const ALLOWED_ATTACHMENT_SNIFFED_MIMES: ReadonlySet<string> = new Set([\n  'image/png',\n  'image/jpeg',\n  'image/gif',\n  'image/bmp',\n  'image/tiff',\n  'image/x-icon',\n  'image/webp',\n  'image/svg+xml',\n  'image/avif',\n  'image/heic',\n  'image/heif',\n  'application/pdf',\n])\n\n/** Extensions whose magic-byte family is unambiguous, mapped to the mime\n *  `sniffBinary` emits for genuine content of that format. Keep in sync with\n *  `ATTACHMENT_ACCEPT`: an extension only belongs here if its format has a\n *  detectable magic-byte signature. Text extensions (.txt/.md/.csv/.json/\n *  .yaml/.yml/.html) are deliberately absent — they have no magic bytes to\n *  compare against, so they ride the plain UTF-8 gate instead. AVIF/HEIC/HEIF\n *  extensions are also deliberately absent: the ISO-BMFF brand-to-extension\n *  mapping in that family isn't one-to-one (a legitimate `.heic` can carry a\n *  `mif1` brand), so an extension-implies-mime entry would reject genuine\n *  files. They still ride the allowlist gate below, which is what catches an\n *  mp4 renamed `.avif` (its content sniffs `video/mp4`, not an allowed mime). */\nconst EXTENSION_IMPLIES_SNIFFED_MIME: Readonly<Record<string, string>> = {\n  png: 'image/png',\n  jpg: 'image/jpeg',\n  jpeg: 'image/jpeg',\n  gif: 'image/gif',\n  bmp: 'image/bmp',\n  tif: 'image/tiff',\n  tiff: 'image/tiff',\n  ico: 'image/x-icon',\n  webp: 'image/webp',\n  svg: 'image/svg+xml',\n  pdf: 'application/pdf',\n}\n\n/** Represent the result of checking an attachment's type with success or specific failure details */\nexport type AttachmentTypeCheckResult =\n  | { succeeded: true }\n  | { succeeded: false; code: 'attachment_type_mismatch' | 'attachment_type_not_allowed'; message: string }\n\n/**\n * Cross-check a filename's extension against its sniffed content.\n *\n * Text content (`sniff.binary === false`) always passes here — it has no\n * magic bytes to compare, so it rides the existing UTF-8 gate instead. For\n * binary content: an extension with an unambiguous magic-byte family (e.g.\n * `.pdf`) must match the sniffed mime, or the upload is a mismatch (a\n * renamed file). Otherwise the sniffed mime must be one of `allowed`\n * (default {@link ALLOWED_ATTACHMENT_SNIFFED_MIMES}), or the upload is\n * rejected outright. The `allowed` param feeds a route's override seam (a\n * product accepting a narrower or wider set than the default).\n */\nexport function checkAttachmentType(\n  fileName: string,\n  sniff: SniffResult,\n  allowed: ReadonlySet<string> = ALLOWED_ATTACHMENT_SNIFFED_MIMES,\n): AttachmentTypeCheckResult {\n  if (sniff.binary === false) return { succeeded: true }\n\n  const extension = fileName.split('.').pop()?.toLowerCase() ?? ''\n  const impliedMime = EXTENSION_IMPLIES_SNIFFED_MIME[extension]\n  if (impliedMime && sniff.mime && sniff.mime !== impliedMime) {\n    return {\n      succeeded: false,\n      code: 'attachment_type_mismatch',\n      message: `${fileName} has a .${extension} extension, but its content is ${sniff.mime}`,\n    }\n  }\n\n  if (!sniff.mime || !allowed.has(sniff.mime)) {\n    return {\n      succeeded: false,\n      code: 'attachment_type_not_allowed',\n      message: sniff.mime\n        ? `${fileName}'s content (${sniff.mime}) is not an allowed attachment type`\n        : `${fileName}'s content is not a recognized attachment type`,\n    }\n  }\n\n  return { succeeded: true }\n}\n\n/**\n * Rewrite a filename into the store-path charset (`A-Za-z0-9._-` per\n * segment) — attachment paths double as store keys, sandbox file paths, and\n * in-message path references, none of which tolerate spaces or punctuation.\n * Runs of unsupported characters collapse to one `-`; leading dots/dashes are\n * stripped so the name can't read as a hidden segment. The original name is\n * preserved separately (the returned `ChatAttachmentInput.name`), so\n * sanitization loses nothing.\n */\nexport function sanitizeAttachmentFileName(name: string): string {\n  const sanitized = name\n    .trim()\n    .replace(/[^A-Za-z0-9._-]+/g, '-')\n    .replace(/^[.-]+/, '')\n  return sanitized || 'file'\n}\n\n/** Human-readable error naming both the actual size and the limit that was\n *  exceeded. Shared so the server route and the composer pre-check report\n *  the same message shape. */\nexport function attachmentSizeErrorMessage(name: string, actualBytes: number, limitBytes: number): string {\n  return `${name} is ${formatBytes(actualBytes)}; attachments are limited to ${formatBytes(limitBytes)}`\n}\n\n/** Human-readable error for a chat message whose combined attachments exceed\n *  the aggregate raw-byte ceiling. */\nexport function attachmentTotalSizeErrorMessage(totalBytes: number, limitBytes: number): string {\n  return `Attachments total ${formatBytes(totalBytes)}; each message is limited to ${formatBytes(limitBytes)}`\n}\n","/**\n * `createSandboxFileIndexRoute` — server side of `@`-file-mentions\n * (companion to sandbox-ui#184's composer mention primitive). Serves a flat,\n * ignore-filtered listing of the workspace sandbox so `useFileMentions`\n * (`/web-react`) can filter it client-side without a round trip per\n * keystroke.\n *\n * Same seam style as `createUploadRoute`: `authorize({ request })` resolves a\n * structural `{ tree(path, opts) }` handle (the shape of the sandbox SDK's\n * `box.fs.tree`) — no SDK import here. `authorize` also carries the\n * cold-box signal: a sandbox that isn't running yet answers `{ status:\n * 'warming' }` directly, never provisions-and-waits inside this route.\n *\n * A box can also be running with its workspace root not yet materialised, which\n * `authorize` cannot see; the route recognises that one signal off `fs.tree`\n * and answers `warming` too, so every consumer gets the retry-and-wait state\n * instead of a 500. Every other `tree()` failure propagates.\n */\n\nimport type { FileMention } from './wire'\n\n/** One entry from a structural `tree()` scan. Mirrors the sandbox SDK's\n *  `FileTreeFile` (`path`, `size`, `mtime`) — `mtime` is unused here so it's\n *  omitted from the structural match. */\nexport interface SandboxTreeFile {\n  path: string\n  size: number\n}\n\n/** Structural match of the sandbox SDK's `box.fs.tree` result shape\n *  (`FileTreeResult`). `stats.truncated` is the only stat this route reads;\n *  the rest ride through unread on the real SDK type. */\nexport interface SandboxTreeResult {\n  root: string\n  files: SandboxTreeFile[]\n  stats: { truncated: boolean }\n}\n\n/** Structural match of the sandbox SDK's `box.fs` tree surface. */\nexport interface SandboxFileTreeSource {\n  tree(path: string, options?: { maxDepth?: number }): Promise<SandboxTreeResult>\n}\n\n/** Describe a ready file index response with workspace-relative entries and truncation status */\nexport interface FileIndexReadyResponse {\n  status: 'ready'\n  /** Workspace-relative entries. Same shape as `FileMention` (`./wire`) so a\n   *  client can hand a response entry straight to `fileMentionsToParts` /\n   *  `buildMentionPromptBlock` without remapping. */\n  files: FileMention[]\n  /** True when either the underlying scan truncated (SDK-side cap) or this\n   *  route's own `maxEntries` cap trimmed the filtered list. The client\n   *  should show \"showing first N files\" rather than imply completeness. */\n  truncated: boolean\n  generatedAt: string\n}\n\n/** Cold-box answer: no provisioning happened, no files were scanned. The\n *  client shows a warming state and retries — this route never blocks on a\n *  box coming up. Two situations produce it: `authorize` reporting a box that\n *  is not running, and a running box whose workspace root does not exist yet\n *  (see `isMissingRootError`). */\nexport interface FileIndexWarmingResponse {\n  status: 'warming'\n}\n\n/** Resolve a response indicating the file index is either ready or warming up */\nexport type FileIndexResponse = FileIndexReadyResponse | FileIndexWarmingResponse\n\n/** Short-TTL cache seam so repeat popover opens in the same session don't\n *  re-scan the workspace. Host-provided (e.g. a KV binding); `key` is\n *  whatever `authorize` returns as `cacheKey` — this route treats it opaquely. */\nexport interface FileIndexCache {\n  get(key: string): Promise<FileIndexReadyResponse | null> | FileIndexReadyResponse | null\n  put(key: string, value: FileIndexReadyResponse, options?: { ttlSeconds?: number }): Promise<void> | void\n}\n\n/** Define authorization details and parameters for indexing a file workspace with optional caching and ignore rules */\nexport type FileIndexAuthorization =\n  | {\n      status: 'ready'\n      /** Structural sandbox `fs` handle, usually `ensureWorkspaceSandbox(...)` → `box.fs`. */\n      fs: SandboxFileTreeSource\n      /** Workspace root to index (e.g. `/home/agent`). */\n      root: string\n      /** Extra ignore segments for this request, merged with the route's\n       *  defaults + `CreateSandboxFileIndexRouteOptions.ignore`. */\n      ignore?: string[]\n      /** Opaque cache key for the optional cache seam. Omit to skip caching\n       *  for this request (e.g. a workspace the host chooses not to cache). */\n      cacheKey?: string\n    }\n  | { status: 'warming' }\n  | { status: 'denied'; response: Response }\n\n/** Define options to authorize and configure sandbox file index route behavior */\nexport interface CreateSandboxFileIndexRouteOptions {\n  /** Authenticate the caller, resolve the sandbox `fs` handle, and signal a\n   *  cold box — never provisions or waits. */\n  authorize(args: { request: Request }): Promise<FileIndexAuthorization>\n  /** Extra ignore segments beyond the route's defaults (node_modules, .git,\n   *  dotfiles/dot-dirs, common build dirs). Matched as exact path-segment\n   *  names, same rule as the defaults. */\n  ignore?: string[]\n  /** Passed to `fs.tree` as `options.maxDepth`. Default 12. */\n  maxDepth?: number\n  /** Hard cap on entries returned after filtering. Default 5000. */\n  maxEntries?: number\n  /** Optional host-provided cache seam. */\n  cache?: FileIndexCache\n  /** Cache TTL in seconds when `cache` is set. Default 20. */\n  cacheTtlSeconds?: number\n}\n\n/** Segment names ignored anywhere in a path, beyond the generic dotfile rule\n *  below. Intentionally small and language/framework-agnostic — callers\n *  extend it via `ignore` for anything domain-specific (e.g. a vault's\n *  `uploads` dir). */\nconst DEFAULT_IGNORE_SEGMENTS = [\n  'node_modules',\n  'dist',\n  'build',\n  'out',\n  'coverage',\n  'target',\n  '__pycache__',\n  'venv',\n]\n\n/** A path segment starting with `.` (`.git`, `.env`, `.next`, `.cache`, …) is\n *  always ignored — this single rule covers most dot-prefixed VCS/tooling\n *  dirs and dotfiles without enumerating them. */\nfunction isIgnored(relPath: string, ignoreSegments: ReadonlySet<string>): boolean {\n  for (const segment of relPath.split('/')) {\n    if (!segment) continue\n    if (segment.startsWith('.')) return true\n    if (ignoreSegments.has(segment)) return true\n  }\n  return false\n}\n\n/** Strips the tree result's echoed `root` prefix so entries are always\n *  workspace-relative, whichever convention the structural `fs.tree` uses\n *  (root-relative already, or root-prefixed). */\nfunction relativeTo(root: string, path: string): string {\n  const prefix = root.endsWith('/') ? root : `${root}/`\n  if (path.startsWith(prefix)) return path.slice(prefix.length)\n  if (path === root) return ''\n  return path\n}\n\nfunction basename(path: string): string {\n  const segments = path.split('/').filter(Boolean)\n  return segments[segments.length - 1] ?? path\n}\n\n/**\n * A box can answer `running` before it has materialised the workspace root —\n * `authorize` has already committed to `ready` by then, so `fs.tree` is the\n * first thing to notice, and it rejects with the sandbox SDK's\n * `ValidationError` wrapping a box-side `ENOENT … lstat` on the root. That is\n * the SAME \"not usable yet\" state `authorize` collapses onto `warming` for an\n * absent or stopped box, just discovered one step later, so it gets the same\n * answer instead of escaping as a 500.\n *\n * Matched STRUCTURALLY, not with `instanceof`: importing the SDK's error class\n * would make `@tangle-network/sandbox` a hard dependency of a route factory\n * whose entire `fs` seam is structural (`SandboxFileTreeSource`), and would\n * break any host feeding it a non-SDK handle.\n *\n * Deliberately narrow — the error code, `ENOENT`, the ENOENT message text, AND\n * the failing syscall's own operand all have to line up. A permission error, a\n * timeout, an auth failure, or an ENOENT on some other path inside the tree is\n * a real failure and still surfaces.\n *\n * The operand is matched as the quoted `lstat '<root>'` clause rather than by\n * substring, because the root is a PREFIX of everything under it: a plain\n * `includes(root)` would also swallow an ENOENT on `<root>/gone/x.md`, and on\n * a prefix sibling like `/home/agent-old/...`.\n */\nfunction isMissingRootError(err: unknown, root: string): boolean {\n  if (!(err instanceof Error)) return false\n  if ((err as { code?: unknown }).code !== 'VALIDATION_ERROR') return false\n  return (\n    /ENOENT/.test(err.message) &&\n    /no such file or directory/.test(err.message) &&\n    new RegExp(`\\\\blstat '${escapeRegExp(root)}'`).test(err.message)\n  )\n}\n\nfunction escapeRegExp(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/** Resolve a sandbox file index route with authorization, caching, and configurable depth and entries limits */\nexport function createSandboxFileIndexRoute(\n  options: CreateSandboxFileIndexRouteOptions,\n): (request: Request) => Promise<Response> {\n  const maxDepth = options.maxDepth ?? 12\n  const maxEntries = options.maxEntries ?? 5000\n  const cacheTtlSeconds = options.cacheTtlSeconds ?? 20\n  const staticIgnore = new Set([...DEFAULT_IGNORE_SEGMENTS, ...(options.ignore ?? [])])\n\n  return async function fileIndex(request: Request): Promise<Response> {\n    const auth = await options.authorize({ request })\n    if (auth.status === 'denied') return auth.response\n    if (auth.status === 'warming') {\n      return Response.json({ status: 'warming' } satisfies FileIndexWarmingResponse)\n    }\n\n    const cache = options.cache\n    if (cache && auth.cacheKey) {\n      const cached = await cache.get(auth.cacheKey)\n      if (cached) return Response.json(cached)\n    }\n\n    const ignoreSegments = auth.ignore?.length\n      ? new Set([...staticIgnore, ...auth.ignore])\n      : staticIgnore\n\n    let scan: SandboxTreeResult\n    try {\n      scan = await auth.fs.tree(auth.root, { maxDepth })\n    } catch (err) {\n      if (!isMissingRootError(err, auth.root)) throw err\n      return Response.json({ status: 'warming' } satisfies FileIndexWarmingResponse)\n    }\n    const filtered = scan.files.filter((f) => !isIgnored(relativeTo(scan.root, f.path), ignoreSegments))\n    const truncated = scan.stats.truncated || filtered.length > maxEntries\n    const files: FileMention[] = filtered.slice(0, maxEntries).map((f) => {\n      const path = relativeTo(scan.root, f.path)\n      const entry: FileMention = { path, name: basename(path) }\n      if (typeof f.size === 'number') entry.size = f.size\n      return entry\n    })\n\n    const body: FileIndexReadyResponse = {\n      status: 'ready',\n      files,\n      truncated,\n      generatedAt: new Date().toISOString(),\n    }\n\n    if (cache && auth.cacheKey) await cache.put(auth.cacheKey, body, { ttlSeconds: cacheTtlSeconds })\n\n    return Response.json(body)\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-MFI4ZM7W.js → chunk-BT4QFCTB.js}

@@ -290,4 +290,4 @@ export {
   failedOptimisticGeneration,
   normalizeImageCount
 };
-//# sourceMappingURL=chunk-MFI4ZM7W.js.map
+//# sourceMappingURL=chunk-BT4QFCTB.js.map

package/dist/chunk-BT4QFCTB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/studio/generation.ts"],"sourcesContent":["// Minimal structural view of a connected integration — `isDestinationConnected`\n// only reads the connection status and the provider/connector identifiers, so\n// the logic layer declares its own shape instead of depending on the\n// design-system package. A sandbox-ui `IntegrationConnection` is assignable to\n// this; `connectorId` is optional because the engine type leaves it undefined\n// for connections established without a named connector.\n/** Define the structure for a studio integration connection with status and provider identifiers */\nexport interface StudioIntegrationConnection {\n  status: string\n  providerId: string\n  connectorId?: string\n}\n\n/** Define generation categories for media including image, video, speech, avatar, and transcription */\nexport type GenerationType = 'image' | 'video' | 'speech' | 'avatar' | 'transcription'\n\n/** Define possible states representing the progress of a generation process */\nexport type GenerationStatus = 'pending' | 'running' | 'succeeded' | 'failed'\n\n/** Define possible status values for a media model's availability and accessibility */\nexport type MediaModelStatus = 'available' | 'limited' | 'unavailable'\n\n/** Define the structure for a generation entity including its metadata and creation details */\nexport interface Generation {\n  id: string\n  type: string\n  prompt: string\n  result: string | null\n  model: string | null\n  cost: number | null\n  createdAt: Date | null\n  metadata: Record<string, unknown> | null\n}\n\n/** Describe media model option properties including id, name, type, status, and optional provider and reason */\nexport interface MediaModelOption {\n  id: string\n  name: string\n  provider?: string\n  type: GenerationType\n  status: MediaModelStatus\n  reason?: string\n}\n\n/** Represent media model catalog with default values, model options, and optional error message */\nexport interface MediaModelCatalogResponse {\n  defaults: Record<GenerationType, string>\n  models: Record<GenerationType, MediaModelOption[]>\n  error?: string\n}\n\n/** Define the structure for configuring package publishing details and evaluation criteria */\nexport interface PublishPackage {\n  caption: string\n  description: string\n  mentions: string[]\n  destinations: string[]\n  cadence: string\n  workflowDraft: boolean\n  evalContract: {\n    artifactType: string\n    deterministicChecks: string[]\n  }\n}\n\n/** Define a destination for publishing content with identifiers, label, provider IDs, and fields */\nexport interface PublishDestination {\n  id: string\n  label: string\n  providerIds: string[]\n  fields: string\n}\n\n// Order drives the type filter tabs and the composer segmented control\n/** Provide an array of supported generation types for media and content processing */\nexport const GENERATION_TYPES: readonly GenerationType[] = ['image', 'video', 'avatar', 'speech', 'transcription']\n\n/** Resolve whether a string value matches a valid GenerationType */\nexport function isGenerationType(value: string): value is GenerationType {\n  return (GENERATION_TYPES as readonly string[]).includes(value)\n}\n\n/** List available social media platforms with their publishing fields and provider identifiers */\nexport const DESTINATIONS: PublishDestination[] = [\n  { id: 'instagram', label: 'Instagram', providerIds: ['instagram'], fields: 'Caption, hashtags, crop' },\n  { id: 'tiktok', label: 'TikTok', providerIds: ['tiktok'], fields: 'Caption, audio note, vertical video' },\n  { id: 'youtube-shorts', label: 'YouTube Shorts', providerIds: ['youtube'], fields: 'Title, description, vertical video' },\n  { id: 'linkedin', label: 'LinkedIn', providerIds: ['linkedin'], fields: 'Caption, link, creator/company page' },\n  { id: 'x', label: 'X', providerIds: ['twitter'], fields: 'Short copy, mentions, thread option' },\n]\n\n/** Provide an array of predefined cadence options for scheduling or approval processes */\nexport const CADENCES = ['Manual approval', 'Publish now', 'Daily creative drop', 'Weekly series']\n\n/** Define the minimum number of images required for processing or validation */\nexport const MIN_IMAGE_COUNT = 1\n/** Define the maximum number of images allowed for upload or display */\nexport const MAX_IMAGE_COUNT = 4\n\n/** Resolve a human-readable relative time string from a given date or return an empty string if null */\nexport function relativeTime(date: Date | null): string {\n  if (!date) return ''\n  const now = Date.now()\n  const diff = now - new Date(date).getTime()\n  const minutes = Math.floor(diff / 60000)\n  if (minutes < 1) return 'just now'\n  if (minutes < 60) return `${minutes}m ago`\n  const hours = Math.floor(minutes / 60)\n  if (hours < 24) return `${hours}h ago`\n  const days = Math.floor(hours / 24)\n  if (days < 7) return `${days}d ago`\n  return new Date(date).toLocaleDateString('en-US', { month: 'short', day: 'numeric' })\n}\n\n/** Resolve the output directory path based on the specified generation type */\nexport function outputPathFor(type: GenerationType): string {\n  if (type === 'image') return 'generated/images'\n  if (type === 'video') return 'generated/videos'\n  if (type === 'avatar') return 'generated/avatars'\n  if (type === 'speech') return 'generated/audio'\n  return 'generated/transcripts'\n}\n\n/** Resolve the vault path string from a Generation object or return null if unavailable */\nexport function generationVaultPath(generation: Generation): string | null {\n  const value = generation.metadata?.vaultPath\n  return typeof value === 'string' && value.trim() ? value.trim() : null\n}\n\n/** Build a PublishPackage object from caption, description, mentions, cadence, and destinations inputs */\nexport function buildPublishPackage({\n  caption,\n  postDescription,\n  mentions,\n  cadence,\n  destinations,\n}: {\n  caption: string\n  postDescription: string\n  mentions: string\n  cadence: string\n  destinations: string[]\n}): PublishPackage | null {\n  const trimmedCaption = caption.trim()\n  const trimmedDescription = postDescription.trim()\n  const parsedMentions = mentions.split(',').map((item) => item.trim()).filter(Boolean)\n  const selectedDestinations = destinations.filter(Boolean)\n  const trimmedCadence = cadence.trim() || 'Manual approval'\n  const hasPublishContent = Boolean(\n    trimmedCaption\n    || trimmedDescription\n    || parsedMentions.length > 0\n    || selectedDestinations.length > 0\n    || trimmedCadence !== 'Manual approval',\n  )\n  if (!hasPublishContent) return null\n\n  return {\n    caption: trimmedCaption,\n    description: trimmedDescription,\n    mentions: parsedMentions,\n    destinations: selectedDestinations,\n    cadence: trimmedCadence,\n    workflowDraft: trimmedCadence !== 'Manual approval',\n    evalContract: {\n      artifactType: 'publish_package',\n      deterministicChecks: ['has_asset', 'has_destination', 'has_caption_or_description', 'has_cadence'],\n    },\n  }\n}\n\n/** Determine if a value conforms to the PublishPackage structure with optional metadata fields */\nexport function isPublishPackage(value: unknown): value is { caption?: string; description?: string; mentions?: string[]; destinations?: string[]; cadence?: string } {\n  if (!value || typeof value !== 'object') return false\n  const publishPackage = value as {\n    caption?: unknown\n    description?: unknown\n    mentions?: unknown\n    destinations?: unknown\n    cadence?: unknown\n  }\n  const destinations = Array.isArray(publishPackage.destinations) ? publishPackage.destinations.filter(Boolean) : []\n  const mentions = Array.isArray(publishPackage.mentions) ? publishPackage.mentions.filter(Boolean) : []\n  return Boolean(\n    destinations.length > 0\n    || mentions.length > 0\n    || (typeof publishPackage.caption === 'string' && publishPackage.caption.trim())\n    || (typeof publishPackage.description === 'string' && publishPackage.description.trim())\n    || (typeof publishPackage.cadence === 'string' && publishPackage.cadence.trim() && publishPackage.cadence.trim() !== 'Manual approval'),\n  )\n}\n\n/** Determine if a destination has any active connections in the given list of studio integration connections */\nexport function isDestinationConnected(\n  destination: PublishDestination,\n  connections: StudioIntegrationConnection[],\n): boolean {\n  return connections.some((connection) => connection.status === 'connected'\n    && (destination.providerIds.includes(connection.providerId)\n      || (connection.connectorId !== undefined && destination.providerIds.includes(connection.connectorId))))\n}\n\n/** Resolve selected models by applying defaults for missing or unavailable entries in the catalog */\nexport function selectedModelsWithDefaults(\n  current: Partial<Record<GenerationType, string>>,\n  catalog: MediaModelCatalogResponse,\n): Partial<Record<GenerationType, string>> {\n  const next = { ...current }\n  for (const key of GENERATION_TYPES) {\n    const models = catalog.models[key] ?? []\n    const currentOption = models.find((model) => model.id === next[key])\n    // Reset when: no selection, selection not in catalog, or selection is unavailable.\n    // This ensures the Generate button is never stuck disabled when routeable\n    // models exist but the stored default isn't one of them.\n    if (!next[key] || !currentOption || currentOption.status === 'unavailable') {\n      next[key] = preferredModelId(key, catalog) ?? ''\n    }\n  }\n  return next\n}\n\n/** Resolve the preferred model ID for a given generation type from the media model catalog */\nexport function preferredModelId(type: GenerationType, catalog: MediaModelCatalogResponse | null): string | undefined {\n  if (!catalog) return undefined\n  const models = catalog.models[type] ?? []\n  const preferred = catalog.defaults[type]\n  return models.find((model) => model.id === preferred)?.id\n    ?? models.find((model) => model.status !== 'unavailable')?.id\n    ?? models[0]?.id\n}\n\n/** Resolve the appropriate status message for a media model based on loading state and availability */\nexport function modelMessage(model: MediaModelOption | undefined, loading: boolean, count: number): string | null {\n  if (loading) return 'Loading media models...'\n  if (count === 0) return 'No models are available for this media type.'\n  if (!model) return 'Select a model.'\n  if (model.status === 'unavailable') return model.reason ?? 'This model is not configured.'\n  if (model.status === 'limited') return model.reason ? `Limited: ${model.reason}` : 'Limited availability.'\n  return null\n}\n\n/** Define fields required to configure and request various types of media generation */\nexport interface GenerationRequestFields {\n  workspaceId: string\n  clientRequestId: string\n  type: GenerationType\n  model: string\n  prompt: string\n  negativePrompt: string\n  outputPath: string\n  publishPackage: PublishPackage | null\n  image: { size: string; quality: string; count: number }\n  video: { duration: string; resolution: string; aspectRatio: string; referenceImageUrl: string }\n  speech: { voice: string }\n  avatar: { audioUrl: string; imageUrl: string; avatarId: string }\n  transcription: { audioUrl: string; language: string; responseFormat: string; temperature: string }\n}\n\n// image.count must already be normalized — it is also the optimistic-card count on the caller side\n/** Build the request body object for a generation operation from provided fields */\nexport function buildGenerationRequestBody(fields: GenerationRequestFields): Record<string, unknown> {\n  const body: Record<string, unknown> = {\n    workspaceId: fields.workspaceId,\n    clientRequestId: fields.clientRequestId,\n    type: fields.type,\n    model: fields.model,\n    prompt: fields.prompt.trim(),\n    negativePrompt: fields.negativePrompt.trim() || undefined,\n    outputPath: fields.outputPath.trim() || undefined,\n  }\n  if (fields.publishPackage) body.publishPackage = fields.publishPackage\n  if (fields.type === 'image') Object.assign(body, {\n    size: fields.image.size,\n    quality: fields.image.quality,\n    n: fields.image.count,\n  })\n  if (fields.type === 'video') {\n    const duration = Number(fields.video.duration)\n    Object.assign(body, {\n      // omit (let the API default) rather than serialize NaN → null on bad input\n      duration: Number.isFinite(duration) ? duration : undefined,\n      resolution: fields.video.resolution,\n      aspectRatio: fields.video.aspectRatio.trim() || undefined,\n      referenceImageUrl: fields.video.referenceImageUrl.trim() || undefined,\n    })\n  }\n  if (fields.type === 'speech') Object.assign(body, { voice: fields.speech.voice })\n  if (fields.type === 'avatar') Object.assign(body, {\n    audioUrl: fields.avatar.audioUrl.trim(),\n    imageUrl: fields.avatar.imageUrl.trim() || undefined,\n    avatarId: fields.avatar.avatarId.trim() || undefined,\n  })\n  if (fields.type === 'transcription') {\n    const temperature = Number(fields.transcription.temperature)\n    Object.assign(body, {\n      audioUrl: fields.transcription.audioUrl.trim(),\n      language: fields.transcription.language.trim() || undefined,\n      responseFormat: fields.transcription.responseFormat,\n      // omit (let the API default) rather than serialize NaN → null on bad input\n      temperature: Number.isFinite(temperature) ? temperature : undefined,\n    })\n  }\n  return body\n}\n\n/** Resolve the current status of a generation based on its metadata and result fields */\nexport function generationStatus(generation: Generation): GenerationStatus {\n  const metadata = generation.metadata ?? {}\n  const status = typeof metadata.generationStatus === 'string' ? metadata.generationStatus : ''\n  if (status === 'pending' || status === 'running' || status === 'failed' || status === 'succeeded') return status\n  return generation.result ? 'succeeded' : 'pending'\n}\n\n/** Resolve and return the first user-safe error message from generation metadata or null if none exist */\nexport function generationError(generation: Generation): string | null {\n  const metadata = generation.metadata ?? {}\n  if (typeof metadata.providerError === 'string' && metadata.providerError.trim()) {\n    return userSafeGenerationMessage(metadata.providerError)\n  }\n  if (typeof metadata.storageError === 'string' && metadata.storageError.trim()) {\n    return metadata.storageError\n  }\n  return null\n}\n\nfunction generationClientRequestId(generation: Generation): string | null {\n  const metadata = generation.metadata ?? {}\n  return typeof metadata.clientRequestId === 'string' && metadata.clientRequestId.trim()\n    ? metadata.clientRequestId\n    : null\n}\n\nfunction generationBatchSlotKey(generation: Generation): string | null {\n  const metadata = generation.metadata ?? {}\n  const batchId = typeof metadata.batchId === 'string' && metadata.batchId.trim() ? metadata.batchId : null\n  return batchId && typeof metadata.outputIndex === 'number'\n    ? `${batchId}:${metadata.outputIndex}`\n    : null\n}\n\n/** Resolve a unique merge key from a generation using batch slot or client request ID */\nexport function generationMergeKey(generation: Generation): string | null {\n  return generationBatchSlotKey(generation) ?? generationClientRequestId(generation)\n}\n\n/** Merge a new generation into the current list by replacing or prepending it based on matching keys */\nexport function mergeLiveGeneration(current: Generation[], generation: Generation): Generation[] {\n  const mergeKey = generationMergeKey(generation)\n  const existingIndex = current.findIndex((item) => (\n    item.id === generation.id\n    || (mergeKey && generationMergeKey(item) === mergeKey)\n  ))\n  if (existingIndex === -1) return [generation, ...current]\n\n  const next = [...current]\n  next[existingIndex] = generation\n  return next\n}\n\n// Overlay in-flight `live` generations on the loader's rows: each live row leads\n// (prefer the matching loader row by merge key / id so it carries the freshest\n// server state), then the remaining loader rows that no live row already\n// represents — deduped by BOTH id and merge key so a server row and its\n// optimistic twin never both appear. Returns `loader` unchanged when nothing is\n// live. Drives the canvas, library, and polling off one list.\n/** Merge two Generation arrays prioritizing live entries and matching by merge keys or IDs */\nexport function mergeLoaderAndLive(loader: Generation[], live: Generation[]): Generation[] {\n  if (live.length === 0) return loader\n  const leading = live.map((generation) => {\n    const mergeKey = generationMergeKey(generation)\n    return mergeKey\n      ? loader.find((gen) => generationMergeKey(gen) === mergeKey) ?? generation\n      : loader.find((gen) => gen.id === generation.id) ?? generation\n  })\n  const leadingIds = new Set(leading.map((gen) => gen.id))\n  const leadingMergeKeys = new Set(leading\n    .map((gen) => generationMergeKey(gen))\n    .filter((id): id is string => Boolean(id)))\n  return [\n    ...leading,\n    ...loader.filter((gen) => (\n      !leadingIds.has(gen.id)\n      && !leadingMergeKeys.has(generationMergeKey(gen) ?? '')\n    )),\n  ]\n}\n\n/** Determine if a generation ID indicates a local generation */\nexport function isLocalGeneration(generation: Generation): boolean {\n  return generation.id.startsWith('local-')\n}\n\nfunction generationOutputIndex(generation: Generation): number {\n  const value = generation.metadata?.outputIndex\n  return typeof value === 'number' ? value : 0\n}\n\n// The most-recent run: all generations sharing the leading item's clientRequestId\n// (a multi-image batch), ordered by output slot. Falls back to the single leading\n// item when no request id is present. Drives the result canvas.\n/** Resolve and return the latest batch of generations grouped and sorted by client request ID and output index */\nexport function latestBatchOf(generations: Generation[]): Generation[] {\n  const first = generations[0]\n  if (!first) return []\n  const key = generationClientRequestId(first)\n  const batch = key\n    ? generations.filter((generation) => generationClientRequestId(generation) === key)\n    : [first]\n  return [...batch].sort((a, b) => generationOutputIndex(a) - generationOutputIndex(b))\n}\n\n/** Resolve a user-safe generation message by filtering sensitive or error-related content */\nexport function userSafeGenerationMessage(message?: string): string {\n  if (!message) return 'Generation failed'\n  if (/Tangle API key is invalid or expired/i.test(message)) return message\n  if (/(api[_ -]?key|secret|token|credential|env|configured|configuration)/i.test(message)) {\n    return 'Generation failed'\n  }\n  return message\n}\n\n/** Generate content optimistically based on input parameters and optional model and output details */\nexport function optimisticGeneration({\n  type,\n  prompt,\n  model,\n  clientRequestId,\n  outputIndex,\n  outputCount,\n}: {\n  type: GenerationType\n  prompt: string\n  model?: string\n  clientRequestId: string\n  outputIndex?: number\n  outputCount?: number\n}): Generation {\n  const batchId = outputIndex == null ? undefined : clientRequestId\n  return {\n    id: outputIndex == null ? `local-${clientRequestId}` : `local-${clientRequestId}-${outputIndex}`,\n    type,\n    prompt,\n    result: null,\n    model: model ?? null,\n    cost: null,\n    createdAt: new Date(),\n    metadata: {\n      generationStatus: 'pending',\n      provider: type,\n      clientRequestId,\n      batchId,\n      outputIndex,\n      outputCount,\n    },\n  }\n}\n\n/** Mark a generation as failed with updated status and error information */\nexport function failedOptimisticGeneration(generation: Generation): Generation {\n  return {\n    ...generation,\n    metadata: {\n      ...(generation.metadata ?? {}),\n      generationStatus: 'failed',\n      providerError: 'Generation failed',\n    },\n  }\n}\n\n/** Normalize a value to a finite integer within the allowed image count range */\nexport function normalizeImageCount(value: unknown): number {\n  const numeric = typeof value === 'number' ? value : Number(value)\n  if (!Number.isFinite(numeric)) return MIN_IMAGE_COUNT\n  return Math.min(Math.max(Math.trunc(numeric), MIN_IMAGE_COUNT), MAX_IMAGE_COUNT)\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-ZYBWGSAZ.js → chunk-BVKQKGRK.js}

@@ -127,4 +127,4 @@ export {
   snapshotFrame,
   trackIntervals
 };
-//# sourceMappingURL=chunk-ZYBWGSAZ.js.map
+//# sourceMappingURL=chunk-BVKQKGRK.js.map

package/dist/chunk-BVKQKGRK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sequences/model.ts"],"sourcesContent":["/**\n * Frame-accurate sequence timeline model — the product-agnostic spine of the\n * sequences surface. A sequence is a fixed-fps, fixed-duration timeline of\n * tracks; clips sit on tracks at integer frame positions with non-destructive\n * source in/out points. Products bind this model to their own storage through\n * `SequenceStore` (./store) and surface it to agents through the MCP toolset\n * (./mcp).\n *\n * All positions and durations are integer FRAMES at the sequence's fps.\n * Seconds appear only at the API edge (agent tools speak seconds; the\n * dispatcher converts exactly once). Nothing here touches a database, the DOM,\n * or React.\n */\n\nexport const MIN_SEQUENCE_CLIP_FRAMES = 1\n\n/** Track kinds. `reference` holds non-rendered guide media; `agent` holds the\n *  agent-decision lane rendered as markers, never as media. */\nexport type SequenceTrackKind = 'video' | 'audio' | 'caption' | 'reference' | 'agent'\n\n/** Define sequence status as one of the specific lifecycle stages draft, active, exporting, or archived */\nexport type SequenceStatus = 'draft' | 'active' | 'exporting' | 'archived'\n\n/** Define export formats available for sequence data including video, subtitle, and metadata types */\nexport type SequenceExportFormat = 'mp4' | 'otio' | 'xml' | 'edl' | 'vtt' | 'srt' | 'contact_sheet'\n\n/** Represent export status of a sequence as queued, processing, completed, failed, or cancelled */\nexport type SequenceExportStatus = 'queued' | 'processing' | 'completed' | 'failed' | 'cancelled'\n\n/** Define media types allowed in a sequence including video, image, and audio */\nexport type SequenceMediaKind = 'video' | 'image' | 'audio'\n\n/** Describe metadata and properties of a media sequence including dimensions, duration, and status */\nexport interface SequenceMeta {\n  id: string\n  title: string\n  fps: number\n  width: number\n  height: number\n  aspectRatio: string\n  durationFrames: number\n  status: SequenceStatus\n  metadata: Record<string, unknown>\n}\n\n/** Define properties and state for a sequence track including id, kind, name, order, and flags */\nexport interface SequenceTrack {\n  id: string\n  kind: SequenceTrackKind\n  name: string\n  sortOrder: number\n  locked: boolean\n  muted: boolean\n  metadata: Record<string, unknown>\n}\n\n/** Resolved playable media behind a clip. The store resolves product-specific\n *  references (generation rows, asset rows) into this shape; the core model\n *  never sees the product's tables. */\nexport interface SequenceClipMedia {\n  url: string\n  kind: SequenceMediaKind\n  /** Natural duration of the source media when known. */\n  durationSeconds?: number\n  /** Provider job state for media still rendering upstream. */\n  providerStatus?: 'queued' | 'processing' | 'completed' | 'failed'\n}\n\n/** Define properties for a media sequence clip including timing, source, track, and caption details */\nexport interface SequenceClip {\n  id: string\n  trackId: string\n  label: string\n  startFrame: number\n  durationFrames: number\n  /** Source-relative in point (frames into the source media). */\n  sourceInFrame: number\n  /** Source-relative out point; null = natural end of the source. */\n  sourceOutFrame: number | null\n  disabled: boolean\n  /** Caption/text body for clips on caption tracks. */\n  text?: string\n  /** BCP-47 language tag for caption clips (e.g. 'en', 'es', 'ja'). */\n  language?: string\n  /** Opaque product reference to a generation row, when the clip came from one. */\n  generationId?: string\n  /** Opaque product reference to an asset row, when the clip came from one. */\n  assetId?: string\n  media?: SequenceClipMedia\n  metadata: Record<string, unknown>\n}\n\n/** One entry in the sequence's decision log — human edits, agent proposals,\n *  agent edits, exports, and notes all land here so the edit history is a\n *  single auditable lane. */\nexport interface SequenceDecision {\n  id: string\n  clipId: string | null\n  kind: 'human_edit' | 'agent_proposal' | 'agent_edit' | 'export' | 'note'\n  instruction: string\n  reasoningSummary: string | null\n  accepted: boolean | null\n  metadata: Record<string, unknown>\n  createdAt: Date\n}\n\n/** Describe a record representing the export details and status of a sequence */\nexport interface SequenceExportRecord {\n  id: string\n  format: SequenceExportFormat\n  status: SequenceExportStatus\n  resultUrl: string | null\n  metadata: Record<string, unknown>\n  createdAt: Date\n}\n\n/** The full timeline aggregate — what `get_timeline_state` returns and what\n *  every operation validates against. */\nexport interface SequenceTimeline {\n  sequence: SequenceMeta\n  tracks: SequenceTrack[]\n  clips: SequenceClip[]\n}\n\n/** What is on screen/audible at a single frame — the answer shape for\n *  \"what is happening at 0:34\". */\nexport interface SequenceFrameSnapshot {\n  frame: number\n  seconds: number\n  /** Active (enabled, in-range) clips at this frame, with their track. */\n  active: Array<{ track: SequenceTrack; clip: SequenceClip }>\n  /** Caption text visible at this frame, in track sort order. */\n  captions: Array<{ text: string; language?: string; clipId: string }>\n}\n\n// ---------------------------------------------------------------------------\n// Frame math\n// ---------------------------------------------------------------------------\n\n/** Convert seconds to the nearest whole number of frames based on frames per second */\nexport function secondsToFrames(seconds: number, fps: number): number {\n  if (!Number.isFinite(seconds) || seconds < 0) throw new Error('seconds must be a non-negative finite number')\n  assertFps(fps)\n  return Math.round(seconds * fps)\n}\n\n/** Convert a frame count to seconds based on the given frames per second rate */\nexport function framesToSeconds(frames: number, fps: number): number {\n  if (!Number.isInteger(frames) || frames < 0) throw new Error('frames must be a non-negative integer')\n  assertFps(fps)\n  return frames / fps\n}\n\n/** Format a number of seconds into a string with integer or two-decimal precision suffix s */\nexport function formatSeconds(seconds: number): string {\n  return Number.isInteger(seconds) ? `${seconds}s` : `${seconds.toFixed(2)}s`\n}\n\n/** `m:ss.ff` timecode for UI and agent-readable frame references. */\nexport function formatTimecode(frames: number, fps: number): string {\n  assertFps(fps)\n  if (!Number.isInteger(frames) || frames < 0) throw new Error('frames must be a non-negative integer')\n  const totalSeconds = Math.floor(frames / fps)\n  const minutes = Math.floor(totalSeconds / 60)\n  const seconds = totalSeconds % 60\n  const residualFrames = frames % fps\n  return `${minutes}:${String(seconds).padStart(2, '0')}.${String(residualFrames).padStart(2, '0')}`\n}\n\n/** Define the start frame and duration in frames for a timeline clip's bounds */\nexport interface TimelineClipBounds {\n  startFrame: number\n  durationFrames: number\n}\n\n/** Define a time range with inclusive start and end frame numbers */\nexport interface TimelineInterval {\n  startFrame: number\n  endFrame: number\n}\n\n/** Clamp the clip start frame within the valid range of the sequence duration and clip length */\nexport function clampClipStart(input: {\n  startFrame: number\n  durationFrames: number\n  sequenceDurationFrames: number\n}): number {\n  assertSequenceDuration(input.sequenceDurationFrames)\n  assertClipDuration(input.durationFrames)\n  return Math.max(0, Math.min(input.sequenceDurationFrames - input.durationFrames, input.startFrame))\n}\n\n/** Clamp clip duration to fit within sequence bounds and minimum length constraints */\nexport function clampClipDuration(input: {\n  startFrame: number\n  durationFrames: number\n  sequenceDurationFrames: number\n}): number {\n  assertSequenceDuration(input.sequenceDurationFrames)\n  if (input.startFrame < 0 || input.startFrame >= input.sequenceDurationFrames) {\n    throw new Error('startFrame must be inside the sequence')\n  }\n  return Math.max(MIN_SEQUENCE_CLIP_FRAMES, Math.min(input.durationFrames, input.sequenceDurationFrames - input.startFrame))\n}\n\n/** Validate that a clip's start and duration fit within the sequence duration without overflow */\nexport function assertClipFitsSequence(input: {\n  startFrame: number\n  durationFrames: number\n  sequenceDurationFrames: number\n  label: string\n}): void {\n  assertSequenceDuration(input.sequenceDurationFrames)\n  assertClipDuration(input.durationFrames)\n  if (!Number.isInteger(input.startFrame) || input.startFrame < 0) {\n    throw new Error(`${input.label} startFrame must be a non-negative integer`)\n  }\n  if (input.startFrame + input.durationFrames > input.sequenceDurationFrames) {\n    throw new Error(`${input.label} extends beyond the sequence duration`)\n  }\n}\n\n/** Place a caption near the playhead inside FREE space only — the caption\n *  track never double-books. Prefers fps*3 frames, floors at fps. The gap\n *  holding (or first after) the playhead wins; with everything ahead occupied\n *  the latest earlier gap is used instead. Throws when no gap can hold the\n *  minimum — the caller must supply explicit bounds or clear space. */\nexport function chooseCaptionPlacement(input: {\n  playheadFrame: number\n  fps: number\n  sequenceDurationFrames: number\n  occupiedIntervals: TimelineInterval[]\n}): TimelineClipBounds {\n  const preferredDurationFrames = Math.min(input.fps * 3, input.sequenceDurationFrames)\n  const minimumDurationFrames = Math.min(input.fps, preferredDurationFrames)\n  const occupied = input.occupiedIntervals\n    .map((interval) => ({\n      startFrame: Math.max(0, interval.startFrame),\n      endFrame: Math.min(input.sequenceDurationFrames, interval.endFrame),\n    }))\n    .filter((interval) => interval.endFrame > interval.startFrame)\n    .sort((a, b) => a.startFrame - b.startFrame)\n\n  // Merge overlaps so the gap walk sees each free run exactly once.\n  const merged: TimelineInterval[] = []\n  for (const interval of occupied) {\n    const last = merged[merged.length - 1]\n    if (last && interval.startFrame <= last.endFrame) last.endFrame = Math.max(last.endFrame, interval.endFrame)\n    else merged.push({ ...interval })\n  }\n\n  const gaps: TimelineInterval[] = []\n  let cursor = 0\n  for (const interval of merged) {\n    if (interval.startFrame > cursor) gaps.push({ startFrame: cursor, endFrame: interval.startFrame })\n    cursor = interval.endFrame\n  }\n  if (cursor < input.sequenceDurationFrames) gaps.push({ startFrame: cursor, endFrame: input.sequenceDurationFrames })\n\n  const usable = gaps.filter((gap) => gap.endFrame - gap.startFrame >= minimumDurationFrames)\n  const latestUsable = usable[usable.length - 1]\n  if (latestUsable === undefined) {\n    throw new Error(\n      `no free gap of at least ${minimumDurationFrames} frames on the caption track — pass explicit startFrame/durationFrames or clear space first`,\n    )\n  }\n  const gap = usable.find((candidate) => candidate.endFrame > input.playheadFrame) ?? latestUsable\n  const durationFrames = Math.min(preferredDurationFrames, gap.endFrame - gap.startFrame)\n  const startFrame = Math.max(gap.startFrame, Math.min(input.playheadFrame, gap.endFrame - durationFrames))\n  return { startFrame, durationFrames }\n}\n\n/** Resolve everything active at one frame — the core of `get_frame_at_time`. */\nexport function snapshotFrame(timeline: SequenceTimeline, frame: number): SequenceFrameSnapshot {\n  if (!Number.isInteger(frame) || frame < 0) throw new Error('frame must be a non-negative integer')\n  if (frame >= timeline.sequence.durationFrames) {\n    throw new Error(`frame ${frame} is beyond the sequence (${timeline.sequence.durationFrames} frames)`)\n  }\n  const trackById = new Map(timeline.tracks.map((track) => [track.id, track]))\n  const sortedTracks = [...timeline.tracks].sort((a, b) => a.sortOrder - b.sortOrder)\n  const trackOrder = new Map(sortedTracks.map((track, index) => [track.id, index]))\n\n  const active = timeline.clips\n    .filter((clip) => !clip.disabled && clip.startFrame <= frame && frame < clip.startFrame + clip.durationFrames)\n    .map((clip) => {\n      const track = trackById.get(clip.trackId)\n      if (!track) throw new Error(`clip ${clip.id} references unknown track ${clip.trackId}`)\n      return { track, clip }\n    })\n    .sort((a, b) => (trackOrder.get(a.track.id) ?? 0) - (trackOrder.get(b.track.id) ?? 0))\n\n  const captions = active\n    .filter(({ track, clip }) => track.kind === 'caption' && typeof clip.text === 'string' && clip.text.length > 0)\n    .map(({ clip }) => ({ text: clip.text as string, language: clip.language, clipId: clip.id }))\n\n  return {\n    frame,\n    seconds: framesToSeconds(frame, timeline.sequence.fps),\n    active,\n    captions,\n  }\n}\n\n/** Occupied intervals on one track, for placement collision checks. */\nexport function trackIntervals(timeline: SequenceTimeline, trackId: string): TimelineInterval[] {\n  return timeline.clips\n    .filter((clip) => clip.trackId === trackId && !clip.disabled)\n    .map((clip) => ({ startFrame: clip.startFrame, endFrame: clip.startFrame + clip.durationFrames }))\n    .sort((a, b) => a.startFrame - b.startFrame)\n}\n\nfunction assertFps(fps: number): void {\n  if (!Number.isInteger(fps) || fps <= 0) throw new Error('fps must be a positive integer')\n}\n\nfunction assertSequenceDuration(sequenceDurationFrames: number): void {\n  if (!Number.isInteger(sequenceDurationFrames) || sequenceDurationFrames < MIN_SEQUENCE_CLIP_FRAMES) {\n    throw new Error('sequenceDurationFrames must be a positive integer')\n  }\n}\n\nfunction assertClipDuration(durationFrames: number): void {\n  if (!Number.isInteger(durationFrames) || durationFrames < MIN_SEQUENCE_CLIP_FRAMES) {\n    throw new Error('durationFrames must be a positive integer')\n  }\n}\n"],"mappings":"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","names":["gap"]}

package/dist/{chunk-RVUISYUE.js → chunk-C3NSB66C.js}

@@ -9,14 +9,14 @@ import {
   checkAttachmentType,
   sanitizeAttachmentFileName,
   sniffBinary
-} from "./chunk-K63OWUDJ.js";
+} from "./chunk-BPSV5AA2.js";
 import {
   stepActivityFlowTrace
-} from "./chunk-2QI7XV2T.js";
+} from "./chunk-FBVLEGEG.js";
 import {
   attachmentPartsFromMessageParts,
   formatBytes
-} from "./chunk-XKBIYSSM.js";
+} from "./chunk-DTSPS2HV.js";
 import {
   cancelStatusFor,
   fieldAcceptsFreeText,
@@ -26,15 +26,15 @@ import {
   parseInteractionRequest,
   persistedPartToInteraction,
   questionInteractionContentSignature
-} from "./chunk-XAWFPMAR.js";
+} from "./chunk-YKOM4ZLQ.js";
 import {
   parsePlanSubmittedEvent,
   persistedPartToPlan
-} from "./chunk-SIXYZ2FB.js";
+} from "./chunk-YJMCRXQQ.js";
 import {
   snapHarnessToModel,
   snapModelToHarness
-} from "./chunk-MCJSS6SM.js";
+} from "./chunk-CQZSAR77.js";
 
 // src/web-react/index.tsx
 import { useEffect as useEffect10, useMemo as useMemo8, useRef as useRef9, useState as useState14, memo } from "react";
@@ -3891,4 +3891,4 @@ export {
   useThinkingSeconds,
   ChatMessages
 };
-//# sourceMappingURL=chunk-RVUISYUE.js.map
+//# sourceMappingURL=chunk-C3NSB66C.js.map