@conciv/protocol 0.0.1

package/dist/harness-types.d.ts

@@ -0,0 +1,138 @@
+import { UsageSnapshot } from "./usage-types.js";
+import { StreamChunk, UIMessage } from "@tanstack/ai";
+import { Readable, Writable } from "node:stream";
+
+//#region src/harness-types.d.ts
+type HarnessCapabilities = {
+  resume: boolean;
+  permissionGate: 'hook' | 'callback' | 'none';
+  transcriptHistory: boolean;
+  compaction: boolean;
+  systemPrompt: 'file' | 'flag' | 'none';
+  mcp: 'http' | 'stdio' | 'none';
+  imageInput: 'native' | 'fileRef' | false;
+};
+type HarnessImage = {
+  mediaType: string;
+  dataBase64: string;
+};
+type HarnessModel = {
+  id: string;
+  name: string;
+  description?: string;
+  group?: string;
+  disabled?: boolean;
+};
+type HarnessModels = HarnessModel[] | (() => HarnessModel[] | Promise<HarnessModel[]>);
+type HarnessTurn = {
+  prompt: string;
+  cwd: string;
+  resumeSessionId: string | null;
+  systemPrompt: string;
+  permissionUrl?: string;
+  mcpUrl?: string;
+  sessionId?: string;
+  images?: HarnessImage[];
+  model?: string;
+  kind?: 'chat' | 'compact';
+};
+type HarnessChild = {
+  pid: number;
+  stdout: Readable;
+  stderr: Readable;
+  stdin?: Writable;
+  kill(): void;
+};
+type HarnessLaunchResult = {
+  opened: boolean;
+  command: string;
+};
+type HarnessLaunchContext = {
+  cwd: string;
+  sessionId: string | null;
+  model: string | null;
+  mcpUrl: string | null;
+  openTerminal(argv: string[]): Promise<HarnessLaunchResult>;
+  openUrl(url: string): Promise<HarnessLaunchResult>;
+};
+type HarnessLaunch = (ctx: HarnessLaunchContext) => HarnessLaunchResult | Promise<HarnessLaunchResult>;
+type HarnessArgsBuilder = (turn: HarnessTurn) => string[];
+type HarnessRunContext = {
+  sessionId: string;
+  env: Record<string, string | undefined>;
+  onSessionId(id: string): void;
+  onUsage?(usage: UsageSnapshot): void;
+  signal: AbortSignal;
+  decide(toolName: string, input: unknown, toolUseId: string): Promise<'allow' | 'deny'>;
+  runId?: string;
+  threadId?: string;
+  logger?: HarnessDecodeLogger;
+};
+type HarnessRun = (turn: HarnessTurn, ctx: HarnessRunContext) => AsyncGenerator<StreamChunk>;
+type HarnessDeliverInput = (child: HarnessChild, turn: HarnessTurn) => void | Promise<void>;
+type HarnessDecodeLogger = {
+  provider(msg: string, meta?: unknown): void;
+};
+type HarnessDecodeOpts = {
+  onSessionId(id: string): void;
+  onUsage?(usage: UsageSnapshot): void;
+  runId?: string;
+  threadId?: string;
+  logger?: HarnessDecodeLogger;
+};
+type HarnessDecoder = (lines: AsyncIterable<string>, opts: HarnessDecodeOpts) => AsyncGenerator<StreamChunk>;
+type HarnessSessionMeta = {
+  id: string;
+  derivedTitle: string;
+  updatedAt: number;
+  messageCount: number;
+  model?: string | null;
+  totalTokens?: number;
+  lastMessage?: string | null;
+  createdAt?: number;
+};
+type HarnessHistory = {
+  transcriptPath(cwd: string, sessionId: string): string;
+  parse(raw: string): UIMessage[];
+  nameFromTranscript?(raw: string): string | null;
+  list?(cwd: string, home?: string): HarnessSessionMeta[] | Promise<HarnessSessionMeta[]>;
+};
+type HarnessAdapterBase = {
+  id: string;
+  binName: string;
+  displayName?: string;
+  launch?: HarnessLaunch;
+  buildArgs: HarnessArgsBuilder;
+  buildCompactArgs?: HarnessArgsBuilder;
+  decode: HarnessDecoder;
+  deliverInput?: HarnessDeliverInput;
+  run?: HarnessRun;
+  shutdown?: () => void | Promise<void>;
+  models?: HarnessModels;
+  defaultModel?: string;
+};
+type HarnessAdapter = HarnessAdapterBase & ({
+  capabilities: HarnessCapabilities & {
+    transcriptHistory: true;
+  };
+  history: HarnessHistory;
+} | {
+  capabilities: HarnessCapabilities & {
+    transcriptHistory: false;
+  };
+  history?: undefined;
+}) & ({
+  capabilities: HarnessCapabilities & {
+    compaction: true;
+  };
+  buildCompactArgs: HarnessArgsBuilder;
+} | {
+  capabilities: HarnessCapabilities & {
+    compaction: false;
+  };
+  buildCompactArgs?: undefined;
+});
+declare function defineHarness<T extends HarnessAdapter>(adapter: T): T;
+//#endregion
+export { HarnessAdapter, HarnessArgsBuilder, HarnessCapabilities, HarnessChild, HarnessDecodeLogger, HarnessDecodeOpts, HarnessDecoder, HarnessDeliverInput, HarnessHistory, HarnessImage, HarnessLaunch, HarnessLaunchContext, HarnessLaunchResult, HarnessModel, HarnessModels, HarnessRun, HarnessRunContext, HarnessSessionMeta, HarnessTurn, defineHarness };
+//# sourceMappingURL=harness-types.d.ts.map

