@zackbart/connecta 0.18.3 → 0.20.0

package/dist/execute.js

@@ -4,10 +4,9 @@ import { boundedDiscoveryText, CatalogService, DiscoveryPolicyError, flatSearchR
 import { errorResult, jsonResult } from "./meta-tools.js";
 import { guardExecuteResultValue, MAX_EXECUTE_LOG_CHARS, truncateExecuteText, } from "./executor-result.js";
 import { ExecutorAdmissionError, ExecutorExecutionError, isAdmittingExecutor, } from "./executor-admission.js";
-import { boundedEchoText, classifyCallError } from "./errors.js";
+import { boundedEchoText, classifyCallError, msg } from "./errors.js";
 import { InvocationFailure, InvocationService, } from "./invocation.js";
 import { hasConnectorGuides } from "./skills.js";
-import { isExplicitlyReadOnly } from "./tool-safety.js";
 /** Keep one model-written program from amplifying into an unbounded fan-out. */
 const EXECUTE_MAX_HOST_CALLS = 20;
 export const EXECUTE_MAX_BATCH_CALLS = 10;
@@ -149,11 +148,7 @@ function requireEmittedBlock(raw) {
     }
     return raw;
 }
-const UI_SHAPE_HINT = "connecta.ui accepts exactly one HTML argument and, optionally, one read-binding options object";
-const MAX_UI_READ_BINDINGS = 32;
-const MAX_UI_VIEW_ARGS = 32;
-const UI_READ_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
-const FORBIDDEN_UI_KEY = new Set(["__proto__", "constructor", "prototype"]);
+const UI_SHAPE_HINT = "connecta.ui accepts exactly one argument: a non-empty string of HTML";
 /** What the argument was, named the way the emit validator names a bad field. */
 function describeUiArgument(raw) {
     if (raw === null)
@@ -168,9 +163,9 @@ function describeUiArgument(raw) {
     return `${/^[aeiou]/.test(kind) ? "an" : "a"} ${kind}`;
 }
 /**
- * Strict U1/V1 validation. The first argument remains HTML; the only second
- * argument is one read-binding manifest. There are no alternate object or MCP
- * block forms.
+ * Strict U1 validation. There is no options parameter and no sugar form, for
+ * M1's reason: sugar is how a one-shape contract grows hair. An options bag or
+ * an MCP block object is just a non-string, and fails as one.
  */
 function requireUiHtml(raw) {
     if (typeof raw !== "string" || raw.length === 0) {
@@ -178,80 +173,11 @@ function requireUiHtml(raw) {
     }
     return raw;
 }
-function requireRecord(raw, label) {
-    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-        throw guestFailure("invalid_args", `${label} must be an object`);
-    }
-    return raw;
-}
-function requireExactKeys(value, allowed, label) {
-    const extras = Object.keys(value).filter((key) => !allowed.includes(key));
-    if (extras.length > 0) {
-        throw guestFailure("invalid_args", `${label} carries unsupported field(s) ${extras.map((key) => JSON.stringify(key)).join(", ")}`);
-    }
-}
-function requireUiReadKey(raw, label) {
-    if (typeof raw !== "string" ||
-        raw.length === 0 ||
-        raw.length > 128 ||
-        FORBIDDEN_UI_KEY.has(raw)) {
-        throw guestFailure("invalid_args", `${label} must be a non-empty string of at most 128 characters and cannot be __proto__, constructor, or prototype`);
-    }
-    return raw;
-}
-function requireUiReads(raw) {
-    const record = requireRecord(raw, "connecta.ui options.reads");
-    const names = Object.keys(record);
-    if (names.length === 0 || names.length > MAX_UI_READ_BINDINGS) {
-        throw guestFailure("invalid_args", `connecta.ui options.reads must contain from 1 through ${MAX_UI_READ_BINDINGS} named bindings`);
-    }
-    const reads = Object.create(null);
-    for (const name of names) {
-        if (!UI_READ_NAME.test(name) || FORBIDDEN_UI_KEY.has(name)) {
-            throw guestFailure("invalid_args", `connecta.ui read binding name ${JSON.stringify(name)} must match ${UI_READ_NAME}`);
-        }
-        const value = requireRecord(record[name], `connecta.ui read binding ${JSON.stringify(name)}`);
-        requireExactKeys(value, ["address", "fixedArgs", "viewArgs"], `connecta.ui read binding ${JSON.stringify(name)}`);
-        if (typeof value.address !== "string" || value.address.length === 0) {
-            throw guestFailure("invalid_args", `connecta.ui read binding ${JSON.stringify(name)} address must be a non-empty string`);
-        }
-        const fixedArgs = value.fixedArgs === undefined
-            ? {}
-            : requireRecord(value.fixedArgs, `connecta.ui read binding ${JSON.stringify(name)} fixedArgs`);
-        const rawViewArgs = value.viewArgs ?? [];
-        if (!Array.isArray(rawViewArgs) || rawViewArgs.length > MAX_UI_VIEW_ARGS) {
-            throw guestFailure("invalid_args", `connecta.ui read binding ${JSON.stringify(name)} viewArgs must be an array of at most ${MAX_UI_VIEW_ARGS} strings`);
-        }
-        const viewArgs = rawViewArgs.map((key) => requireUiReadKey(key, `connecta.ui read binding ${JSON.stringify(name)} viewArgs entry`));
-        if (new Set(viewArgs).size !== viewArgs.length) {
-            throw guestFailure("invalid_args", `connecta.ui read binding ${JSON.stringify(name)} viewArgs must not repeat a key`);
-        }
-        for (const key of viewArgs) {
-            if (Object.prototype.hasOwnProperty.call(fixedArgs, key)) {
-                throw guestFailure("invalid_args", `connecta.ui read binding ${JSON.stringify(name)} view argument ${JSON.stringify(key)} cannot override a fixed argument`);
-            }
-        }
-        reads[name] = {
-            address: value.address,
-            fixedArgs,
-            viewArgs,
-        };
-    }
-    return reads;
-}
 function requireUiPayload(values) {
-    if (values.length !== 1 && values.length !== 2) {
+    if (values.length !== 1) {
         throw guestFailure("invalid_args", `${UI_SHAPE_HINT}; got ${values.length} arguments`);
     }
-    const html = requireUiHtml(values[0]);
-    if (values.length === 1)
-        return { html };
-    const options = requireRecord(values[1], "connecta.ui options");
-    requireExactKeys(options, ["reads"], "connecta.ui options");
-    if (!Object.prototype.hasOwnProperty.call(options, "reads")) {
-        throw guestFailure("invalid_args", "connecta.ui options must contain reads");
-    }
-    return { html, reads: requireUiReads(options.reads) };
+    return { html: requireUiHtml(values[0]) };
 }
 /**
  * Request-local collection for `connecta.emit` and `connecta.ui`. Budgets fail
@@ -306,15 +232,15 @@ export class EmitCollector {
      * complaint about its type would send the author to fix the wrong thing.
      */
     acceptUi(...values) {
-        if (this.ui) {
-            throw guestFailure("invalid_args", "connecta.ui accepts at most one payload per run: a view was already accepted and stands");
-        }
+        this.assertUiVacant();
         this.acceptUiPayload(requireUiPayload(values));
     }
-    acceptUiPayload(payload) {
+    assertUiVacant() {
         if (this.ui) {
             throw guestFailure("invalid_args", "connecta.ui accepts at most one payload per run: a view was already accepted and stands");
         }
+    }
+    acceptUiPayload(payload) {
         let serialized;
         try {
             serialized = JSON.stringify(payload);
@@ -429,9 +355,6 @@ const SANDBOX_RESERVED_NAMES = new Set([
     "__stringifyForCodemode",
     "__parseForCodemode",
 ]);
-function msg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
 function guestFailure(code, message, retryable = false) {
     return new InvocationFailure({ code, message, retryable });
 }
@@ -515,13 +438,9 @@ export async function buildSandboxProviders(registry, baseUrl, logger, activity,
         requestScope,
         // A program that just missed an address cannot call search_tools.
         searchRoute: "connecta.search",
-        ...(limits.discoveryConcurrency !== undefined
-            ? { concurrency: limits.discoveryConcurrency }
-            : {}),
-        ...(limits.probeTimeoutMs !== undefined
-            ? { probeTimeoutMs: limits.probeTimeoutMs }
-            : {}),
-        ...(limits.defer !== undefined ? { defer: limits.defer } : {}),
+        concurrency: limits.discoveryConcurrency,
+        probeTimeoutMs: limits.probeTimeoutMs,
+        defer: limits.defer,
     });
     const invocation = new InvocationService(registry, catalog, activity);
     const maxHostCalls = Math.max(1, Math.trunc(limits.maxHostCalls ?? EXECUTE_MAX_HOST_CALLS));
@@ -573,53 +492,30 @@ export async function buildSandboxProviders(registry, baseUrl, logger, activity,
             throw err;
         }
     };
-    const callAddress = async (address, args, diagnosticOperation = "call") => {
-        const outcome = await invocation.invoke(String(address), args ?? {}, invocationContext());
-        limits.diagnostics?.recordCall(diagnosticOperation, outcome);
-        if (!outcome.ok) {
-            const failure = new InvocationFailure(outcome.error);
-            throw failure;
+    const timedCatalog = async (operation, fn) => {
+        const started = Date.now();
+        try {
+            const result = await fn();
+            limits.diagnostics?.recordCatalog(operation, Date.now() - started, true, result);
+            return result;
         }
-        return outcome.value;
-    };
-    const callNamespace = async (connectorId, toolAlias, args) => {
-        const outcome = await invocation.invokeToolAlias(String(connectorId), String(toolAlias), sanitizeIdentifier, args ?? {}, invocationContext());
-        limits.diagnostics?.recordCall("call", outcome);
-        if (!outcome.ok) {
-            const failure = new InvocationFailure(outcome.error);
-            throw failure;
+        catch (err) {
+            limits.diagnostics?.recordCatalog(operation, Date.now() - started, false);
+            throw err;
         }
+    };
+    const called = async (operation, invoke) => {
+        const outcome = await invoke();
+        limits.diagnostics?.recordCall(operation, outcome);
+        if (!outcome.ok)
+            throw new InvocationFailure(outcome.error);
         return outcome.value;
     };
-    /**
-     * A read binding is admitted while the program still owns the request. The
-     * shell later calls the ordinary `call_tool`, which repeats this same
-     * fail-closed check against the then-current catalog; validating here keeps
-     * a typo or destructive address from producing a view whose controls can
-     * never work, while validation at use keeps a stale view from retaining old
-     * authority.
-     */
-    const validateUiReads = async (payload) => {
-        if (!payload.reads)
-            return payload;
-        const reads = Object.create(null);
-        for (const [name, binding] of Object.entries(payload.reads)) {
-            const resolution = await catalog.resolveTool(binding.address, limits.signal !== undefined ? { signal: limits.signal } : {});
-            if (!resolution.ok) {
-                throw new InvocationFailure({
-                    ...resolution.error,
-                    message: `connecta.ui read binding ${JSON.stringify(name)} could not resolve ${JSON.stringify(binding.address)}: ${resolution.error.message}`,
-                });
-            }
-            if (!isExplicitlyReadOnly(resolution.resolved.definition)) {
-                throw guestFailure("destructive_tool_requires_approval", `connecta.ui read binding ${JSON.stringify(name)} refuses ${JSON.stringify(binding.address)}: the tool is not explicitly read-only`);
-            }
-            reads[name] = {
-                ...binding,
-                address: `${resolution.resolved.connector.id}.${resolution.resolved.toolName}`,
-            };
-        }
-        return { html: payload.html, reads };
+    const callAddress = async (address, args, diagnosticOperation = "call") => {
+        return called(diagnosticOperation, () => invocation.invoke(String(address), args ?? {}, invocationContext()));
+    };
+    const callNamespace = async (connectorId, toolAlias, args) => {
+        return called("call", () => invocation.invokeToolAlias(String(connectorId), String(toolAlias), sanitizeIdentifier, args ?? {}, invocationContext()));
     };
     const fns = {
         __callNamespace: callNamespace,
@@ -642,8 +538,7 @@ export async function buildSandboxProviders(registry, baseUrl, logger, activity,
             if (!limits.emitCollector) {
                 throw guestFailure("unavailable", "connecta.ui is unavailable: no emission collector was configured for this execution", true);
             }
-            const payload = await validateUiReads(requireUiPayload(values));
-            limits.emitCollector.acceptUiPayload(payload);
+            limits.emitCollector.acceptUi(...values);
         },
         batch: async (calls) => {
             const started = Date.now();
@@ -684,43 +579,21 @@ export async function buildSandboxProviders(registry, baseUrl, logger, activity,
                 throw err;
             }
         },
-        search: async (raw) => {
-            const started = Date.now();
-            try {
-                const result = await typedDiscovery(async () => {
-                    const args = (raw ?? {});
-                    const result = flatSearchResult(await catalog.search({
-                        ...args,
-                        includeSchemaKeys: args.includeSchemaKeys !== false,
-                    }));
-                    boundedDiscoveryText(result, "Request a smaller limit, omit fullDescriptions, use compact schemas, or pass includeSchemaKeys: false.");
-                    return result;
-                });
-                limits.diagnostics?.recordCatalog("search", Date.now() - started, true, result);
-                return result;
-            }
-            catch (err) {
-                limits.diagnostics?.recordCatalog("search", Date.now() - started, false);
-                throw err;
-            }
-        },
-        describe: async (raw) => {
-            const started = Date.now();
-            try {
-                const result = await typedDiscovery(async () => {
-                    const args = (raw ?? {});
-                    const result = { tools: await catalog.describe(args) };
-                    boundedDiscoveryText(result, 'Split the address list or use format: "compact".');
-                    return result;
-                });
-                limits.diagnostics?.recordCatalog("describe", Date.now() - started, true, result);
-                return result;
-            }
-            catch (err) {
-                limits.diagnostics?.recordCatalog("describe", Date.now() - started, false);
-                throw err;
-            }
-        },
+        search: async (raw) => timedCatalog("search", () => typedDiscovery(async () => {
+            const args = (raw ?? {});
+            const result = flatSearchResult(await catalog.search({
+                ...args,
+                includeSchemaKeys: args.includeSchemaKeys !== false,
+            }));
+            boundedDiscoveryText(result, "Request a smaller limit, omit fullDescriptions, use compact schemas, or pass includeSchemaKeys: false.");
+            return result;
+        })),
+        describe: async (raw) => timedCatalog("describe", () => typedDiscovery(async () => {
+            const args = (raw ?? {});
+            const result = { tools: await catalog.describe(args) };
+            boundedDiscoveryText(result, 'Split the address list or use format: "compact".');
+            return result;
+        })),
     };
     const transportedFns = Object.fromEntries(Object.entries(fns).map(([name, fn]) => [
         name,
@@ -790,13 +663,9 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
                     },
                     emitCollector: emitted,
                     ...(diagnostics ? { diagnostics } : {}),
-                    ...(config.discoveryConcurrency !== undefined
-                        ? { discoveryConcurrency: config.discoveryConcurrency }
-                        : {}),
-                    ...(config.probeTimeoutMs !== undefined
-                        ? { probeTimeoutMs: config.probeTimeoutMs }
-                        : {}),
-                    ...(config.defer !== undefined ? { defer: config.defer } : {}),
+                    discoveryConcurrency: config.discoveryConcurrency,
+                    probeTimeoutMs: config.probeTimeoutMs,
+                    defer: config.defer,
                 });
             }
             finally {
@@ -826,8 +695,10 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
                         retryAfterMs: err.retryAfterMs,
                     });
                 }
-                const result = jsonResult({
-                    error: {
+                return failureResponse(err.message, {
+                    emitted: err instanceof ExecutorExecutionError ? emitted : undefined,
+                    diagnostics,
+                    code: {
                         code: err.code,
                         message: err.message,
                         retryable: err.retryable,
@@ -835,28 +706,13 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
                             ? { retryAfterMs: err.retryAfterMs }
                             : {}),
                     },
-                    ...(err instanceof ExecutorExecutionError
-                        ? discardedEmits(emitted)
-                        : {}),
-                    ...(diagnostics ? { diagnostics: diagnostics.finish() } : {}),
                 });
-                result.isError = true;
-                return result;
             }
-            if (diagnostics) {
-                const result = jsonResult({
-                    error: {
-                        code: "executor_failed",
-                        message: `Executor failed: ${msg(err)}`,
-                        retryable: false,
-                    },
-                    ...discardedEmits(emitted),
-                    diagnostics: diagnostics.finish(),
-                });
-                result.isError = true;
-                return result;
-            }
-            return errorResult(`Executor failed: ${msg(err)}${discardedEmitsText(emitted)}`);
+            return failureResponse(`Executor failed: ${msg(err)}`, {
+                emitted,
+                diagnostics,
+                code: "executor_failed",
+            });
         }
         finally {
             // A sandbox timeout or early return must also release any outstanding
@@ -900,31 +756,20 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
                 // framed with bounded caller text (`boundedEchoText`) precisely so
                 // this path never needs one. Adding a cap here instead would leave the
                 // top-level surfaces, which have the same amplification, uncovered.
-                const result = jsonResult({
-                    error: invocationFailure.details,
-                    ...(logs ? { logs } : {}),
-                    ...discardedEmits(emitted),
-                    ...(diagnostics ? { diagnostics: diagnostics.finish() } : {}),
+                return failureResponse(invocationFailure.details.message, {
+                    logs,
+                    emitted,
+                    diagnostics,
+                    code: invocationFailure.details,
                 });
-                result.isError = true;
-                return result;
             }
             const message = `Error: ${outcome.error}`;
-            if (diagnostics) {
-                const result = jsonResult({
-                    error: {
-                        code: "executor_failed",
-                        message,
-                        retryable: false,
-                    },
-                    ...(logs ? { logs } : {}),
-                    ...discardedEmits(emitted),
-                    diagnostics: diagnostics.finish(),
-                });
-                result.isError = true;
-                return result;
-            }
-            return errorResult(`${message}${logs ? `\n\nLogs:\n${logs}` : ""}${discardedEmitsText(emitted)}`);
+            return failureResponse(message, {
+                logs,
+                emitted,
+                diagnostics,
+                code: "executor_failed",
+            });
         }
         // A result crossing back as a host BigInt (or otherwise unserializable
         // value) makes JSON.stringify throw — keep that inside the structured
@@ -935,21 +780,12 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
         }
         catch (err) {
             const message = `Error: result is not JSON-serializable: ${msg(err)}`;
-            if (diagnostics) {
-                const response = jsonResult({
-                    error: {
-                        code: "executor_failed",
-                        message,
-                        retryable: false,
-                    },
-                    ...(logs ? { logs } : {}),
-                    ...discardedEmits(emitted),
-                    diagnostics: diagnostics.finish(),
-                });
-                response.isError = true;
-                return response;
-            }
-            return errorResult(`${message}${logs ? `\n\nLogs:\n${logs}` : ""}${discardedEmitsText(emitted)}`);
+            return failureResponse(message, {
+                logs,
+                emitted,
+                diagnostics,
+                code: "executor_failed",
+            });
         }
         const response = jsonResult({
             result,
@@ -976,6 +812,22 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
         return response;
     };
 }
+function failureResponse(message, options) {
+    const { logs, emitted, diagnostics, code } = options;
+    if (diagnostics || typeof code !== "string") {
+        const result = jsonResult({
+            error: typeof code === "string"
+                ? { code, message, retryable: false }
+                : code,
+            ...(logs ? { logs } : {}),
+            ...(emitted ? discardedEmits(emitted) : {}),
+            ...(diagnostics ? { diagnostics: diagnostics.finish() } : {}),
+        });
+        result.isError = true;
+        return result;
+    }
+    return errorResult(`${message}${logs ? `\n\nLogs:\n${logs}` : ""}${emitted ? discardedEmitsText(emitted) : ""}`);
+}
 /**
  * M4 and U3: a failed program delivers no blocks and no view, but each
  * discard is visible — and one failure can discard both.
@@ -1035,7 +887,7 @@ Write one plain-JavaScript async arrow function. Use only:
 - <connectorId>.<toolName>(args) for a sanitized shortcut, or connecta.call(address, args) for a canonical address.
 - connecta.search(args), connecta.describe(args), and connecta.batch(calls) for discovery and independent read-only calls.
 - connecta.emit(block) — { type: "text", text } or { type: "image" | "audio", data (base64), mimeType }. Success-only; ${emitBudgets.maxBlocks} blocks/${emitBudgets.maxBytes} bytes; invalid/over-budget throws.
-- connecta.ui(html, options?) for one success-only view; return the same initial summary the HTML renders.
+- connecta.ui(html) for one display-only, success-only view; return the same summary the HTML renders.
 - console.log(...) — captured.
 
 Programs have no portable ambient capabilities. Return JSON and reduce large results before they truncate. Fetch skills({ name: "usage" }) once for selection rules, exact result shapes, repair, examples, guide handling${connectorGuides ? ", connector-guide rules" : ""}, and runtime differences.`;
@@ -1049,15 +901,11 @@ export function registerExecuteTool(server, registry, ctx) {
     };
     const connectors = registry.listConnectors();
     const handler = createExecuteTool(registry, ctx.baseUrl, ctx.executor, ctx.logger, ctx.activity, {
-        ...(ctx.discoveryConcurrency !== undefined
-            ? { discoveryConcurrency: ctx.discoveryConcurrency }
-            : {}),
-        ...(ctx.probeTimeoutMs !== undefined
-            ? { probeTimeoutMs: ctx.probeTimeoutMs }
-            : {}),
+        discoveryConcurrency: ctx.discoveryConcurrency,
+        probeTimeoutMs: ctx.probeTimeoutMs,
         maxEmittedBytes: emitBudgets.maxBytes,
         maxEmittedBlocks: emitBudgets.maxBlocks,
-        ...(ctx.defer !== undefined ? { defer: ctx.defer } : {}),
+        defer: ctx.defer,
     });
     server.registerTool("execute_code", {
         description: executeDescription(emitBudgets, hasConnectorGuides(connectors), connectors),
@@ -1078,12 +926,8 @@ export function registerExecuteTool(server, registry, ctx) {
             destructiveHint: false,
             openWorldHint: true,
         },
-        // U5 and U10: declared unconditionally. A host without the Apps
-        // extension ignores unknown _meta and sees the ordinary envelope, which
-        // is the text fallback the spec mandates — and a stateless aggregator
-        // has nowhere dependable to hold a negotiation check anyway. The
-        // explicit visibility keeps hosts from being told the view may call
-        // execute_code; the default ["model","app"] would say exactly that.
+        // U5 and U10 are specified in documentation/code-mode.md; explicit model
+        // visibility prevents hosts from offering execute_code to the view.
         _meta: {
             ui: {
                 resourceUri: PROGRAM_UI_RESOURCE_URI,

package/dist/executor-result.d.ts

@@ -1,5 +1,6 @@
 import type { ExecuteResult } from "./types.js";
 export declare const MAX_EXECUTE_LOG_CHARS = 4000;
+export declare function serializeResultText(value: unknown): string;
 export declare function guardExecuteResultValue(value: unknown): unknown;
 export declare function truncateExecuteText(text: string, max: number): string;
 /**

package/dist/executor-result.js

@@ -1,10 +1,8 @@
+import { msg } from "./errors.js";
 /** ~6k tokens. Sandbox code should filter data down before returning. */
 const MAX_EXECUTE_RESULT_CHARS = 24_000;
 export const MAX_EXECUTE_LOG_CHARS = 4_000;
-function msg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-function serializeExecuteValue(value) {
+export function serializeResultText(value) {
     const serialized = JSON.stringify(value);
     return serialized === undefined ? String(value) : serialized;
 }
@@ -37,15 +35,10 @@ function truncationEnvelope(text) {
         // the overshoot ratio (minus a step) strictly shrinks the budget.
         budget = Math.max(0, Math.floor(budget * (MAX_EXECUTE_RESULT_CHARS / size)) - 8);
     }
-    // The loop shrinks monotonically, so this is unreachable in practice — but an
-    // unchecked slice is exactly how a "bounded" envelope stops being bounded.
-    const clamped = { ...base, preview: text.slice(0, Math.max(0, budget)) };
-    return JSON.stringify(clamped).length <= MAX_EXECUTE_RESULT_CHARS
-        ? clamped
-        : { ...base, preview: "" };
+    return { ...base, preview: text.slice(0, budget) };
 }
 export function guardExecuteResultValue(value) {
-    const text = serializeExecuteValue(value);
+    const text = serializeResultText(value);
     if (text.length <= MAX_EXECUTE_RESULT_CHARS)
         return value;
     return truncationEnvelope(text);

package/dist/executors/quickjs-child.js

@@ -1,12 +1,10 @@
 import { prepareExecuteResultForTransport } from "../executor-result.js";
+import { msg } from "../errors.js";
 import { MAX_QUICKJS_IPC_BYTES, MAX_QUICKJS_HOST_RPC_BYTES, serializedBytes, stringifyBounded, } from "./quickjs-protocol.js";
 import { executeQuickJs, prepareQuickJs } from "./quickjs-runtime.js";
 let activeJobId;
 let nextCallId = 1;
 const pending = new Map();
-function msg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
 function send(message) {
     if (!process.send)
         throw new Error("QuickJS child IPC channel is unavailable.");

package/dist/executors/quickjs-runtime.js

@@ -8,6 +8,7 @@
 // continuations from a host-side loop. Values cross the boundary as JSON, so
 // provider args/results must be JSON-serializable.
 import { getQuickJS, } from "quickjs-emscripten";
+import { msg } from "../errors.js";
 import { hostCallLabel, MAX_QUICKJS_LOG_TRANSPORT_BYTES, serializedBytes, } from "./quickjs-protocol.js";
 /** Load and compile the shared QuickJS WASM module before a run budget starts. */
 export async function prepareQuickJs() {
@@ -29,9 +30,6 @@ const MAX_LOG_MARKER_TRANSPORT_BYTES = Math.max(logTransportBytes(LOG_ENTRY_LIMI
 // This still lets guest code reduce data more than ten times larger than
 // connecta's final response budget.
 const MAX_HOST_RESULT_BYTES = 256 * 1024;
-function msg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
 function logTransportBytes(entry) {
     // The log is encoded into ExecutionPayload, then that payloadJson string is
     // encoded into ChildToParentMessage. Measure the units the IPC cap sees.

package/dist/executors/quickjs.js

@@ -6,6 +6,7 @@ import { fork } from "node:child_process";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { AdmissionController, ExecutorAdmissionError, ExecutorExecutionError, } from "../executor-admission.js";
+import { msg } from "../errors.js";
 import { hostCallLabel, MAX_QUICKJS_IPC_BYTES, MAX_QUICKJS_HOST_RPC_BYTES, serializedBytes, stringifyBounded, } from "./quickjs-protocol.js";
 export { normalizeCode } from "./quickjs-runtime.js";
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -19,9 +20,6 @@ const CHILD_EXIT_GRACE_MS = 250;
 const CHILD_STARTUP_TIMEOUT_MS = 10_000;
 const MAX_CHILD_STDERR_BYTES = 8 * 1024;
 const MAX_ERROR_CHARS = 4_000;
-function msg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
 function retainStderrTail(current, chunk) {
     const incoming = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
     if (incoming.length >= MAX_CHILD_STDERR_BYTES) {