@noodleseed/one 0.164.0 → 0.165.0

package/node_modules/@noodle-borg/compute/dist/deterministic-helpers.js

@@ -0,0 +1,138 @@
+import { createHash } from 'node:crypto';
+/** Worker-local pure capabilities: bounded arguments and calls, never an ambient host clock. */
+export function installDeterministicHelpers(context) {
+    let calls = 0;
+    const formatters = new Map();
+    const fn = context.newFunction('__explicitHelper', (operationHandle, argsHandle) => {
+        try {
+            calls += 1;
+            if (calls > 4096)
+                throw new Error('explicit helper call budget exceeded');
+            const operation = context.getString(operationHandle);
+            const json = context.getString(argsHandle);
+            if (json.length > 16_384)
+                throw new Error('explicit helper input exceeds its bound');
+            const args = JSON.parse(json);
+            if (!Array.isArray(args))
+                throw new Error('explicit helper arguments are invalid');
+            let result;
+            if (operation === 'parse') {
+                const value = args[0];
+                if (typeof value !== 'string' ||
+                    value.length > 64 ||
+                    !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d{1,9})?(?:Z|[+-]\d\d:\d\d)$/.test(value))
+                    throw new Error('explicit instant is invalid');
+                const year = Number(value.slice(0, 4));
+                const month = Number(value.slice(5, 7));
+                const day = Number(value.slice(8, 10));
+                const maxDay = new Date(`${value.slice(0, 7)}-01T00:00:00Z`);
+                maxDay.setUTCMonth(month);
+                maxDay.setUTCDate(0);
+                const millis = Date.parse(value);
+                if (!Number.isFinite(millis) ||
+                    month < 1 ||
+                    month > 12 ||
+                    day < 1 ||
+                    day > maxDay.getUTCDate() ||
+                    year < 1 ||
+                    Number(value.slice(11, 13)) > 23 ||
+                    Number(value.slice(14, 16)) > 59 ||
+                    Number(value.slice(17, 19)) > 59)
+                    throw new Error('explicit instant is invalid');
+                result = millis;
+            }
+            else if (operation === 'format' || operation === 'parts') {
+                const epoch = args[0];
+                if (typeof epoch !== 'number' ||
+                    !Number.isInteger(epoch) ||
+                    epoch < -62135596800000 ||
+                    epoch > 253402300799999)
+                    throw new Error('explicit instant is invalid');
+                if (operation === 'format')
+                    result = new Date(epoch).toISOString();
+                else {
+                    const zone = args[1];
+                    if (typeof zone !== 'string' ||
+                        zone.length < 1 ||
+                        zone.length > 64 ||
+                        zone.trim() !== zone)
+                        throw new Error('explicit time zone is invalid');
+                    let formatter = formatters.get(zone);
+                    if (!formatter) {
+                        if (formatters.size >= 16)
+                            throw new Error('explicit time zone count exceeds its bound');
+                        formatter = new Intl.DateTimeFormat('en-US', {
+                            timeZone: zone,
+                            weekday: 'short',
+                            year: 'numeric',
+                            month: '2-digit',
+                            day: '2-digit',
+                            hour: '2-digit',
+                            minute: '2-digit',
+                            hourCycle: 'h23',
+                        });
+                        formatters.set(zone, formatter);
+                    }
+                    const parts = Object.fromEntries(formatter.formatToParts(epoch).map(({ type, value }) => [type, value]));
+                    const weekday = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'].indexOf(parts.weekday ?? '') + 1;
+                    result = {
+                        date: `${parts.year}-${parts.month}-${parts.day}`,
+                        weekday,
+                        hour: Number(parts.hour),
+                        minute: Number(parts.minute),
+                    };
+                }
+            }
+            else if (operation === 'digest') {
+                const value = args[0];
+                const encoding = args[1] ?? 'hex';
+                if (typeof value !== 'string' ||
+                    value.length > 8192 ||
+                    (encoding !== 'hex' && encoding !== 'base32hex'))
+                    throw new Error('explicit digest input is invalid');
+                const digest = createHash('sha256').update(value, 'utf8').digest();
+                if (encoding === 'hex')
+                    result = digest.toString('hex');
+                else {
+                    let bits = 0;
+                    let value = 0;
+                    let output = '';
+                    const alphabet = '0123456789abcdefghijklmnopqrstuv';
+                    for (const byte of digest) {
+                        value = (value << 8) | byte;
+                        bits += 8;
+                        while (bits >= 5) {
+                            output += alphabet[(value >>> (bits - 5)) & 31];
+                            bits -= 5;
+                        }
+                    }
+                    if (bits > 0)
+                        output += alphabet[(value << (5 - bits)) & 31];
+                    result = output;
+                }
+            }
+            else
+                throw new Error('explicit helper is not available');
+            return context.newString(JSON.stringify({ ok: true, value: result }));
+        }
+        catch {
+            return context.newString(JSON.stringify({ ok: false, error: 'invalid or exhausted explicit helper request' }));
+        }
+    });
+    context.setProp(context.global, '__explicitHelper', fn);
+    fn.dispose();
+}
+export const helperPrelude = `
+var __helper = function(operation, args) {
+  var result = JSON.parse(globalThis.__explicitHelper(operation, JSON.stringify(args)));
+  if (!result.ok) throw new Error(result.error);
+  return result.value;
+};
+var __timeHelpers = Object.freeze({
+  parse: function(value) { return __helper('parse', [value]); },
+  format: function(value) { return __helper('format', [value]); },
+  parts: function(value, timeZone) { return __helper('parts', [value, timeZone]); }
+});
+var __digestHelper = function(value, encoding) { return __helper('digest', [value, encoding]); };
+`;
+//# sourceMappingURL=deterministic-helpers.js.map