package/dist/harness-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness-types.d.ts","names":[],"sources":["../src/harness-types.ts"],"mappings":"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"}

package/dist/harness-types.js

@@ -0,0 +1,8 @@
+//#region src/harness-types.ts
+function defineHarness(adapter) {
+	return adapter;
+}
+//#endregion
+export { defineHarness };
+
+//# sourceMappingURL=harness-types.js.map

package/dist/harness-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness-types.js","names":[],"sources":["../src/harness-types.ts"],"sourcesContent":["import type {Readable, Writable} from 'node:stream'\nimport type {StreamChunk, UIMessage} from '@tanstack/ai'\nimport type {UsageSnapshot} from './usage-types.js'\n\n// A harness is the underlying coding agent CLI (claude, codex, …). Core resolves a\n// HarnessAdapter and feature-detects by capability, degrading gracefully when one is absent.\n\nexport type HarnessCapabilities = {\n  resume: boolean\n  permissionGate: 'hook' | 'callback' | 'none'\n  transcriptHistory: boolean\n  // Native context compaction (the agent rewrites its own context to a summary, freeing the window).\n  // true → the adapter must supply `buildCompactArgs` (type-enforced below). false → core falls back\n  // to a summarize-prompt turn, which produces a summary but does not free the resumed context.\n  compaction: boolean\n  systemPrompt: 'file' | 'flag' | 'none'\n  mcp: 'http' | 'stdio' | 'none'\n  // 'native'  → ingests image content blocks (claude: --input-format stream-json on stdin)\n  // 'fileRef' → no vision channel; server writes temp files + appends path refs to the prompt\n  // false     → no image support\n  imageInput: 'native' | 'fileRef' | false\n}\n\n// An image content part carried from chat()'s messages to the harness (base64 data source).\nexport type HarnessImage = {mediaType: string; dataBase64: string}\n\n// A model the harness can run. `id` is what the CLI receives (e.g. claude --model <id>); `name`\n// is the display label; `group` buckets the combobox by provider/family.\nexport type HarnessModel = {id: string; name: string; description?: string; group?: string; disabled?: boolean}\n\n// A harness's models: either a static list or a (possibly async) resolver, so an adapter that\n// can enumerate its CLI's models at runtime returns a function instead of a literal array.\nexport type HarnessModels = HarnessModel[] | (() => HarnessModel[] | Promise<HarnessModel[]>)\n\nexport type HarnessTurn = {\n  prompt: string\n  cwd: string\n  resumeSessionId: string | null\n  systemPrompt: string\n  permissionUrl?: string\n  mcpUrl?: string\n  // The conciv chat session this turn runs in; rides the MCP config as a header so session-scoped\n  // tools (canvas.draw, comments) resolve the same room the widget joined.\n  sessionId?: string\n  images?: HarnessImage[]\n  // The selected model id, forwarded by buildArgs to the CLI's model flag. Absent → CLI default.\n  model?: string\n  // 'compact' → core wants this turn to compact the resumed context, not chat. The adapter's\n  // buildCompactArgs builds it (only reached for compaction-capable harnesses). Default 'chat'.\n  kind?: 'chat' | 'compact'\n}\n\nexport type HarnessChild = {pid: number; stdout: Readable; stderr: Readable; stdin?: Writable; kill(): void}\n\n// \"Open in <harness>\": reopen a chat session as the harness's own interactive CLI in a terminal.\n// Core owns the open logic (OS detection, cwd, shell quoting, spawning) and hands it to the harness\n// via the context's open* methods; the harness only builds the interactive argv.\nexport type HarnessLaunchResult = {opened: boolean; command: string}\nexport type HarnessLaunchContext = {\n  cwd: string\n  sessionId: string | null\n  model: string | null // the model the widget currently has selected, mirrored from the chat turn\n  mcpUrl: string | null // the conciv MCP-over-HTTP endpoint, for tool parity (null if not http-capable)\n  // Run `argv` in an interactive terminal at cwd. Core shell-quotes it, prepends `cd`, spawns the\n  // per-OS terminal, and returns {opened, command} — command is the resolved paste-able fallback.\n  openTerminal(argv: string[]): Promise<HarnessLaunchResult>\n  openUrl(url: string): Promise<HarnessLaunchResult>\n}\nexport type HarnessLaunch = (ctx: HarnessLaunchContext) => HarnessLaunchResult | Promise<HarnessLaunchResult>\n\n// Builds the CLI argv for one turn.\nexport type HarnessArgsBuilder = (turn: HarnessTurn) => string[]\n\n// In-process turn runner (SDK transport): core branches to this in place of buildArgs/spawn/decode.\nexport type HarnessRunContext = {\n  sessionId: string\n  env: Record<string, string | undefined>\n  onSessionId(id: string): void\n  onUsage?(usage: UsageSnapshot): void\n  signal: AbortSignal\n  decide(toolName: string, input: unknown, toolUseId: string): Promise<'allow' | 'deny'>\n  runId?: string\n  threadId?: string\n  logger?: HarnessDecodeLogger\n}\nexport type HarnessRun = (turn: HarnessTurn, ctx: HarnessRunContext) => AsyncGenerator<StreamChunk>\n\n// Optional: write the turn's input to the child after spawn (e.g. claude native images →\n// a stream-json user message on stdin). Harnesses that take everything via argv omit it.\nexport type HarnessDeliverInput = (child: HarnessChild, turn: HarnessTurn) => void | Promise<void>\n\n// Minimal logger shape the adapter threads in (matches @tanstack/ai InternalLogger surface we use).\nexport type HarnessDecodeLogger = {provider(msg: string, meta?: unknown): void}\n\nexport type HarnessDecodeOpts = {\n  onSessionId(id: string): void\n  // Live usage as the harness learns it mid-turn (claude message_start carries full context at the\n  // start of the response). Core injects it onto the stream for the widget's tracker.\n  onUsage?(usage: UsageSnapshot): void\n  runId?: string\n  threadId?: string\n  logger?: HarnessDecodeLogger\n}\n\n// Turns the harness's raw stdout lines into the AG-UI StreamChunk stream, surfacing the session id.\nexport type HarnessDecoder = (lines: AsyncIterable<string>, opts: HarnessDecodeOpts) => AsyncGenerator<StreamChunk>\n\n// One enumerated session from a harness's transcript store (for the session selector list). The\n// enrichment fields (gathered when cheap) are joined onto selector rows / persisted onto the record.\nexport type HarnessSessionMeta = {\n  id: string\n  derivedTitle: string\n  updatedAt: number\n  messageCount: number\n  model?: string | null\n  totalTokens?: number\n  lastMessage?: string | null\n  createdAt?: number\n}\n\n// Where a harness persists a session's transcript, and how to parse it into UIMessages.\nexport type HarnessHistory = {\n  transcriptPath(cwd: string, sessionId: string): string\n  parse(raw: string): UIMessage[]\n  // Optional human-readable session name derived from the transcript (e.g. claude's `summary`\n  // record). Harnesses that omit it fall back to a short id in the UI.\n  nameFromTranscript?(raw: string): string | null\n  // Enumerate the cwd's sessions, newest first, bounded. `home` is injectable for testing. Optional\n  // so a transcript adapter without enumeration still typechecks (the selector just stays empty).\n  list?(cwd: string, home?: string): HarnessSessionMeta[] | Promise<HarnessSessionMeta[]>\n}\n\ntype HarnessAdapterBase = {\n  id: string\n  binName: string\n  // Human label for \"Open in <displayName>\" and other UI; falls back to id when absent.\n  displayName?: string\n  // How to reopen a session as this harness's interactive CLI. Absent → \"open in <harness>\" is\n  // unavailable (core reports unsupported, the widget hides the button).\n  launch?: HarnessLaunch\n  buildArgs: HarnessArgsBuilder\n  // Builds the argv for a compaction turn. Present iff capabilities.compaction (enforced by the\n  // adapter union below), mirroring how transcriptHistory enforces `history`.\n  buildCompactArgs?: HarnessArgsBuilder\n  decode: HarnessDecoder\n  deliverInput?: HarnessDeliverInput\n  run?: HarnessRun\n  shutdown?: () => void | Promise<void>\n  // Models this harness can run + the id to pre-select. Both optional: a harness with no model\n  // choice omits them and the widget hides its selector.\n  models?: HarnessModels\n  defaultModel?: string\n}\n\n// `history` is present iff `capabilities.transcriptHistory` and `buildCompactArgs` iff\n// `capabilities.compaction` — the type enforces both, so there is no runtime check: a\n// transcriptHistory:true adapter without a history (or a compaction:true adapter without\n// buildCompactArgs) is a compile error.\nexport type HarnessAdapter = HarnessAdapterBase &\n  (\n    | {capabilities: HarnessCapabilities & {transcriptHistory: true}; history: HarnessHistory}\n    | {capabilities: HarnessCapabilities & {transcriptHistory: false}; history?: undefined}\n  ) &\n  (\n    | {capabilities: HarnessCapabilities & {compaction: true}; buildCompactArgs: HarnessArgsBuilder}\n    | {capabilities: HarnessCapabilities & {compaction: false}; buildCompactArgs?: undefined}\n  )\n\nexport function defineHarness<T extends HarnessAdapter>(adapter: T): T {\n  return adapter\n}\n"],"mappings":";AAwKA,SAAgB,cAAwC,SAAe;CACrE,OAAO;AACT"}

