@vibesdotdev/tools 0.0.0-stage → 1.0.0-rc.4

package/dist/docs/tools.docs.descriptor.js

@@ -0,0 +1,51 @@
+const toolsMarkdown = `---
+title: Tools
+summary: Listing, invocation, providers, and UI.
+parent: 
+order: 7
+---
+
+# Tools
+
+Listing, invocation, providers, and UI. Tools are descriptors of kind \`tools/tool\` resolved through the runtime and surfaced to agents via \`runtime.query('tools/tool')\`.
+
+## When to use
+
+Reach for this area when you need to expose a capability to an agent — a function it can call, with a typed schema and an implementation that runs in the consumer or cloud scope.
+
+## How it resolves
+
+Tools are runtime-resolved descriptors of kind \`tools/tool\`. Resolve one from app code via the runtime:
+
+\`\`\`ts
+import type { VibesRuntime } from '@vibesdotdev/kernel';
+// The handed runtime: context.runtime in a command, event.locals.runtime in SvelteKit.
+declare const runtime: VibesRuntime;
+const tool = await runtime.query('tools/tool').first();
+\`\`\`
+
+:::card{title="In this section"}
+- [\`tools.list\`](tools.list) — Tools List
+- [\`tools.invoke\`](tools.invoke) — Tool Invocation
+- [\`tools.adapters\`](tools.providers) — Tool Adapters
+- [\`tools.ui\`](tools.ui) — Tool UI
+:::
+`;
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'tools',
+    title: 'Tools',
+    summary: "Listing, invocation, providers, and UI.",
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: toolsMarkdown
+    },
+    order: 7,
+    tags: ['tools', 'overview'],
+    surfaces: ['web', 'in-app'],
+    hardware: ['consumer', 'cloud'],
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=tools.docs.descriptor.js.map

package/dist/docs/tools.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/tools.docs.descriptor.ts"],"names":[],"mappings":"AAEA,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCrB,CAAC;AAEF,MAAM,UAAU,GAAwB;IACvC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,OAAO;IACX,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,yCAAyC;IAClD,IAAI,EAAE;QACL,IAAI,EAAE,UAAU;QAChB,UAAU,EAAE,KAAK;QACjB,MAAM,EAAE,aAAa;KACrB;IACD,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC;IAC3B,QAAQ,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC;IAC3B,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,OAAO,EAAE,IAAI;CACb,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/tools.providers.docs.descriptor.d.ts

@@ -0,0 +1,4 @@
+import type { DocsTopicDescriptor } from '@vibesdotdev/docs-contracts';
+declare const descriptor: DocsTopicDescriptor;
+export default descriptor;
+//# sourceMappingURL=tools.providers.docs.descriptor.d.ts.map

package/dist/docs/tools.providers.docs.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.providers.docs.descriptor.d.ts","sourceRoot":"","sources":["../../src/docs/tools.providers.docs.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAoMvE,QAAA,MAAM,UAAU,EAAE,mBAgBjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/tools.providers.docs.descriptor.js