package/node_modules/@noodle-borg/compute/dist/quickjs-engine.js

@@ -111,6 +111,54 @@ class QuickJsComputeInstance {
  */
 function envelopeBridge(host) {
     return {
+        ...(host.execution === undefined ? {} : { execution: { id: host.execution.id } }),
+        ...(host.coordination === undefined
+            ? {}
+            : {
+                coordination: {
+                    acquired: host.coordination.acquired,
+                    ...(host.coordination.previous
+                        ? {
+                            previous: {
+                                reference: host.coordination.previous.reference,
+                                operationDigest: host.coordination.previous.operationDigest,
+                            },
+                        }
+                        : {}),
+                },
+            }),
+        async control(name, argsJson) {
+            try {
+                const args = JSON.parse(argsJson);
+                if (name === 'resolveCoordination' && host.resolveCoordination) {
+                    await host.resolveCoordination();
+                }
+                else if (name === 'reportOutcome' &&
+                    host.reportOutcome &&
+                    args !== null &&
+                    typeof args === 'object' &&
+                    !Array.isArray(args)) {
+                    const evidence = args;
+                    if (!['completed', 'rejected', 'unknown'].includes(String(evidence.outcome)) ||
+                        (evidence.reference !== undefined &&
+                            (typeof evidence.reference !== 'string' || evidence.reference.length > 1024)))
+                        throw new Error('invalid execution evidence');
+                    await host.reportOutcome({
+                        outcome: evidence.outcome,
+                        ...(typeof evidence.reference === 'string' ? { reference: evidence.reference } : {}),
+                    });
+                }
+                else
+                    throw new Error('host control unavailable');
+                return JSON.stringify({ ok: true, output: null });
+            }
+            catch {
+                return JSON.stringify({
+                    ok: false,
+                    error: { code: 'host_call_denied', message: 'host control unavailable or invalid' },
+                });
+            }
+        },
         async callOperation(name, argsJson) {
             const envelope = await (async () => {
                 try {

package/node_modules/@noodle-borg/compute/dist/sandbox-eval.js

@@ -1,4 +1,5 @@
 import { shouldInterruptAfterDeadline } from 'quickjs-emscripten';
+import { helperPrelude, installDeterministicHelpers } from './deterministic-helpers.js';
 import { ComputeError, } from './engine.js';
 /**
  * Normalize a host-call failure into a bounded error envelope. The code/path pass through only as
@@ -24,6 +25,7 @@ export function runPure(wasm, source, input, limits) {
     runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + limits.timeoutMs));
     const context = runtime.newContext();
     try {
+        installDeterministicHelpers(context);
         const wrapper = buildWrapper(source, input);
         const result = context.evalCode(wrapper, 'module.js');
         if (result.error) {
@@ -47,10 +49,11 @@ export async function runHosted(wasm, source, input, limits, bridge) {
     runtime.setMemoryLimit(limits.memoryBytes);
     runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + limits.timeoutMs));
     try {
+        installDeterministicHelpers(context);
         installHostCall(context, bridge, limits);
         if (bridge.log !== undefined)
             installConsole(context, bridge);
-        const result = await context.evalCodeAsync(buildWrapper(source, input, true, bridge.log !== undefined), 'module.js');
+        const result = await context.evalCodeAsync(buildWrapper(source, input, true, bridge.log !== undefined, bridge.execution, bridge.coordination), 'module.js');
         if (result.error) {
             const described = describeError(context, result.error);
             result.error.dispose();
@@ -91,9 +94,14 @@ async function drainPendingJobs(runtime, context) {
  * nondeterministic globals so "deterministic by default" holds for the future resume/idempotency
  * model ([ADR 0004](../../../docs/decisions/0004-code-as-sandboxed-connector.md)).
  */
-function buildWrapper(source, input, hostEnabled = false, consoleEnabled = false) {
+function buildWrapper(source, input, hostEnabled = false, consoleEnabled = false, execution, coordination) {
     const callOperationPrelude = hostEnabled
         ? `
+var __control = function(name, args) {
+  var result = JSON.parse(globalThis.__hostControl(name, JSON.stringify(args)));
+  if (!result.ok) { var error = new Error(result.error.message); error.name = result.error.code; throw error; }
+  return result.output;
+};
 var callOperation = function(name, args) {
   var __hostEnvelope = JSON.parse(globalThis.__hostCallOperation(String(name), JSON.stringify(args ?? {})));
   if (!__hostEnvelope.ok) {
@@ -107,9 +115,16 @@ var callOperation = function(name, args) {
 };
 `
         : '';
-    const handlerArgs = hostEnabled
-        ? `${jsLiteral(input ?? null)}, { callOperation: callOperation }`
-        : jsLiteral(input ?? null);
+    const handlerArgs = `${jsLiteral(input ?? null)}, Object.freeze({
+    time: __timeHelpers, digest: __digestHelper,
+    ${hostEnabled
+        ? `callOperation: callOperation,
+      reportOutcome: function(evidence) { return __control('reportOutcome', evidence); },
+      resolveCoordination: function() { return __control('resolveCoordination', {}); },`
+        : ''}
+    ${coordination === undefined ? '' : `coordination: Object.freeze(${jsLiteral(coordination)}),`}
+    ${execution === undefined ? '' : `execution: Object.freeze(${jsLiteral(execution)}),`}
+  })`;
     const consolePrelude = consoleEnabled
         ? `
 var console = Object.freeze({
@@ -123,7 +138,9 @@ var console = Object.freeze({
         : '';
     const bodyPrefix = `"use strict";
 delete globalThis.Date;
+delete globalThis.Intl;
 delete Math.random;
+${helperPrelude}
 ${callOperationPrelude}
 ${consolePrelude}
 var __handler = (${source});
@@ -141,6 +158,23 @@ var __out = JSON.stringify(__handler(${handlerArgs}));
 }
 function installHostCall(context, bridge, limits) {
     let calls = 0;
+    let controls = 0;
+    const control = context.newAsyncifiedFunction('__hostControl', async (name, args) => {
+        if (++controls > 4 || !bridge.control)
+            return context.newString(JSON.stringify({
+                ok: false,
+                error: { code: 'host_call_denied', message: 'host control budget exceeded' },
+            }));
+        const argsJson = context.getString(args);
+        if (argsJson.length > 2048)
+            return context.newString(JSON.stringify({
+                ok: false,
+                error: { code: 'host_call_denied', message: 'host control input exceeds bound' },
+            }));
+        return context.newString(await bridge.control(context.getString(name), argsJson));
+    });
+    context.setProp(context.global, '__hostControl', control);
+    control.dispose();
     const fn = context.newAsyncifiedFunction('__hostCallOperation', async (nameHandle, argsJsonHandle) => {
         const envelopeJson = await (async () => {
             if (calls >= limits.maxHostCalls) {

package/node_modules/@noodle-borg/compute/dist/worker-entry.js

@@ -29,6 +29,13 @@ function startWorker(port) {
     });
     function bridgeFor(run) {
         return {
+            ...(run.execution === undefined ? {} : { execution: run.execution }),
+            ...(run.coordination === undefined ? {} : { coordination: run.coordination }),
+            control: (name, argsJson) => new Promise((resolve) => {
+                const callId = nextCallId++;
+                pendingHostReplies.set(callId, resolve);
+                post({ t: 'host_control', id: run.id, callId, name, argsJson });
+            }),
             callOperation: (name, argsJson) => new Promise((resolve) => {
                 const callId = nextCallId;
                 nextCallId += 1;

package/node_modules/@noodle-borg/compute/dist/worker-pool.js

@@ -107,6 +107,8 @@ export class ComputeWorkerPool {
             limits: { ...job.limits, timeoutMs: remainingMs },
             hostEnabled: job.host !== undefined,
             consoleEnabled: job.consoleEnabled,
+            ...(job.host?.execution === undefined ? {} : { execution: job.host.execution }),
+            ...(job.host?.coordination === undefined ? {} : { coordination: job.host.coordination }),
         };
         slot.worker.postMessage(message);
     }
@@ -129,7 +131,7 @@ export class ComputeWorkerPool {
             this.#release(slot);
             return;
         }
-        if (message.t === 'host_call') {
+        if (message.t === 'host_call' || message.t === 'host_control') {
             const host = active.job.host;
             const respond = (envelopeJson) => {
                 if (slot.active === active && !active.settled && !slot.dropped) {
@@ -148,8 +150,15 @@ export class ComputeWorkerPool {
                 }));
                 return;
             }
-            host
-                .callOperation(message.name, message.argsJson)
+            const invoke = message.t === 'host_control' ? host.control : host.callOperation;
+            if (!invoke) {
+                respond(JSON.stringify({
+                    ok: false,
+                    error: { code: 'host_call_denied', message: 'host control unavailable' },
+                }));
+                return;
+            }
+            invoke(message.name, message.argsJson)
                 .then(respond)
                 .catch(() => respond(JSON.stringify({
                 ok: false,
@@ -157,6 +166,8 @@ export class ComputeWorkerPool {
             })));
             return;
         }
+        if (message.t !== 'log')
+            return;
         // 'log': deliver to the sink (fire-and-forget failures) and always release the sandbox.
         const ack = () => {
             if (slot.active === active && !active.settled && !slot.dropped) {

package/node_modules/@noodle-borg/connector-defs/dist/compile-http.js

@@ -139,7 +139,7 @@ export function compileHttpConnector(def, mode, errors, catalog, connectors, sec
         const pagination = compilePagination(op, `${base}.pagination`, errors);
         const projection = compileProjection(op, `${base}.projection`, errors);
         const fake = httpFake(op.fake);
-        operations[opName] = buildOperation(op, signature, requestAst, responseAst, headersAst, pagination, fake, projection, evidenceAst);
+        operations[opName] = buildOperation(op, signature, requestAst, responseAst, headersAst, pagination, fake, projection, evidenceAst, compileStatusResponses(op.responses, `${base}.responses`, errors));
         // Per-operation auth declares its own secret reference (overrides any connector-level default).
         addAuthBinding({
             auth: op.auth,
@@ -268,7 +268,7 @@ function compileRequest(request, path, errors) {
 function isRecord(value) {
     return value !== null && typeof value === 'object';
 }
-function buildOperation(op, signature, requestAst, responseAst, headersAst, pagination, fake, projection, evidenceAst) {
+function buildOperation(op, signature, requestAst, responseAst, headersAst, pagination, fake, projection, evidenceAst, responses) {
     const resilience = httpResilience(op.resilience);
     return {
         method: op.method ?? 'GET',
@@ -287,6 +287,7 @@ function buildOperation(op, signature, requestAst, responseAst, headersAst, pagi
         ...(op.limits !== undefined ? { maxResponseBytes: op.limits.maxResponseBytes } : {}),
         ...(op.responseType !== undefined ? { responseType: op.responseType } : {}),
         ...(op.requestEncoding !== undefined ? { requestEncoding: op.requestEncoding } : {}),
+        ...(responses !== undefined ? { responses } : {}),
         ...(evidenceAst === undefined
             ? {}
             : {
@@ -321,6 +322,34 @@ function buildOperation(op, signature, requestAst, responseAst, headersAst, pagi
             : {}),
     };
 }
+function compileStatusResponses(responses, path, errors) {
+    if (responses === undefined)
+        return undefined;
+    return Object.fromEntries(Object.entries(responses).map(([status, response]) => {
+        const responseAst = compileExprMap(response.response, RESPONSE_ROOTS, `${path}.${status}.response`, errors);
+        const evidenceAst = response.evidence === undefined
+            ? undefined
+            : compileExprMap(response.evidence, new Set(['response']), `${path}.${status}.evidence`, errors);
+        return [
+            status,
+            {
+                ...(response.responseType === undefined ? {} : { responseType: response.responseType }),
+                mapResponse: (json, args) => evalMap(responseAst, { args, response: json }),
+                ...(evidenceAst === undefined
+                    ? {}
+                    : {
+                        evidence: (json) => {
+                            const value = evalMap(evidenceAst, { response: json });
+                            return {
+                                outcome: value.outcome === 'rejected' ? 'rejected' : 'unknown',
+                                ...(typeof value.reference === 'string' ? { reference: value.reference } : {}),
+                            };
+                        },
+                    }),
+            },
+        ];
+    }));
+}
 function usesExecutionIdentity(node) {
     if (node.kind === 'path')
         return node.root === 'execution';

package/node_modules/@noodle-borg/connector-defs/dist/compile.d.ts

@@ -1,6 +1,6 @@
 import { type CatalogConnector } from '@noodle-borg/compiler';
 import type { Connector } from '@noodle-borg/runtime';
-import type { ConnectorCompileError } from './compile-expr.js';
+import { type ConnectorCompileError } from './compile-expr.js';
 export type { ConnectorCompileError } from './compile-expr.js';
 /**
  * A binding from a connector operation to the *named* secret its auth scheme needs. It carries the

package/node_modules/@noodle-borg/connector-defs/dist/compile.js

@@ -2,6 +2,7 @@ import { computeSignatureHash, } from '@noodle-borg/compiler';
 import { CodeConnector, DEFAULT_LIMITS, QuickJsComputeEngine, } from '@noodle-borg/compute';
 import { parse as parseYaml } from 'yaml';
 import { validateComputeCallGraph } from './call-graph.js';
+import { compileExpr } from './compile-expr.js';
 import { compileHttpConnector, toSignature } from './compile-http.js';
 import { compileMcpConnector } from './compile-mcp.js';
 import { catalogCredentialMetadata } from './credential-profiles.js';
@@ -119,6 +120,16 @@ function compileComputeConnector(def, engine, targets, errors, catalog, connecto
             module: engine.registerSource(op.code),
             limits,
             ...(calls ? { calls } : {}),
+            ...(op.coordination
+                ? {
+                    coordination: {
+                        connectionId: op.coordination.connectionId,
+                        namespace: op.coordination.namespace,
+                        key: compileExpr(op.coordination.key, new Set(['args', 'env', 'execution']), `${base}.coordination.key`, errors),
+                        reference: compileExpr(op.coordination.reference, new Set(['args', 'env', 'execution']), `${base}.coordination.reference`, errors),
+                    },
+                }
+                : {}),
         };
     }
     catalog.push({
@@ -127,6 +138,15 @@ function compileComputeConnector(def, engine, targets, errors, catalog, connecto
         kind: def.kind ?? 'custom',
         ...catalogCredentialMetadata(def),
         operations: signatures,
+        operationCalls: Object.fromEntries(Object.entries(operations).map(([name, operation]) => [
+            name,
+            Object.values(operation.calls ?? {}).map(({ connectorId, connectorVersion, operation, signatureHash }) => ({
+                connectorId,
+                connectorVersion,
+                operation,
+                signatureHash,
+            })),
+        ])),
     });
     connectors.push(new CodeConnector({ id: def.id, version: def.version, engine, operations }));
 }

package/node_modules/@noodle-borg/connector-defs/dist/schema.d.ts

@@ -99,6 +99,21 @@ declare const httpOperationSchema: z.ZodObject<{
         "form-urlencoded": "form-urlencoded";
     }>>;
     response: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    responses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        response: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        responseType: z.ZodOptional<z.ZodEnum<{
+            json: "json";
+            text: "text";
+            empty: "empty";
+        }>>;
+        evidence: z.ZodOptional<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                unknown: "unknown";
+                rejected: "rejected";
+            }>;
+            reference: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
     evidence: z.ZodOptional<z.ZodObject<{
         outcome: z.ZodString;
         reference: z.ZodOptional<z.ZodString>;
@@ -340,6 +355,12 @@ declare const computeOperationSchema: z.ZodObject<{
         maxHostCalls: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     calls: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    coordination: z.ZodOptional<z.ZodObject<{
+        connectionId: z.ZodString;
+        namespace: z.ZodString;
+        key: z.ZodString;
+        reference: z.ZodString;
+    }, z.core.$strict>>;
     credentials: z.ZodOptional<z.ZodObject<{
         profiles: z.ZodArray<z.ZodString>;
         scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -453,6 +474,21 @@ declare const httpConnectorDefSchema: z.ZodObject<{
             "form-urlencoded": "form-urlencoded";
         }>>;
         response: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        responses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            response: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            responseType: z.ZodOptional<z.ZodEnum<{
+                json: "json";
+                text: "text";
+                empty: "empty";
+            }>>;
+            evidence: z.ZodOptional<z.ZodObject<{
+                outcome: z.ZodEnum<{
+                    unknown: "unknown";
+                    rejected: "rejected";
+                }>;
+                reference: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
         evidence: z.ZodOptional<z.ZodObject<{
             outcome: z.ZodString;
             reference: z.ZodOptional<z.ZodString>;
@@ -796,6 +832,12 @@ declare const computeConnectorDefSchema: z.ZodObject<{
             maxHostCalls: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
         calls: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        coordination: z.ZodOptional<z.ZodObject<{
+            connectionId: z.ZodString;
+            namespace: z.ZodString;
+            key: z.ZodString;
+            reference: z.ZodString;
+        }, z.core.$strict>>;
         credentials: z.ZodOptional<z.ZodObject<{
             profiles: z.ZodArray<z.ZodString>;
             scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -927,6 +969,21 @@ declare const connectorDefSchema: z.ZodUnion<readonly [z.ZodObject<{
             "form-urlencoded": "form-urlencoded";
         }>>;
         response: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        responses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            response: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            responseType: z.ZodOptional<z.ZodEnum<{
+                json: "json";
+                text: "text";
+                empty: "empty";
+            }>>;
+            evidence: z.ZodOptional<z.ZodObject<{
+                outcome: z.ZodEnum<{
+                    unknown: "unknown";
+                    rejected: "rejected";
+                }>;
+                reference: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
         evidence: z.ZodOptional<z.ZodObject<{
             outcome: z.ZodString;
             reference: z.ZodOptional<z.ZodString>;
@@ -1266,6 +1323,12 @@ declare const connectorDefSchema: z.ZodUnion<readonly [z.ZodObject<{
             maxHostCalls: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
         calls: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        coordination: z.ZodOptional<z.ZodObject<{
+            connectionId: z.ZodString;
+            namespace: z.ZodString;
+            key: z.ZodString;
+            reference: z.ZodString;
+        }, z.core.$strict>>;
         credentials: z.ZodOptional<z.ZodObject<{
             profiles: z.ZodArray<z.ZodString>;
             scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -1394,6 +1457,21 @@ export declare const connectorFileSchema: z.ZodObject<{
                 "form-urlencoded": "form-urlencoded";
             }>>;
             response: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            responses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                response: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                responseType: z.ZodOptional<z.ZodEnum<{
+                    json: "json";
+                    text: "text";
+                    empty: "empty";
+                }>>;
+                evidence: z.ZodOptional<z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        unknown: "unknown";
+                        rejected: "rejected";
+                    }>;
+                    reference: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
             evidence: z.ZodOptional<z.ZodObject<{
                 outcome: z.ZodString;
                 reference: z.ZodOptional<z.ZodString>;
@@ -1733,6 +1811,12 @@ export declare const connectorFileSchema: z.ZodObject<{
                 maxHostCalls: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>>;
             calls: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            coordination: z.ZodOptional<z.ZodObject<{
+                connectionId: z.ZodString;
+                namespace: z.ZodString;
+                key: z.ZodString;
+                reference: z.ZodString;
+            }, z.core.$strict>>;
             credentials: z.ZodOptional<z.ZodObject<{
                 profiles: z.ZodArray<z.ZodString>;
                 scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/node_modules/@noodle-borg/connector-defs/dist/schema.js

@@ -308,6 +308,25 @@ const httpOperationSchema = z
     /** How to encode a non-GET request mapping. JSON remains the default. */
     requestEncoding: z.enum(['json', 'form-urlencoded']).optional(),
     response: exprMapSchema.optional(),
+    /** Explicit expected rejection outcomes. Authentication, redirects, rate limits and 5xx fail closed. */
+    responses: z
+        .record(z
+        .string()
+        .regex(/^4\d\d$/u)
+        .refine((status) => !['401', '403', '429'].includes(status)), z
+        .object({
+        response: exprMapSchema,
+        responseType: z.enum(['json', 'text', 'empty']).optional(),
+        evidence: z
+            .object({
+            outcome: z.enum(['rejected', 'unknown']),
+            reference: z.string().min(1).optional(),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict())
+        .optional(),
     /** Explicit provider evidence mapping; never infer completion from an HTTP status or tool name. */
     evidence: z
         .object({ outcome: z.string().min(1), reference: z.string().min(1).optional() })
@@ -339,6 +358,13 @@ const httpOperationSchema = z
 })
     .strict()
     .superRefine((operation, ctx) => {
+    if (operation.responses !== undefined && operation.pagination !== undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['responses'],
+            message: 'HTTP response status mappings cannot be combined with pagination',
+        });
+    }
     if (operation.requestEncoding !== 'form-urlencoded')
         return;
     if (operation.method === undefined || operation.method === 'GET') {
@@ -426,9 +452,26 @@ const computeOperationSchema = z
     code: z.string().min(1),
     limits: computeLimitsSchema.optional(),
     calls: z.record(z.string(), z.string().min(1)).optional(),
+    coordination: z
+        .object({
+        connectionId: z.string().regex(/^[A-Za-z0-9_-]{1,128}$/),
+        namespace: z.string().regex(/^[A-Za-z0-9_-]{1,80}$/),
+        key: z.string().min(1).max(4096),
+        reference: z.string().min(1).max(4096),
+    })
+        .strict()
+        .optional(),
     credentials: operationCredentialsSchema.optional(),
 })
-    .strict();
+    .strict()
+    .superRefine((operation, ctx) => {
+    if (operation.coordination && operation.type !== 'action')
+        ctx.addIssue({
+            code: 'custom',
+            path: ['coordination'],
+            message: 'Coordination requires an action operation',
+        });
+});
 const managedVariableExpressionSchema = z
     .string()
     .regex(/^\$\{env\.[A-Za-z0-9_]+\}$/, 'must be an exact managed variable expression');