package/dist/page-introspect-types.d.ts

@@ -0,0 +1,55 @@
+//#region src/page-introspect-types.d.ts
+type RawFrame = {
+  fileName?: string;
+  line?: number;
+  column?: number;
+  fn?: string;
+};
+type SourceLoc = {
+  file: string;
+  line: number;
+  column: number;
+};
+type Owner = {
+  component: string;
+  ref: string;
+};
+type LocateResult = {
+  component: string | null;
+  stack: string[];
+  frames: RawFrame[];
+  owners: Owner[];
+  source?: SourceLoc;
+};
+type TreeNode = {
+  component: string;
+  ref: string;
+  children: TreeNode[];
+  truncated?: number;
+};
+type HookNode = {
+  id: number;
+  name: string;
+  value: unknown;
+  editable: boolean;
+};
+type Rect = {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+};
+type InspectResult = {
+  component: string | null;
+  props: unknown;
+  state: unknown;
+  hooks: HookNode[];
+  rect: Rect | null;
+};
+type TreeResult = {
+  nodes: TreeNode[];
+  truncated: number;
+};
+//#endregion
+export { HookNode, InspectResult, LocateResult, Owner, RawFrame, Rect, SourceLoc, TreeNode, TreeResult };
+//# sourceMappingURL=page-introspect-types.d.ts.map