@@ -0,0 +1,212 @@
+const markdown = `---
+id: tools.providers
+title: Tool Providers
+summary: Tool provider interface, capabilities, change watching, and built-in providers
+tags: [tools, providers, filesystem, database, remote]
+parent: tools
+order: 3
+surfaces: [cli, web, in-app]
+hardware: [consumer, cloud]
+---
+
+# Tool Providers
+
+Tool providers supply tool descriptors to the runtime from various sources — the local filesystem, a remote HTTP API, a database, or a remote runtime. The runtime registers them under the \`tools/provider\` kind and queries them by hardware scope.
+
+## Provider interface
+
+Providers implement \`ToolProviderInterface\`:
+
+:::usage{language="ts"}
+import type {
+  ToolProviderInterface,
+  ToolChangeEvent
+} from '@vibesdotdev/tools';
+
+interface ToolProviderInterface {
+  readonly id: string;
+  readonly descriptor: ToolProviderDescriptor;
+  loadTools(): Promise<ToolDescriptor[]>;
+  watch(callback: (event: ToolChangeEvent) => void): () => void;
+}
+:::
+
+\`loadTools()\` returns the current set of tool descriptors. \`watch()\` subscribes to changes and returns an unsubscribe function.
+
+## Change events
+
+Watching a provider yields a discriminated \`ToolChangeEvent\`:
+
+:::usage{language="ts"}
+type ToolChangeEvent =
+  | { type: 'added'; tool: ToolDescriptor }
+  | { type: 'updated'; tool: ToolDescriptor }
+  | { type: 'removed'; toolId: string };
+:::
+
+## Provider descriptor
+
+A \`tools/provider\` descriptor declares capabilities and hardware targets, validated by \`ToolProviderDescriptorSchema\`:
+
+:::usage{language="ts"}
+import {
+  ToolProviderDescriptorSchema,
+  type ToolProviderDescriptor
+} from '@vibesdotdev/tools';
+
+const descriptor: ToolProviderDescriptor = {
+  kind: 'tools/provider',
+  id: 'tool-provider.filesystem',
+  hardware: ['consumer'],
+  capabilities: {
+    watchable: true,
+    writable: true,
+    remote: false
+  }
+};
+:::
+
+### Capabilities
+
+\`ToolProviderCapabilities\` has three boolean fields:
+
+| Field | Meaning |
+|-------|---------|
+| \`watchable\` | Provider can detect changes and notify via \`watch()\` |
+| \`writable\` | Provider can persist new or updated tools |
+| \`remote\` | Provider requires network access |
+
+## Built-in providers
+
+| Provider | ID | Hardware | watchable / writable / remote |
+|----------|----|----------|-------------------------------|
+| Filesystem | \`tool-provider.filesystem\` | consumer | true / true / false |
+| API | \`tool-provider.api\` | consumer | false / false / true |
+| Database | \`tool-provider.database\` | cloud | true / true / false |
+| Remote | \`tool-provider.remote\` | consumer, cloud | false / false / true |
+
+## Querying providers
+
+Providers are resolved through the runtime by hardware scope:
+
+:::usage{language="ts"}
+import type { VibesRuntime } from '@vibesdotdev/kernel';
+
+// The handed runtime: context.runtime in a command, event.locals.runtime in
+// SvelteKit, the onActivate runtime in a plugin.
+declare const runtime: VibesRuntime;
+
+const provider = await runtime.query('tools/provider')
+  .forHardware('consumer')
+  .resolve();
+
+const tools = await provider.loadTools();
+:::
+
+## Provider context
+
+Provider implementations receive a \`ToolProviderContext\`. The runtime injects the \`runtime/workspace-path\` context (declared by the \`tools/provider\` kind). Individual providers may declare additional contexts on their descriptor — the API provider declares \`app/api-client\` via \`optionalContext\` and falls back to env configuration when it is absent:
+
+:::usage{language="ts"}
+import type { ToolProviderContext } from '@vibesdotdev/tools';
+
+interface ToolProviderContext {
+  registry?: unknown;
+  config?: Record<string, unknown>;
+  apiClient?: unknown;
+  db?: unknown;
+  'runtime/workspace-path'?: string;
+  [key: string]: unknown;
+}
+:::
+
+## Filesystem provider
+
+The \`FilesystemToolProvider\` (consumer-only) discovers \`*.descriptor*.ts\` files under configured tool paths (defaulting to \`.vibes/tools\` in the workspace), watches them for changes via Node's \`fs.watch\`, and can write new descriptors back to disk. It is resolved through the runtime rather than imported directly:
+
+:::usage{language="ts"}
+const provider = await runtime.query('tools/provider')
+  .forHardware('consumer')
+  .resolve();
+
+const tools = await provider.loadTools();
+
+const unwatch = provider.watch((event) => {
+  if (event.type === 'removed') {
+    console.log('tool removed', event.toolId);
+  } else {
+    console.log(event.type, event.tool.id);
+  }
+});
+
+// later
+unwatch();
+:::
+
+## Custom providers
+
+Implement \`ToolProviderInterface\` to source tools from a new backend, then register a loader for the \`tools/provider\` kind. The loader returns a validated implementation via \`createRuntimeImplementation\`:
+
+:::usage{language="ts"}
+import {
+  createRuntimeImplementation,
+  type VibesRuntime
+} from '@vibesdotdev/kernel';
+import type {
+  ToolProviderInterface,
+  ToolChangeEvent
+} from '@vibesdotdev/tools';
+
+const provider: ToolProviderInterface = {
+  id: 'tool-provider.custom',
+  descriptor: customDescriptor,
+  async loadTools() {
+    return [];
+  },
+  watch(_callback: (event: ToolChangeEvent) => void) {
+    return () => {};
+  }
+};
+
+// The handed runtime: the plugin's onRegister/onActivate runtime.
+declare const runtime: VibesRuntime;
+runtime.registerLoader('tools/provider', provider.id, async () =>
+  createRuntimeImplementation<ToolProviderInterface>({
+    kind: 'tools/provider',
+    id: provider.id,
+    constraint: { hardware: ['consumer'] },
+    implementation: provider
+  })
+);
+:::
+
+## Related descriptors
+
+:::descriptor{kind="docs/topic" id="tools.list"}
+:::
+
+:::descriptor{kind="docs/topic" id="tools.invoke"}
+:::
+
+:::descriptor{kind="docs/topic" id="tools.ui"}
+:::
+`;
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'tools.providers',
+    title: 'Tool Providers',
+    summary: 'Tool provider interface, capabilities, change watching, and built-in providers',
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: markdown
+    },
+    parent: 'tools',
+    order: 3,
+    tags: ['tools', 'providers', 'filesystem', 'database', 'remote'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer', 'cloud'],
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=tools.providers.docs.descriptor.js.map

package/dist/docs/tools.providers.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.providers.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/tools.providers.docs.descriptor.ts"],"names":[],"mappings":"AAEA,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgMhB,CAAC;AAEF,MAAM,UAAU,GAAwB;IACvC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,iBAAiB;IACrB,KAAK,EAAE,gBAAgB;IACvB,OAAO,EAAE,gFAAgF;IACzF,IAAI,EAAE;QACL,IAAI,EAAE,UAAU;QAChB,UAAU,EAAE,KAAK;QACjB,MAAM,EAAE,QAAQ;KAChB;IACD,MAAM,EAAE,OAAO;IACf,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,CAAC;IAChE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC;IAClC,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,OAAO,EAAE,IAAI;CACb,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/ui.docs.descriptor.d.ts

@@ -0,0 +1,4 @@
+import type { DocsTopicDescriptor } from '@vibesdotdev/docs-contracts';
+declare const descriptor: DocsTopicDescriptor;
+export default descriptor;
+//# sourceMappingURL=ui.docs.descriptor.d.ts.map

package/dist/docs/ui.docs.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui.docs.descriptor.d.ts","sourceRoot":"","sources":["../../src/docs/ui.docs.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAsIvE,QAAA,MAAM,UAAU,EAAE,mBAgBjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/ui.docs.descriptor.js

@@ -0,0 +1,150 @@
+const markdown = `---
+id: tools.ui
+title: Tool UI
+summary: Tool UI descriptors and surface-specific widgets for rendering tool calls
+tags: [tools, ui, widgets, rendering]
+parent: tools
+order: 5
+surfaces: [cli, web, in-app]
+hardware: [consumer]
+---
+
+# Tool UI
+
+\`tools/ui\` descriptors register surface-specific assets that render a tool's call — terminal widgets, badges, and approval views — co-located with the tool implementation. The descriptor declares *which* tool it renders and *where* it can render; the actual render function is supplied separately as a runtime implementation.
+
+## Descriptor schema
+
+A \`tools/ui\` descriptor extends the base runtime descriptor with the fields below (from \`schemas/ui.ts\`):
+
+:::usage{language="ts"}
+import * as z from 'zod/v4';
+
+const ToolUISurfaceSchema = z.enum(['cli', 'tui', 'web', 'worker', 'bridge']);
+const ToolUIRoleSchema = z.enum(['badge', 'widget', 'approval']);
+
+// ToolUIDescriptorSchema extends RuntimeDescriptorSchema:
+{
+  kind: 'tools/ui';
+  surfaces: Array<'cli' | 'tui' | 'web' | 'worker' | 'bridge'>;
+  hardware?: Array<'consumer' | 'cloud'>;
+  role: 'badge' | 'widget' | 'approval';
+  targetToolId: string;   // ID of the tool this UI renders for
+  targetId?: string;      // Aliases targetToolId; synced automatically
+}
+:::
+
+There is no \`widgetType\`, \`component\`, or \`props\` field on the descriptor — those are part of the *implementation*, not the descriptor.
+
+## Creating a descriptor
+
+Use \`createToolUIDescriptor\` (from \`schemas/ui.ts\`), which validates against the schema and syncs \`targetId\` from \`targetToolId\`:
+
+:::usage{language="ts"}
+import { createToolUIDescriptor } from '../schemas/ui.ts';
+
+export const fsReadUIDescriptor = createToolUIDescriptor({
+  id: 'workspace-fs.ui',
+  name: 'File Read Widget',
+  description: 'Renders file read results with syntax highlighting',
+  surfaces: ['tui'],
+  role: 'widget',
+  targetToolId: 'workspace-fs',
+  targetId: 'workspace-fs',
+  tags: ['filesystem', 'widget'],
+  enabled: true
+});
+:::
+
+## Built-in UI widgets
+
+First-party tools register designed Svelte and TUI widgets. The default card is
+only for user-authored \`custom:*\` tools that have not declared a widget.
+
+| Descriptor | targetToolId | Role | Surfaces |
+|------------|--------------|------|----------|
+| \`workspace-fs.ui\` | \`workspace-fs\` | widget | tui |
+| \`*.svelte-widget\` | first-party chat tools | widget | web |
+| \`*.tui-widget\` | first-party chat tools | widget | tui |
+
+## Implementations
+
+The descriptor is render-agnostic. The render function is registered separately as a \`ToolUIImplementation\`. The TUI surface implementation supplies a \`component\` that receives a \`ToolWidgetProps\`:
+
+:::usage{language="ts"}
+// ToolUIImplementation (from kinds/schemas/tools-ui.ts)
+interface ToolUIImplementation {
+  // The TUI surface is typed as the named ToolUITuiImplementation interface:
+  tui?: ToolUITuiImplementation;
+}
+
+interface ToolUITuiImplementation {
+  component: (props: ToolWidgetProps) => ToolUIRenderable;
+}
+
+interface ToolWidgetProps {
+  toolCall: {
+    id: string;
+    messageId: string;
+    tool: string;
+    events: ReadonlyArray<{ event: unknown; timestamp: number }>;
+    startedAt: number;
+    updatedAt: number;
+    agent?: { agentId: string; name: string; icon?: string; color?: string };
+  };
+  status: 'running' | 'done' | 'failed';
+  args: Record<string, unknown> | undefined;
+  output: unknown;
+  error: string | null;
+}
+:::
+
+When no implementation is registered, the default (\`DefaultToolUI\`) throws on access, instructing you to register one:
+
+:::usage{language="ts"}
+runtime.registerLoader('tools/ui', 'workspace-fs.ui', loader);
+:::
+
+## Resolution
+
+The \`tools/ui\` kind resolves a descriptor by surface, not by a chained \`.withId()\` lookup. \`resolveToolUI\` filters the registered candidates to those whose \`surfaces\` include the current scope surface, preferring entries with explicit \`hardware\`:
+
+:::usage{language="ts"}
+// resolveToolUI(candidates, scope):
+// 1. parse candidates against ToolUIDescriptorSchema
+// 2. if 0 valid -> undefined; if 1 -> that one
+// 3. else filter by scope.surface; prefer descriptors with hardware set
+:::
+
+Helpers for the TUI widgets live in \`ui/utils.ts\` — \`detectLanguage(filePath)\` maps a file extension to a syntax-highlight language, and \`truncate(text, maxLines)\` clips long output for display.
+
+## Related descriptors
+
+:::descriptor{kind="docs/topic" id="tools.invoke"}
+:::
+
+:::descriptor{kind="docs/topic" id="tools.providers"}
+:::
+
+:::descriptor{kind="docs/topic" id="tools.list"}
+:::
+`;
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'tools.ui',
+    title: 'Tool UI',
+    summary: 'Tool UI descriptors and surface-specific widgets for rendering tool calls',
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: markdown
+    },
+    parent: 'tools',
+    order: 5,
+    tags: ['tools', 'ui', 'widgets', 'rendering'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer'],
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=ui.docs.descriptor.js.map

package/dist/docs/ui.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/ui.docs.descriptor.ts"],"names":[],"mappings":"AAEA,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkIhB,CAAC;AAEF,MAAM,UAAU,GAAwB;IACvC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,UAAU;IACd,KAAK,EAAE,SAAS;IAChB,OAAO,EAAE,2EAA2E;IACpF,IAAI,EAAE;QACL,IAAI,EAAE,UAAU;QAChB,UAAU,EAAE,KAAK;QACjB,MAAM,EAAE,QAAQ;KAChB;IACD,MAAM,EAAE,OAAO;IACf,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,WAAW,CAAC;IAC7C,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC;IAClC,QAAQ,EAAE,CAAC,UAAU,CAAC;IACtB,OAAO,EAAE,IAAI;CACb,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/encoding/compact.impl.d.ts

@@ -0,0 +1,3 @@
+import { compactJsonEncoder } from './json-encoder.ts';
+export default compactJsonEncoder;
+//# sourceMappingURL=compact.impl.d.ts.map

package/dist/encoding/compact.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.impl.d.ts","sourceRoot":"","sources":["../../src/encoding/compact.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,eAAe,kBAAkB,CAAC"}

package/dist/encoding/compact.impl.js

@@ -0,0 +1,3 @@
+import { compactJsonEncoder } from "./json-encoder.js";
+export default compactJsonEncoder;
+//# sourceMappingURL=compact.impl.js.map

package/dist/encoding/compact.impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.impl.js","sourceRoot":"","sources":["../../src/encoding/compact.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,eAAe,kBAAkB,CAAC"}

package/dist/encoding/encoding.plugin.d.ts

@@ -0,0 +1,34 @@
+/** Shared isomorphic encoder composition. Hosts may register additional encoders. */
+declare const encodingPluginDefinition: {
+    id: string;
+    kinds: {
+        id: string;
+        descriptorSchema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            kind: import("zod").ZodLiteral<"tools/result-encoder">;
+            encoderId: import("zod").ZodEnum<{
+                json: "json";
+                "compact-json": "compact-json";
+                toon: "toon";
+            }>;
+            version: import("zod").ZodDefault<import("zod").ZodString>;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        defaultImplementation: typeof import("../kinds/result-encoder.kind.ts").DefaultResultEncoderImplementation;
+        contexts: readonly [];
+    }[];
+    descriptors: ({
+        id: string;
+        kind: "tools/result-encoder";
+        encoderId: "json";
+        version: string;
+    } | {
+        id: string;
+        kind: "tools/result-encoder";
+        encoderId: "compact-json";
+        version: string;
+    })[];
+    loaders: import("@vibesdotdev/kernel").AssetLoader[];
+};
+export default encodingPluginDefinition;
+//# sourceMappingURL=encoding.plugin.d.ts.map

package/dist/encoding/encoding.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.plugin.d.ts","sourceRoot":"","sources":["../../src/encoding/encoding.plugin.ts"],"names":[],"mappings":"AAIA,qFAAqF;AACrF,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAW7B,CAAC;AACF,eAAe,wBAAwB,CAAC"}

package/dist/encoding/encoding.plugin.js

@@ -0,0 +1,17 @@
+import { loader } from '@vibesdotdev/kernel';
+import { resultEncoderKind } from "../kinds/result-encoder.kind.js";
+/** Shared isomorphic encoder composition. Hosts may register additional encoders. */
+const encodingPluginDefinition = {
+    id: 'tools.encoding',
+    kinds: [resultEncoderKind],
+    descriptors: [
+        { id: 'json', kind: 'tools/result-encoder', encoderId: 'json', version: '1.0.0' },
+        { id: 'compact-json', kind: 'tools/result-encoder', encoderId: 'compact-json', version: '1.0.0' }
+    ],
+    loaders: [
+        loader('json', { kind: 'tools/result-encoder' }, () => import("./json.impl.js")),
+        loader('compact-json', { kind: 'tools/result-encoder' }, () => import("./compact.impl.js"))
+    ]
+};
+export default encodingPluginDefinition;
+//# sourceMappingURL=encoding.plugin.js.map

package/dist/encoding/encoding.plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.plugin.js","sourceRoot":"","sources":["../../src/encoding/encoding.plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAEpE,qFAAqF;AACrF,MAAM,wBAAwB,GAAG;IAChC,EAAE,EAAE,gBAAgB;IACpB,KAAK,EAAE,CAAC,iBAAiB,CAAC;IAC1B,WAAW,EAAE;QACZ,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,sBAAsB,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE;QACjF,EAAE,EAAE,EAAE,cAAc,EAAE,IAAI,EAAE,sBAAsB,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE;KAC7D;IACrC,OAAO,EAAE;QACR,MAAM,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,sBAAsB,EAAE,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;QAChF,MAAM,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE,sBAAsB,EAAE,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC;KAC3F;CACD,CAAC;AACF,eAAe,wBAAwB,CAAC"}

package/dist/encoding/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * TOON Milestone Phase 1 (Lane A): Encoding Module Exports
+ */
+export * from './types.ts';
+export * from './registry.ts';
+export * from './resolve.ts';
+export * from './json-encoder.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/encoding/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/encoding/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC"}

package/dist/encoding/index.js

@@ -0,0 +1,8 @@
+/**
+ * TOON Milestone Phase 1 (Lane A): Encoding Module Exports
+ */
+export * from "./types.js";
+export * from "./registry.js";
+export * from "./resolve.js";
+export * from "./json-encoder.js";
+//# sourceMappingURL=index.js.map

package/dist/encoding/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/encoding/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC"}

package/dist/encoding/json-encoder.d.ts

@@ -0,0 +1,4 @@
+import type { EncoderDescriptor } from './types.ts';
+export declare const jsonEncoder: EncoderDescriptor;
+export declare const compactJsonEncoder: EncoderDescriptor;
+//# sourceMappingURL=json-encoder.d.ts.map

package/dist/encoding/json-encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-encoder.d.ts","sourceRoot":"","sources":["../../src/encoding/json-encoder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAgC,iBAAiB,EAAE,MAAM,YAAY,CAAC;AA2BlF,eAAO,MAAM,WAAW,EAAE,iBAazB,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,iBAchC,CAAC"}

package/dist/encoding/json-encoder.js

@@ -0,0 +1,57 @@
+import { CaughtFailureSchema } from '@vibesdotdev/kernel';
+function isString(value) {
+    return typeof value === 'string';
+}
+function tryParseJson(text) {
+    try {
+        // SAFETY: Valid JSON text parses to a DecodedValue.
+        return { ok: true, value: JSON.parse(text) };
+    }
+    catch (error) {
+        return { ok: false, failure: CaughtFailureSchema.parse(error) };
+    }
+}
+function tryStringifyJson(value) {
+    try {
+        return { ok: true, text: JSON.stringify(value) };
+    }
+    catch (error) {
+        return { ok: false, failure: CaughtFailureSchema.parse(error) };
+    }
+}
+export const jsonEncoder = {
+    id: 'json',
+    version: '1.0.0',
+    encode(value) {
+        if (isString(value))
+            return value;
+        if (value === null || value === undefined)
+            return '';
+        return JSON.stringify(value);
+    },
+    decode(text) {
+        if (!text)
+            return null;
+        const parsed = tryParseJson(text);
+        return parsed.ok ? parsed.value : text;
+    }
+};
+export const compactJsonEncoder = {
+    id: 'compact-json',
+    version: '1.0.0',
+    encode(value) {
+        if (isString(value))
+            return value;
+        if (value === null || value === undefined)
+            return '';
+        const stringified = tryStringifyJson(value);
+        return stringified.ok ? stringified.text : String(value);
+    },
+    decode(text) {
+        if (!text)
+            return null;
+        const parsed = tryParseJson(text);
+        return parsed.ok ? parsed.value : text;
+    }
+};
+//# sourceMappingURL=json-encoder.js.map

package/dist/encoding/json-encoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-encoder.js","sourceRoot":"","sources":["../../src/encoding/json-encoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAsB,MAAM,qBAAqB,CAAC;AAG9E,SAAS,QAAQ,CAAC,KAAc;IAC/B,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC;AAClC,CAAC;AAED,SAAS,YAAY,CACpB,IAAY;IAEZ,IAAI,CAAC;QACJ,oDAAoD;QACpD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAiB,EAAE,CAAC;IAC9D,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,mBAAmB,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;IACjE,CAAC;AACF,CAAC;AAED,SAAS,gBAAgB,CACxB,KAAqB;IAErB,IAAI,CAAC;QACJ,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;IAClD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,mBAAmB,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;IACjE,CAAC;AACF,CAAC;AAED,MAAM,CAAC,MAAM,WAAW,GAAsB;IAC7C,EAAE,EAAE,MAAM;IACV,OAAO,EAAE,OAAO;IAChB,MAAM,CAAC,KAAqB;QAC3B,IAAI,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAClC,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,EAAE,CAAC;QACrD,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IACD,MAAM,CAAC,IAAY;QAClB,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACvB,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;QAClC,OAAO,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;IACxC,CAAC;CACD,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAsB;IACpD,EAAE,EAAE,cAAc;IAClB,OAAO,EAAE,OAAO;IAChB,MAAM,CAAC,KAAqB;QAC3B,IAAI,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAClC,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,EAAE,CAAC;QACrD,MAAM,WAAW,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAC5C,OAAO,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1D,CAAC;IACD,MAAM,CAAC,IAAY;QAClB,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACvB,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;QAClC,OAAO,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;IACxC,CAAC;CACD,CAAC"}

package/dist/encoding/json.impl.d.ts

@@ -0,0 +1,3 @@
+import { jsonEncoder } from './json-encoder.ts';
+export default jsonEncoder;
+//# sourceMappingURL=json.impl.d.ts.map

package/dist/encoding/json.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.impl.d.ts","sourceRoot":"","sources":["../../src/encoding/json.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,eAAe,WAAW,CAAC"}

package/dist/encoding/json.impl.js

@@ -0,0 +1,3 @@
+import { jsonEncoder } from "./json-encoder.js";
+export default jsonEncoder;
+//# sourceMappingURL=json.impl.js.map

package/dist/encoding/json.impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.impl.js","sourceRoot":"","sources":["../../src/encoding/json.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,eAAe,WAAW,CAAC"}

package/dist/encoding/registry.d.ts

@@ -0,0 +1,18 @@
+import { type RuntimeRef } from '@vibesdotdev/kernel';
+import { type SurfacePolicy } from '../schemas/encoding.ts';
+/** Policy data owned by ToolsClient; implementations remain in tools/result-encoder. */
+export declare class EncodingPolicies {
+    private readonly policies;
+    constructor();
+    get(surfaceId: string): SurfacePolicy | undefined;
+    list(): readonly SurfacePolicy[];
+    register(policy: SurfacePolicy): void;
+    reset(): void;
+    dispose(): void;
+}
+/** Runtime-free reads return only immutable configuration defaults. */
+export declare function getSurfacePolicy(surfaceId: string, runtime?: RuntimeRef): SurfacePolicy | undefined;
+export declare function listSurfacePolicies(runtime?: RuntimeRef): readonly SurfacePolicy[];
+export declare function registerSurfacePolicy(policy: SurfacePolicy, runtime?: RuntimeRef): void;
+export declare function resetSurfacePolicies(runtime?: RuntimeRef): void;
+//# sourceMappingURL=registry.d.ts.map