package/dist/page-introspect-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-introspect-types.d.ts","names":[],"sources":["../src/page-introspect-types.ts"],"mappings":";KACY,QAAA;EAAY,QAAA;EAAmB,IAAA;EAAe,MAAA;EAAiB,EAAA;AAAA;AAAA,KAC/D,SAAA;EAAa,IAAA;EAAc,IAAA;EAAc,MAAA;AAAA;AAAA,KACzC,KAAA;EAAS,SAAA;EAAmB,GAAG;AAAA;AAAA,KAC/B,YAAA;EACV,SAAA;EACA,KAAA;EACA,MAAA,EAAQ,QAAA;EACR,MAAA,EAAQ,KAAA;EAGR,MAAA,GAAS,SAAA;AAAA;AAAA,KAEC,QAAA;EAAY,SAAA;EAAmB,GAAA;EAAa,QAAA,EAAU,QAAQ;EAAI,SAAA;AAAA;AAAA,KAClE,QAAA;EAAY,EAAA;EAAY,IAAA;EAAc,KAAA;EAAgB,QAAA;AAAA;AAAA,KACtD,IAAA;EAAQ,CAAA;EAAW,CAAA;EAAW,CAAA;EAAW,CAAA;AAAA;AAAA,KACzC,aAAA;EACV,SAAA;EACA,KAAA;EACA,KAAA;EACA,KAAA,EAAO,QAAA;EAGP,IAAA,EAAM,IAAI;AAAA;AAAA,KAEA,UAAA;EAAc,KAAA,EAAO,QAAQ;EAAI,SAAA;AAAA"}

package/dist/page-introspect-types.js

@@ -0,0 +1 @@
+export {};

package/dist/page-types.d.ts

@@ -0,0 +1,222 @@
+import { z } from "zod";
+
+//#region src/page-types.d.ts
+declare const PAGE_QUERY_KINDS: readonly ["route", "dom", "query", "console", "text", "value", "attr", "exists", "snapshot", "locate", "tree", "inspect", "override", "find", "track", "effect", "wait", "click", "fill", "select", "check", "uncheck", "press", "hover", "scroll", "submit", "setattr", "removeattr", "addclass", "removeclass", "setstyle", "settext", "sethtml", "remove", "insert", "css", "eval"];
+type PageQueryKind = (typeof PAGE_QUERY_KINDS)[number];
+declare const MUTATING_KINDS: readonly ["override", "click", "fill", "select", "check", "uncheck", "press", "hover", "scroll", "submit", "setattr", "removeattr", "addclass", "removeclass", "setstyle", "settext", "sethtml", "remove", "insert", "css", "eval"];
+declare const MIRROR_KINDS: readonly ["click", "fill", "select", "check", "uncheck", "press", "hover", "scroll", "submit"];
+declare function mirrorsKind(kind: PageQueryKind): boolean;
+declare const PageQueryKindSchema: z.ZodEnum<{
+  value: "value";
+  check: "check";
+  text: "text";
+  select: "select";
+  route: "route";
+  dom: "dom";
+  query: "query";
+  console: "console";
+  attr: "attr";
+  exists: "exists";
+  snapshot: "snapshot";
+  locate: "locate";
+  tree: "tree";
+  inspect: "inspect";
+  override: "override";
+  find: "find";
+  track: "track";
+  effect: "effect";
+  wait: "wait";
+  click: "click";
+  fill: "fill";
+  uncheck: "uncheck";
+  press: "press";
+  hover: "hover";
+  scroll: "scroll";
+  submit: "submit";
+  setattr: "setattr";
+  removeattr: "removeattr";
+  addclass: "addclass";
+  removeclass: "removeclass";
+  setstyle: "setstyle";
+  settext: "settext";
+  sethtml: "sethtml";
+  remove: "remove";
+  insert: "insert";
+  css: "css";
+  eval: "eval";
+}>;
+declare const PagePositionSchema: z.ZodEnum<{
+  before: "before";
+  after: "after";
+  prepend: "prepend";
+  append: "append";
+}>;
+declare const PageWaitStateSchema: z.ZodEnum<{
+  visible: "visible";
+  hidden: "hidden";
+}>;
+type PagePosition = z.infer<typeof PagePositionSchema>;
+type PageWaitState = z.infer<typeof PageWaitStateSchema>;
+declare const PageQuerySchema: z.ZodObject<{
+  requestId: z.ZodOptional<z.ZodString>;
+  kind: z.ZodEnum<{
+    value: "value";
+    check: "check";
+    text: "text";
+    select: "select";
+    route: "route";
+    dom: "dom";
+    query: "query";
+    console: "console";
+    attr: "attr";
+    exists: "exists";
+    snapshot: "snapshot";
+    locate: "locate";
+    tree: "tree";
+    inspect: "inspect";
+    override: "override";
+    find: "find";
+    track: "track";
+    effect: "effect";
+    wait: "wait";
+    click: "click";
+    fill: "fill";
+    uncheck: "uncheck";
+    press: "press";
+    hover: "hover";
+    scroll: "scroll";
+    submit: "submit";
+    setattr: "setattr";
+    removeattr: "removeattr";
+    addclass: "addclass";
+    removeclass: "removeclass";
+    setstyle: "setstyle";
+    settext: "settext";
+    sethtml: "sethtml";
+    remove: "remove";
+    insert: "insert";
+    css: "css";
+    eval: "eval";
+  }>;
+  selector: z.ZodOptional<z.ZodString>;
+  ref: z.ZodOptional<z.ZodString>;
+  since: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  value: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  class: z.ZodOptional<z.ZodString>;
+  prop: z.ZodOptional<z.ZodString>;
+  text: z.ZodOptional<z.ZodString>;
+  html: z.ZodOptional<z.ZodString>;
+  key: z.ZodOptional<z.ZodString>;
+  position: z.ZodOptional<z.ZodEnum<{
+    before: "before";
+    after: "after";
+    prepend: "prepend";
+    append: "append";
+  }>>;
+  state: z.ZodOptional<z.ZodEnum<{
+    visible: "visible";
+    hidden: "hidden";
+  }>>;
+  timeout: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  code: z.ZodOptional<z.ZodString>;
+  path: z.ZodOptional<z.ZodString>;
+  target: z.ZodOptional<z.ZodEnum<{
+    state: "state";
+    props: "props";
+    hooks: "hooks";
+    context: "context";
+  }>>;
+  hookId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  json: z.ZodOptional<z.ZodString>;
+  effect: z.ZodOptional<z.ZodString>;
+  action: z.ZodOptional<z.ZodEnum<{
+    start: "start";
+    stop: "stop";
+    report: "report";
+    enable: "enable";
+    disable: "disable";
+    toggle: "toggle";
+    list: "list";
+  }>>;
+}, z.core.$strip>;
+type PageQuery = z.infer<typeof PageQuerySchema>;
+declare const PageQueryInputSchema: z.ZodObject<{
+  value: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  path: z.ZodOptional<z.ZodString>;
+  code: z.ZodOptional<z.ZodString>;
+  text: z.ZodOptional<z.ZodString>;
+  effect: z.ZodOptional<z.ZodString>;
+  selector: z.ZodOptional<z.ZodString>;
+  ref: z.ZodOptional<z.ZodString>;
+  since: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  class: z.ZodOptional<z.ZodString>;
+  prop: z.ZodOptional<z.ZodString>;
+  html: z.ZodOptional<z.ZodString>;
+  key: z.ZodOptional<z.ZodString>;
+  position: z.ZodOptional<z.ZodEnum<{
+    before: "before";
+    after: "after";
+    prepend: "prepend";
+    append: "append";
+  }>>;
+  state: z.ZodOptional<z.ZodEnum<{
+    visible: "visible";
+    hidden: "hidden";
+  }>>;
+  timeout: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  target: z.ZodOptional<z.ZodEnum<{
+    state: "state";
+    props: "props";
+    hooks: "hooks";
+    context: "context";
+  }>>;
+  hookId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  json: z.ZodOptional<z.ZodString>;
+  action: z.ZodOptional<z.ZodEnum<{
+    start: "start";
+    stop: "stop";
+    report: "report";
+    enable: "enable";
+    disable: "disable";
+    toggle: "toggle";
+    list: "list";
+  }>>;
+}, z.core.$strip>;
+type PageQueryInput = z.infer<typeof PageQueryInputSchema>;
+declare const PageReplySchema: z.ZodObject<{
+  requestId: z.ZodString;
+  data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type PageReply = z.infer<typeof PageReplySchema>;
+type PageResult = Record<string, unknown>;
+declare function ok(data?: Record<string, unknown>): PageResult;
+declare function err(message: string): PageResult;
+declare function isError(result: PageResult): boolean;
+declare function isMutating(kind: string): boolean;
+declare const RawFrameSchema: z.ZodObject<{
+  fileName: z.ZodOptional<z.ZodString>;
+  line: z.ZodOptional<z.ZodNumber>;
+  column: z.ZodOptional<z.ZodNumber>;
+  fn: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const OpenSourceSchema: z.ZodObject<{
+  frames: z.ZodArray<z.ZodObject<{
+    fileName: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    column: z.ZodOptional<z.ZodNumber>;
+    fn: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const OpenSourceResultSchema: z.ZodObject<{
+  status: z.ZodEnum<{
+    opened: "opened";
+    "no-source": "no-source";
+    failed: "failed";
+  }>;
+}, z.core.$strip>;
+type OpenSourceResult = z.infer<typeof OpenSourceResultSchema>['status'];
+//#endregion
+export { MIRROR_KINDS, MUTATING_KINDS, OpenSourceResult, OpenSourceResultSchema, OpenSourceSchema, PAGE_QUERY_KINDS, PagePosition, PagePositionSchema, PageQuery, PageQueryInput, PageQueryInputSchema, PageQueryKind, PageQueryKindSchema, PageQuerySchema, PageReply, PageReplySchema, PageResult, PageWaitState, PageWaitStateSchema, RawFrameSchema, err, isError, isMutating, mirrorsKind, ok };
+//# sourceMappingURL=page-types.d.ts.map

package/dist/page-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-types.d.ts","names":[],"sources":["../src/page-types.ts"],"mappings":";;;cAKa,gBAAA;AAAA,KAwCD,aAAA,WAAwB,gBAAgB;AAAA,cAEvC,cAAA;AAAA,cA2BA,YAAA;AAAA,iBAYG,WAAA,CAAY,IAAmB,EAAb,aAAa;AAAA,cAIlC,mBAAA,EAAmB,CAAA,CAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cACnB,kBAAA,EAAkB,CAAA,CAAA,OAAA;;;;;;cAClB,mBAAA,EAAmB,CAAA,CAAA,OAAA;;;;KAEpB,YAAA,GAAe,CAAA,CAAE,KAAK,QAAQ,kBAAA;AAAA,KAC9B,aAAA,GAAgB,CAAA,CAAE,KAAK,QAAQ,mBAAA;AAAA,cAE9B,eAAA,EAAe,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6BhB,SAAA,GAAY,CAAA,CAAE,KAAK,QAAQ,eAAA;AAAA,cAE1B,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACrB,cAAA,GAAiB,CAAA,CAAE,KAAK,QAAQ,oBAAA;AAAA,cAI/B,eAAA,EAAe,CAAA,CAAA,SAAA;;;;KAChB,SAAA,GAAY,CAAA,CAAE,KAAK,QAAQ,eAAA;AAAA,KAG3B,UAAA,GAAa,MAAM;AAAA,iBAEf,EAAA,CAAG,IAAA,GAAM,MAAA,oBAA+B,UAAU;AAAA,iBAGlD,GAAA,CAAI,OAAA,WAAkB,UAAU;AAAA,iBAGhC,OAAA,CAAQ,MAAkB,EAAV,UAAU;AAAA,iBAK1B,UAAA,CAAW,IAAY;AAAA,cAI1B,cAAA,EAAc,CAAA,CAAA,SAAA;;;;;;cAMd,gBAAA,EAAgB,CAAA,CAAA,SAAA;;;;;;;;cAChB,sBAAA,EAAsB,CAAA,CAAA,SAAA;;;;;;;KACvB,gBAAA,GAAmB,CAAA,CAAE,KAAK,QAAQ,sBAAA"}

package/dist/page-types.js

@@ -0,0 +1,163 @@
+import { z } from "zod";
+//#region src/page-types.ts
+const PAGE_QUERY_KINDS = [
+	"route",
+	"dom",
+	"query",
+	"console",
+	"text",
+	"value",
+	"attr",
+	"exists",
+	"snapshot",
+	"locate",
+	"tree",
+	"inspect",
+	"override",
+	"find",
+	"track",
+	"effect",
+	"wait",
+	"click",
+	"fill",
+	"select",
+	"check",
+	"uncheck",
+	"press",
+	"hover",
+	"scroll",
+	"submit",
+	"setattr",
+	"removeattr",
+	"addclass",
+	"removeclass",
+	"setstyle",
+	"settext",
+	"sethtml",
+	"remove",
+	"insert",
+	"css",
+	"eval"
+];
+const MUTATING_KINDS = [
+	"override",
+	"click",
+	"fill",
+	"select",
+	"check",
+	"uncheck",
+	"press",
+	"hover",
+	"scroll",
+	"submit",
+	"setattr",
+	"removeattr",
+	"addclass",
+	"removeclass",
+	"setstyle",
+	"settext",
+	"sethtml",
+	"remove",
+	"insert",
+	"css",
+	"eval"
+];
+const MIRROR_KINDS = [
+	"click",
+	"fill",
+	"select",
+	"check",
+	"uncheck",
+	"press",
+	"hover",
+	"scroll",
+	"submit"
+];
+function mirrorsKind(kind) {
+	return MIRROR_KINDS.includes(kind);
+}
+const PageQueryKindSchema = z.enum(PAGE_QUERY_KINDS);
+const PagePositionSchema = z.enum([
+	"before",
+	"after",
+	"prepend",
+	"append"
+]);
+const PageWaitStateSchema = z.enum(["visible", "hidden"]);
+const PageQuerySchema = z.object({
+	requestId: z.string().optional(),
+	kind: PageQueryKindSchema,
+	selector: z.string().optional(),
+	ref: z.string().optional(),
+	since: z.coerce.number().optional(),
+	value: z.string().optional(),
+	name: z.string().optional(),
+	class: z.string().optional(),
+	prop: z.string().optional(),
+	text: z.string().optional(),
+	html: z.string().optional(),
+	key: z.string().optional(),
+	position: PagePositionSchema.optional(),
+	state: PageWaitStateSchema.optional(),
+	timeout: z.coerce.number().optional(),
+	code: z.string().optional(),
+	path: z.string().optional(),
+	target: z.enum([
+		"props",
+		"state",
+		"hooks",
+		"context"
+	]).optional(),
+	hookId: z.coerce.number().optional(),
+	json: z.string().optional(),
+	effect: z.string().optional(),
+	action: z.enum([
+		"start",
+		"stop",
+		"report",
+		"enable",
+		"disable",
+		"toggle",
+		"list"
+	]).optional()
+});
+const PageQueryInputSchema = PageQuerySchema.omit({
+	kind: true,
+	requestId: true
+});
+const PageReplySchema = z.object({
+	requestId: z.string(),
+	data: z.record(z.string(), z.unknown()).default({})
+});
+function ok(data = {}) {
+	return {
+		ok: true,
+		...data
+	};
+}
+function err(message) {
+	return { error: message };
+}
+function isError(result) {
+	return typeof result.error === "string";
+}
+const MUTATING = new Set(MUTATING_KINDS);
+function isMutating(kind) {
+	return MUTATING.has(kind);
+}
+const RawFrameSchema = z.object({
+	fileName: z.string().optional(),
+	line: z.number().optional(),
+	column: z.number().optional(),
+	fn: z.string().optional()
+});
+const OpenSourceSchema = z.object({ frames: z.array(RawFrameSchema) });
+const OpenSourceResultSchema = z.object({ status: z.enum([
+	"opened",
+	"no-source",
+	"failed"
+]) });
+//#endregion
+export { MIRROR_KINDS, MUTATING_KINDS, OpenSourceResultSchema, OpenSourceSchema, PAGE_QUERY_KINDS, PagePositionSchema, PageQueryInputSchema, PageQueryKindSchema, PageQuerySchema, PageReplySchema, PageWaitStateSchema, RawFrameSchema, err, isError, isMutating, mirrorsKind, ok };
+
+//# sourceMappingURL=page-types.js.map

package/dist/page-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-types.js","names":[],"sources":["../src/page-types.ts"],"sourcesContent":["import {z} from 'zod'\n\n// The single source of truth for the page-bus contract, shared by core (server) and the\n// widget (browser). The kind union is derived from a runtime array so a contract test can\n// assert the verb table + handler registry never drift from it.\nexport const PAGE_QUERY_KINDS = [\n  'route',\n  'dom',\n  'query',\n  'console',\n  'text',\n  'value',\n  'attr',\n  'exists',\n  'snapshot',\n  'locate',\n  'tree',\n  'inspect',\n  'override',\n  'find',\n  'track',\n  'effect',\n  'wait',\n  'click',\n  'fill',\n  'select',\n  'check',\n  'uncheck',\n  'press',\n  'hover',\n  'scroll',\n  'submit',\n  'setattr',\n  'removeattr',\n  'addclass',\n  'removeclass',\n  'setstyle',\n  'settext',\n  'sethtml',\n  'remove',\n  'insert',\n  'css',\n  'eval',\n] as const\n\nexport type PageQueryKind = (typeof PAGE_QUERY_KINDS)[number]\n\nexport const MUTATING_KINDS = [\n  'override',\n  'click',\n  'fill',\n  'select',\n  'check',\n  'uncheck',\n  'press',\n  'hover',\n  'scroll',\n  'submit',\n  'setattr',\n  'removeattr',\n  'addclass',\n  'removeclass',\n  'setstyle',\n  'settext',\n  'sethtml',\n  'remove',\n  'insert',\n  'css',\n  'eval',\n] as const satisfies readonly PageQueryKind[]\n\n// Visual action verbs that move/affect a visible element — the ones worth mirroring on the real page\n// (cursor glide + ring) and flagging in the tool card. Shared so the widget's page-mirror and the\n// tool-ui card never drift on which actions claim \"shown on your page\". Non-visual reads are excluded.\nexport const MIRROR_KINDS = [\n  'click',\n  'fill',\n  'select',\n  'check',\n  'uncheck',\n  'press',\n  'hover',\n  'scroll',\n  'submit',\n] as const satisfies readonly PageQueryKind[]\n\nexport function mirrorsKind(kind: PageQueryKind): boolean {\n  return (MIRROR_KINDS as readonly PageQueryKind[]).includes(kind)\n}\n\nexport const PageQueryKindSchema = z.enum(PAGE_QUERY_KINDS)\nexport const PagePositionSchema = z.enum(['before', 'after', 'prepend', 'append'])\nexport const PageWaitStateSchema = z.enum(['visible', 'hidden'])\n\nexport type PagePosition = z.infer<typeof PagePositionSchema>\nexport type PageWaitState = z.infer<typeof PageWaitStateSchema>\n\nexport const PageQuerySchema = z.object({\n  requestId: z.string().optional(),\n  kind: PageQueryKindSchema,\n  selector: z.string().optional(),\n  ref: z.string().optional(),\n  since: z.coerce.number().optional(),\n  value: z.string().optional(),\n  name: z.string().optional(),\n  class: z.string().optional(),\n  prop: z.string().optional(),\n  text: z.string().optional(),\n  html: z.string().optional(),\n  key: z.string().optional(),\n  position: PagePositionSchema.optional(),\n  state: PageWaitStateSchema.optional(),\n  timeout: z.coerce.number().optional(),\n  code: z.string().optional(),\n  // Dot-path into an inspect result for drill-down, e.g. \"props.user.address\" or \"hooks.0.value\".\n  // Numeric segments index arrays. Stays a plain string so it rides the query-string + MCP alike.\n  path: z.string().optional(),\n  // override verb: which slice to edit, the hook id (from inspect's hooks tree), and the new value\n  // as a JSON-encoded string (so `42`, `\"text\"`, `{\"a\":1}` are unambiguous over query-string + MCP).\n  target: z.enum(['props', 'state', 'hooks', 'context']).optional(),\n  hookId: z.coerce.number().optional(),\n  json: z.string().optional(),\n  effect: z.string().optional(),\n  action: z.enum(['start', 'stop', 'report', 'enable', 'disable', 'toggle', 'list']).optional(),\n})\n\nexport type PageQuery = z.infer<typeof PageQuerySchema>\n\nexport const PageQueryInputSchema = PageQuerySchema.omit({kind: true, requestId: true})\nexport type PageQueryInput = z.infer<typeof PageQueryInputSchema>\n\n// POST /api/page/reply body — the widget's answer to a pushed PageQuery. Shared by core (validation)\n// and the widget transport (typing) so the two ends can't drift.\nexport const PageReplySchema = z.object({requestId: z.string(), data: z.record(z.string(), z.unknown()).default({})})\nexport type PageReply = z.infer<typeof PageReplySchema>\n\n// A reply is always a plain JSON object: either an error or some data (often {ok:true}).\nexport type PageResult = Record<string, unknown>\n\nexport function ok(data: Record<string, unknown> = {}): PageResult {\n  return {ok: true, ...data}\n}\nexport function err(message: string): PageResult {\n  return {error: message}\n}\nexport function isError(result: PageResult): boolean {\n  return typeof result.error === 'string'\n}\n\nconst MUTATING = new Set<string>(MUTATING_KINDS)\nexport function isMutating(kind: string): boolean {\n  return MUTATING.has(kind)\n}\n\nexport const RawFrameSchema = z.object({\n  fileName: z.string().optional(),\n  line: z.number().optional(),\n  column: z.number().optional(),\n  fn: z.string().optional(),\n})\nexport const OpenSourceSchema = z.object({frames: z.array(RawFrameSchema)})\nexport const OpenSourceResultSchema = z.object({status: z.enum(['opened', 'no-source', 'failed'])})\nexport type OpenSourceResult = z.infer<typeof OpenSourceResultSchema>['status']\n"],"mappings":"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"}

package/dist/tool-timing.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { StreamChunk } from "@tanstack/ai";
+
+//#region src/tool-timing.d.ts
+declare const CONCIV_TOOL_DURATION_EVENT = "conciv-tool-duration";
+declare const ToolDurationSchema: z.ZodObject<{
+  toolCallId: z.ZodString;
+  durationMs: z.ZodNumber;
+}, z.core.$strip>;
+type ToolDuration = z.infer<typeof ToolDurationSchema>;
+declare function aguiToolDurationFor(toolCallId: string, durationMs: number): StreamChunk;
+//#endregion
+export { CONCIV_TOOL_DURATION_EVENT, ToolDuration, ToolDurationSchema, aguiToolDurationFor };
+//# sourceMappingURL=tool-timing.d.ts.map

package/dist/tool-timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-timing.d.ts","names":[],"sources":["../src/tool-timing.ts"],"mappings":";;;;cAGa,0BAAA;AAAA,cAEA,kBAAA,EAAkB,CAAA,CAAA,SAAA;;;;KACnB,YAAA,GAAe,CAAA,CAAE,KAAK,QAAQ,kBAAA;AAAA,iBAE1B,mBAAA,CAAoB,UAAA,UAAoB,UAAA,WAAqB,WAAW"}