@noodleseed/one 0.168.0 → 0.170.0

package/node_modules/@noodle-borg/managed-capabilities/dist/service.js

@@ -0,0 +1,139 @@
+import { createHash } from 'node:crypto';
+import { CapabilityError } from './errors.js';
+import { effectiveWebPolicy, executeWebExtract } from './executor.js';
+import { WEB_EXTRACT_LIMITS } from './limits.js';
+import { capabilityScopeKey, } from './policy-store.js';
+/** Policy/admission authority shared by normal tools and operator diagnostics. Never resolves a model. */
+export class CapabilityService {
+    options;
+    constructor(options) {
+        this.options = options;
+        if (options.profile === 'hosted' && (!options.policies.durable || !options.counters.durable)) {
+            throw new Error('capability_durable_authority_required');
+        }
+    }
+    enabled(tenant) {
+        return (this.options.profile === 'development' ||
+            (this.options.enabledScopes ?? []).some((scope) => scope.org === tenant.org && scope.app === tenant.app && scope.env === tenant.env));
+    }
+    async inspect(tenant, declaration) {
+        const record = await this.options.policies.get({ ...tenant, name: declaration.name });
+        const operator = record === undefined ? {} : policyBounds(record.policy);
+        return {
+            name: declaration.name,
+            class: declaration.class,
+            title: declaration.title,
+            serviceKey: `capability.web-extract.${declaration.name}.provider`,
+            available: this.enabled(tenant) && record?.policy.enabled === true,
+            profile: this.options.profile === 'hosted' ? 'managed-learning-cohort' : 'local-first-party',
+            revision: record?.revision ?? 0,
+            developerPolicy: declaration.policy ?? {},
+            operatorPolicy: record?.policy ?? { enabled: false, dailyCalls: 100 },
+            effectivePolicy: effectiveWebPolicy(declaration.policy, operator),
+            ...(record === undefined ? {} : { actor: record.actor, updatedAt: record.updatedAt }),
+        };
+    }
+    async configure(tenant, declaration, update) {
+        const effective = effectiveWebPolicy(declaration.policy, policyBounds(update.policy));
+        for (const key of ['maxUrls', 'maxCalls', 'timeoutMs', 'maxTextBytes']) {
+            if (update.policy[key] !== undefined && update.policy[key] !== effective[key])
+                throw new CapabilityError('capability_policy_denied');
+        }
+        if (update.policy.domains?.some((host) => !effective.domains?.includes(host)))
+            throw new CapabilityError('capability_policy_denied');
+        return this.options.policies.replace({ ...tenant, name: declaration.name }, update);
+    }
+    async execute(declaration, input, context, reader = this.options.reader) {
+        const scope = { ...context.tenant, name: declaration.name };
+        if (!this.enabled(context.tenant))
+            throw new CapabilityError('capability_unavailable');
+        let record;
+        try {
+            record = await this.options.policies.get(scope);
+        }
+        catch {
+            throw new CapabilityError('capability_unavailable');
+        }
+        if (record?.policy.enabled !== true)
+            throw new CapabilityError('capability_unavailable');
+        if (context.anonymous && !context.network)
+            throw new CapabilityError('capability_policy_denied');
+        if (!context.anonymous && !context.subject)
+            throw new CapabilityError('capability_policy_denied');
+        const scopeId = opaque(capabilityScopeKey(scope));
+        const amount = WEB_EXTRACT_LIMITS.maxHttpAttempts;
+        const attribution = context.anonymous
+            ? `network:${context.network}`
+            : `subject:${context.subject}`;
+        const started = Date.now();
+        try {
+            const result = await executeWebExtract(declaration, input, {
+                reader,
+                enabled: true,
+                authorized: context.authorized,
+                budget: context.budget,
+                operatorPolicy: policyBounds(record.policy),
+                ...(context.signal === undefined ? {} : { signal: context.signal }),
+                admit: async () => {
+                    const requests = [
+                        { key: 'capability:web-extract:fleet', amount, limit: 1000 * amount },
+                        { key: `capability:${scopeId}`, amount, limit: record.policy.dailyCalls * amount },
+                        {
+                            key: `capability:caller:${opaque(`${scopeId}:${attribution}`)}`,
+                            amount,
+                            limit: 10 * amount,
+                        },
+                        ...(context.network === undefined
+                            ? []
+                            : [
+                                {
+                                    key: `capability:network:${opaque(context.network)}`,
+                                    amount,
+                                    limit: 30 * amount,
+                                },
+                            ]),
+                    ];
+                    const attempt = {
+                        key: `capability:attempt:${opaque(`${scopeId}:${context.deploymentId}:${context.executionId}`)}`,
+                        fingerprint: opaque(JSON.stringify(input)),
+                    };
+                    const outcome = await this.options.counters.consumeAllOnce(requests, attempt, new Date());
+                    // A replay is not a cache hit: there is no retained source body, so it cannot authorize more I/O.
+                    return outcome.kind === 'consumed';
+                },
+            });
+            await this.options.audit?.({
+                ...context.tenant,
+                class: declaration.class,
+                scope: scopeId,
+                policyRevision: record.revision,
+                status: result.status,
+                pages: result.items.length,
+                elapsedMs: Date.now() - started,
+            });
+            return result;
+        }
+        catch (error) {
+            const safe = error instanceof CapabilityError ? error : new CapabilityError('capability_unavailable');
+            await Promise.resolve()
+                .then(() => this.options.audit?.({
+                ...context.tenant,
+                class: declaration.class,
+                scope: scopeId,
+                policyRevision: record.revision,
+                status: safe.code,
+                elapsedMs: Date.now() - started,
+            }))
+                .catch(() => { });
+            throw safe;
+        }
+    }
+}
+function opaque(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function policyBounds(policy) {
+    const { enabled: _enabled, dailyCalls: _daily, ...bounds } = policy;
+    return bounds;
+}
+//# sourceMappingURL=service.js.map

package/node_modules/@noodle-borg/managed-capabilities/dist/urls.d.ts

@@ -0,0 +1,3 @@
+/** Syntactic policy only. The adapter must additionally pin socket DNS to public unicast addresses. */
+export declare function publicPageUrl(value: string, domains?: readonly string[]): URL;
+//# sourceMappingURL=urls.d.ts.map

package/node_modules/@noodle-borg/managed-capabilities/dist/urls.js

@@ -0,0 +1,30 @@
+import { isIP } from 'node:net';
+import { CapabilityError } from './errors.js';
+import { WEB_EXTRACT_LIMITS } from './limits.js';
+/** Syntactic policy only. The adapter must additionally pin socket DNS to public unicast addresses. */
+export function publicPageUrl(value, domains) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new CapabilityError('capability_source_rejected');
+    }
+    const host = url.hostname;
+    if (value.length > WEB_EXTRACT_LIMITS.maxUrlCharacters ||
+        url.protocol !== 'https:' ||
+        url.username !== '' ||
+        url.password !== '' ||
+        url.port !== '' ||
+        url.search !== '' ||
+        isIP(host.replace(/^\[|\]$/g, '')) !== 0 ||
+        !host.includes('.') ||
+        host.endsWith('.') ||
+        /(?:^|\.)(?:localhost|local|internal|test|invalid)$/.test(host) ||
+        (domains !== undefined && !domains.includes(host))) {
+        throw new CapabilityError('capability_source_rejected');
+    }
+    url.hash = '';
+    return url;
+}
+//# sourceMappingURL=urls.js.map

package/node_modules/@noodle-borg/managed-capabilities/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@noodle-borg/managed-capabilities",
+  "version": "0.0.0",
+  "license": "Apache-2.0",
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "main": "./dist/portable.js",
+  "types": "./dist/portable.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/portable.d.ts",
+      "import": "./dist/portable.js"
+    },
+    "./portable": {
+      "types": "./dist/portable.d.ts",
+      "import": "./dist/portable.js"
+    },
+    "./contracts": {
+      "types": "./dist/operator-contracts.d.ts",
+      "import": "./dist/operator-contracts.js"
+    },
+    "./testing": {
+      "types": "./dist/conformance.d.ts",
+      "import": "./dist/conformance.js"
+    },
+    "./postgres": {
+      "types": "./dist/postgres.d.ts",
+      "import": "./dist/postgres.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@noodle-borg/module": "0.0.0",
+    "@noodle-borg/admission-limits": "0.0.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.1",
+    "@types/pg": "^8.20.0"
+  }
+}

package/node_modules/@noodle-borg/module/dist/contract.d.ts

@@ -25,6 +25,17 @@ export interface ModuleRouteContext {
     readonly tenantControl?: TenantControlAuthorizer;
     /** Narrow deployment/App Package projection for hosted package operations. */
     readonly deploymentPackages?: DeploymentPackageView;
+    /** Read-only exact active capability declarations, available after same-request tenant authorization. */
+    readonly capabilityDeployments?: {
+        get(req: IncomingMessage, scope: {
+            readonly org: string;
+            readonly app: string;
+            readonly env: string;
+        }): Promise<{
+            readonly deploymentId: string;
+            readonly declarations: readonly unknown[];
+        } | undefined>;
+    };
     /** Minimal live deployment/package identity used only after an opaque delivery lookup. */
     readonly distributionDelivery?: DistributionDeliveryView;
     /** Host audit sink for route-emitted audit events; absent means the host has no audit trail. */

package/node_modules/@noodle-borg/runtime/dist/confirmation.js

@@ -1,3 +1,4 @@
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import { resolveVariableEnvironment, validateVariableContinuation } from './business-variables.js';
 import { analyzeEligibleActions, countTrailingEligibleOperations, isActionOperation, validateConfirmationFlow, } from './confirmation-analysis.js';
 import { artifactIdentity, confirmationRequired, sameArtifact, } from './confirmation-continuation.js';
@@ -10,12 +11,32 @@ import { createHost, evalExprMap, prepareOperationAction, resolveEnv, runOperati
 import { AllowAllPolicy } from './policy/allow-all.js';
 import { attachResultMeta, splitResultMeta } from './result-meta.js';
 import { admitToolDispatch, latchToolDispatchAdmission } from './tool-dispatch.js';
+function carryBudget(result, budget) {
+    if (result.status === 'input_required')
+        return {
+            ...result,
+            continuation: { ...result.continuation, capabilityBudget: budget.snapshot() },
+        };
+    if (result.status === 'confirmation_required')
+        return {
+            ...result,
+            continuation: { ...result.continuation, capabilityBudget: budget.snapshot() },
+        };
+    return result;
+}
 /**
  * Evaluate the pure prefix of a confirmable tool. Connector operations are an absolute suspension
  * boundary: this function either requests input, returns a prepared confirmation, or fails before
  * invoking one.
  */
 export async function prepareToolForConfirmation(artifact, toolName, input, deps) {
+    const capabilityBudget = deps.capabilityBudget ?? new CapabilityBudget();
+    return carryBudget(await prepareToolForConfirmationInternal(artifact, toolName, input, {
+        ...deps,
+        capabilityBudget,
+    }), capabilityBudget);
+}
+async function prepareToolForConfirmationInternal(artifact, toolName, input, deps) {
     if (artifact.resolution !== 'resolved') {
         return failPreparation('shape_only_artifact', 'runtime refuses to serve a shape-only artifact');
     }
@@ -52,6 +73,13 @@ export async function prepareToolForConfirmation(artifact, toolName, input, deps
 }
 /** Resume the pure preparation prefix with one accepted, declined, or cancelled input response. */
 export async function resumeToolPreparation(artifact, continuation, response, deps) {
+    const capabilityBudget = new CapabilityBudget(continuation.capabilityBudget);
+    return carryBudget(await resumeToolPreparationInternal(artifact, continuation, response, {
+        ...deps,
+        capabilityBudget,
+    }), capabilityBudget);
+}
+async function resumeToolPreparationInternal(artifact, continuation, response, deps) {
     if (artifact.resolution !== 'resolved') {
         return failPreparation('shape_only_artifact', 'runtime refuses to serve a shape-only artifact');
     }
@@ -94,6 +122,7 @@ export async function resumeToolPreparation(artifact, continuation, response, de
  * after performing a side effect.
  */
 export async function executePreparedTool(artifact, continuation, deps) {
+    deps = { ...deps, capabilityBudget: new CapabilityBudget(continuation.capabilityBudget) };
     if (artifact.resolution !== 'resolved') {
         return failInteractive('shape_only_artifact', 'runtime refuses to serve a shape-only artifact');
     }

package/node_modules/@noodle-borg/runtime/dist/connector/types.d.ts

@@ -1,4 +1,5 @@
 import type { CredentialProfile, OperationSignature, ResolvedOperationRef } from '@noodle-borg/compiler';
+import type { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import type { DownstreamCredential } from '../broker/types.js';
 import type { CustomerConnectorRoute } from '../customer-routing.js';
 import type { OperationCoordinationDeclaration, OperationCoordinationSnapshot } from '../operation-coordination.js';
@@ -81,6 +82,7 @@ export interface ConnectorCallHost {
 }
 /** A single connector-operation invocation, fully resolved and credentialed by the runtime. */
 export interface ConnectorCall {
+    readonly capabilityBudget?: CapabilityBudget;
     readonly operation: string;
     /** Runtime-generated, deployment/step-bound identity. Not a business input or recovery authority. */
     readonly execution?: Readonly<{

package/node_modules/@noodle-borg/runtime/dist/execute.d.ts

@@ -1,4 +1,5 @@
 import type { ArtifactFulfilment, RuntimeArtifact } from '@noodle-borg/compiler';
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import type { CredentialBroker } from './broker/types.js';
 import type { CallerIdentity, ConnectorRegistry, ExecutionTraceSink } from './connector/types.js';
 import type { FrozenCustomerRoutes } from './customer-routing.js';
@@ -18,6 +19,8 @@ export { evalExprMap, validateAgainstSchema, validateAgainstSchemaWithDefaults,
  * [ADR 0005](../../../docs/decisions/0005-runtime-execution-boundary.md)).
  */
 export interface ExecuteDeps {
+    /** Trusted shared assistant-turn / MCP-invocation budget; never part of the expression scope. */
+    readonly capabilityBudget?: CapabilityBudget;
     readonly connectors: ConnectorRegistry;
     readonly broker: CredentialBroker;
     readonly policy?: PolicyGate;

package/node_modules/@noodle-borg/runtime/dist/execute.js

@@ -1,3 +1,4 @@
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import { resolveVariableEnvironment } from './business-variables.js';
 import { preflightFulfilmentSignatures } from './connector-snapshot.js';
 import { preflightFulfilmentCustomerRoutes } from './customer-routing.js';
@@ -29,7 +30,11 @@ export async function executeTool(artifact, toolName, input, deps) {
     const variables = resolveVariableEnvironment(artifact.server.variables ?? [], await resolveEnv(deps), toolName);
     if (!variables.ok)
         return variables;
-    return runFulfilment(tool.fulfilment, input, toolName, { ...deps, env: variables.env }, deps.beforeDispatch);
+    return runFulfilment(tool.fulfilment, input, toolName, {
+        ...deps,
+        env: variables.env,
+        capabilityBudget: deps.capabilityBudget ?? new CapabilityBudget(),
+    }, deps.beforeDispatch);
 }
 /**
  * Execute a resource read against a resolved artifact. `input` is the resource's variable scope — the

package/node_modules/@noodle-borg/runtime/dist/index.d.ts

@@ -20,8 +20,9 @@ export type { OperationEvidence, OperationEvidenceIntent, OperationEvidencePort,
 export { AllowAllPolicy } from './policy/allow-all.js';
 export type { PolicyContext, PolicyDecision, PolicyGate } from './policy/types.js';
 export { type ConfirmationActionReview, type ConfirmationPreparationResult, type ConfirmationReview, type ConnectorFailureAttribution, type ElicitationRequest, type ElicitationResponse, type ExecutionError, type ExecutionErrorCode, type ExecutionResult, type InteractiveExecutionResult, isConfirmationRequired, isInputRequired, isInputRequiredForConfirmation, type PreparedOperationAction, type PreparedToolContinuation, type ToolContinuation, type ToolPreparationContinuation, } from './result.js';
-export { splitResultMeta } from './result-meta.js';
+export { hasEphemeralEvidence, splitResultMeta } from './result-meta.js';
 export { type CallerStateAdoptionInput, type CallerStateAdoptionResult, claimableStateHandleNames, } from './state-handle-ownership.js';
 export { assertExpectedStateRevision, assertNoSecretValue, assertSchemaValue, assertStateHandleNotCompleted, COMPLETE_STATE_OPERATION, createMutableStateHandleRecord, createStateConnector, InMemoryStateHandleStore, type MutableStateHandleRecord, PATCH_STATE_OPERATION, READ_STATE_OPERATION, STATE_CONNECTOR_ID, STATE_CONNECTOR_VERSION, STATE_OPERATION_SIGNATURES, StateConnector, type StateHandleRecord, type StateHandleStore, type StateInput, type StateMutationInput, type StatePatchInput, stateHandleRecordForMutation, toPublicStateHandleRecord, } from './state-handles.js';
 export type { ToolDispatchContext, ToolDispatchDecision, ToolDispatchHook, } from './tool-dispatch.js';
+export { WebCapabilityConnector, type WebCapabilityExecutionPort } from './web-capabilities.js';
 //# sourceMappingURL=index.d.ts.map

package/node_modules/@noodle-borg/runtime/dist/index.js

@@ -15,7 +15,8 @@ export { executeToolInteractive, resumeTool } from './interactive.js';
 export { resolveManagedOrigins, } from './managed-origins.js';
 export { AllowAllPolicy } from './policy/allow-all.js';
 export { isConfirmationRequired, isInputRequired, isInputRequiredForConfirmation, } from './result.js';
-export { splitResultMeta } from './result-meta.js';
+export { hasEphemeralEvidence, splitResultMeta } from './result-meta.js';
 export { claimableStateHandleNames, } from './state-handle-ownership.js';
 export { assertExpectedStateRevision, assertNoSecretValue, assertSchemaValue, assertStateHandleNotCompleted, COMPLETE_STATE_OPERATION, createMutableStateHandleRecord, createStateConnector, InMemoryStateHandleStore, PATCH_STATE_OPERATION, READ_STATE_OPERATION, STATE_CONNECTOR_ID, STATE_CONNECTOR_VERSION, STATE_OPERATION_SIGNATURES, StateConnector, stateHandleRecordForMutation, toPublicStateHandleRecord, } from './state-handles.js';
+export { WebCapabilityConnector } from './web-capabilities.js';
 //# sourceMappingURL=index.js.map

package/node_modules/@noodle-borg/runtime/dist/interactive.js

@@ -1,3 +1,4 @@
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import { resolveVariableEnvironment, validateVariableContinuation } from './business-variables.js';
 import { preflightFulfilmentCustomerRoutes } from './customer-routing.js';
 import { validateElicitationContent } from './elicitation-response.js';
@@ -17,7 +18,11 @@ export async function executeToolInteractive(artifact, toolName, input, deps) {
     const variables = resolveVariableEnvironment(artifact.server.variables ?? [], await resolveEnv(deps), toolName);
     if (!variables.ok)
         return { status: 'failed', error: variables.error };
-    deps = { ...deps, env: variables.env };
+    deps = {
+        ...deps,
+        env: variables.env,
+        capabilityBudget: deps.capabilityBudget ?? new CapabilityBudget(),
+    };
     if (tool.fulfilment.kind !== 'flow' || !tool.fulfilment.steps.some((s) => s.kind === 'elicit')) {
         return toInteractive(await runFulfilment(tool.fulfilment, input, toolName, deps, deps.beforeDispatch));
     }
@@ -32,6 +37,7 @@ export async function executeToolInteractive(artifact, toolName, input, deps) {
 }
 /** Resume one server-held continuation with the user's reviewed response. */
 export async function resumeTool(artifact, continuation, response, deps) {
+    deps = { ...deps, capabilityBudget: new CapabilityBudget(continuation.capabilityBudget) };
     if (!sameArtifact(artifact, continuation) || continuation.version !== 1) {
         return interactiveFail('invalid_continuation', 'tool continuation does not match the artifact');
     }
@@ -84,6 +90,9 @@ async function runInteractiveFlow(artifact, toolName, flow, input, startIndex, s
                     status: 'input_required',
                     request,
                     continuation: {
+                        ...(deps.capabilityBudget === undefined
+                            ? {}
+                            : { capabilityBudget: deps.capabilityBudget.snapshot() }),
                         version: 1,
                         artifact: artifactIdentity(artifact),
                         toolName,

package/node_modules/@noodle-borg/runtime/dist/operation-execution.js

@@ -224,6 +224,9 @@ async function invokeOperation(ref, args, sig, toolName, deps, policy, host, env
                     if (signal?.aborted)
                         return fail('execution_cancelled', 'Execution deadline elapsed before connector dispatch.');
                     output = await connector.invoke({
+                        ...(deps.capabilityBudget === undefined
+                            ? {}
+                            : { capabilityBudget: deps.capabilityBudget }),
                         operation: ref.operation,
                         execution,
                         reportOutcome: (value) => {

package/node_modules/@noodle-borg/runtime/dist/result-meta.d.ts

@@ -1,3 +1,5 @@
+/** Ephemeral extraction evidence is usable in the current turn but never replay/persistence data. */
+export declare function hasEphemeralEvidence(output: unknown): boolean;
 /** @internal Shared with suspension-aware execution and surface adapters. */
 export declare function splitResultMeta(output: unknown): {
     readonly visible: unknown;

package/node_modules/@noodle-borg/runtime/dist/result-meta.js

@@ -1,4 +1,8 @@
 const RESULT_META_KEY = '__noodleResultMeta';
+/** Ephemeral extraction evidence is usable in the current turn but never replay/persistence data. */
+export function hasEphemeralEvidence(output) {
+    return splitResultMeta(output).meta?.['noodle/ephemeralEvidence'] === true;
+}
 /** @internal Shared with suspension-aware execution and surface adapters. */
 export function splitResultMeta(output) {
     if (output === null || typeof output !== 'object' || Array.isArray(output)) {
@@ -31,6 +35,8 @@ export function attachResultMeta(output, metas) {
 }
 function mergeRecords(target, source) {
     for (const [key, value] of Object.entries(source)) {
+        if (key === 'noodle/ephemeralEvidence' && target[key] === true)
+            continue;
         const existing = target[key];
         if (isPlainRecord(existing) && isPlainRecord(value)) {
             mergeRecords(existing, value);

package/node_modules/@noodle-borg/runtime/dist/result.d.ts

@@ -1,4 +1,5 @@
 import type { CredentialProfile } from '@noodle-borg/compiler';
+import type { CapabilityBudgetSnapshot } from '@noodle-borg/managed-capabilities';
 import type { ConnectorFailureCategory } from './connector/types.js';
 import type { CustomerRouteBinding } from './customer-routing.js';
 /** Why a tool call could not be fulfilled. Protocol and embedded adapters map this internal contract. */
@@ -60,6 +61,7 @@ export type ElicitationResponse = {
  * never be serialized into MCP or embedded-assistant client payloads.
  */
 export interface ToolContinuation {
+    readonly capabilityBudget?: CapabilityBudgetSnapshot;
     readonly version: 1;
     readonly artifact: {
         readonly manifestName: string;
@@ -86,6 +88,7 @@ interface ContinuationArtifactIdentity {
  * can evaluate pure maps and request more input, but cannot execute a connector operation.
  */
 export interface ToolPreparationContinuation {
+    readonly capabilityBudget?: CapabilityBudgetSnapshot;
     readonly kind: 'confirmation_preparation';
     readonly version: 1;
     readonly artifact: ContinuationArtifactIdentity;
@@ -102,6 +105,7 @@ export interface ToolPreparationContinuation {
  * behind an opaque interaction id and release it to {@code executePreparedTool} only after approval.
  */
 export interface PreparedToolContinuation {
+    readonly capabilityBudget?: CapabilityBudgetSnapshot;
     readonly kind: 'prepared_confirmation';
     /** Private hosting snapshot; never projected into a model-visible confirmation. */
     readonly executionRevision?: string;

package/node_modules/@noodle-borg/runtime/dist/web-capabilities.d.ts

@@ -0,0 +1,71 @@
+import type { WebCapability, WebExtractResult } from '@noodle-borg/managed-capabilities';
+import { type Connector, type ConnectorCall } from './connector/types.js';
+export type WebCapabilityExecutionPort = (declaration: WebCapability, request: unknown, call: ConnectorCall) => Promise<WebExtractResult>;
+/** Thin ordinary connector; deployment binding and policy authority are injected by the service. */
+export declare class WebCapabilityConnector implements Connector {
+    private readonly declarations;
+    private readonly execute;
+    readonly id = "noodle_web";
+    readonly version = "1.0.0";
+    constructor(declarations: readonly WebCapability[], execute: WebCapabilityExecutionPort);
+    signature(operation: string): {
+        type: "read";
+        input: import("zod/v4/core").ZodStandardJSONSchemaPayload<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            request: import("zod").ZodObject<{
+                urls: import("zod").ZodArray<import("zod").ZodString>;
+                domains: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>>;
+        output: import("zod/v4/core").ZodStandardJSONSchemaPayload<import("zod").ZodObject<{
+            status: import("zod").ZodEnum<{
+                complete: "complete";
+                partial: "partial";
+            }>;
+            items: import("zod").ZodArray<import("zod").ZodObject<{
+                requestIndex: import("zod").ZodNumber;
+                sourceRef: import("zod").ZodString;
+                content: import("zod").ZodObject<{
+                    format: import("zod").ZodLiteral<"text">;
+                    text: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+                links: import("zod").ZodArray<import("zod").ZodObject<{
+                    url: import("zod").ZodString;
+                    label: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>>;
+                truncated: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strict>>;
+            sources: import("zod").ZodArray<import("zod").ZodObject<{
+                ref: import("zod").ZodString;
+                url: import("zod").ZodString;
+                title: import("zod").ZodOptional<import("zod").ZodString>;
+                retrievedAt: import("zod").ZodISODateTime;
+                publishedAt: import("zod").ZodOptional<import("zod").ZodISODateTime>;
+                observedAt: import("zod").ZodOptional<import("zod").ZodISODateTime>;
+                expiresAt: import("zod").ZodOptional<import("zod").ZodISODateTime>;
+                attribution: import("zod").ZodOptional<import("zod").ZodString>;
+                rights: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+            warnings: import("zod").ZodArray<import("zod").ZodObject<{
+                requestIndex: import("zod").ZodNumber;
+                code: import("zod").ZodEnum<{
+                    capability_unavailable: "capability_unavailable";
+                    capability_binding_invalid: "capability_binding_invalid";
+                    capability_requirement_unsupported: "capability_requirement_unsupported";
+                    capability_policy_denied: "capability_policy_denied";
+                    capability_budget_exhausted: "capability_budget_exhausted";
+                    capability_source_rejected: "capability_source_rejected";
+                    capability_provider_failed: "capability_provider_failed";
+                    capability_result_invalid: "capability_result_invalid";
+                    capability_cancelled: "capability_cancelled";
+                    content_truncated: "content_truncated";
+                }>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>>;
+    } | undefined;
+    executionBoundMs(): number;
+    invoke(call: ConnectorCall): Promise<WebExtractResult & {
+        readonly __noodleResultMeta: Readonly<Record<string, unknown>>;
+    }>;
+}
+//# sourceMappingURL=web-capabilities.d.ts.map

package/node_modules/@noodle-borg/runtime/dist/web-capabilities.js

@@ -0,0 +1,41 @@
+import { CapabilityError, WEB_CONNECTOR_ID, WEB_CONNECTOR_VERSION, WEB_OPERATION_SIGNATURE, webOperationInputSchema, } from '@noodle-borg/managed-capabilities';
+import { ConnectorInvocationError } from './connector/types.js';
+/** Thin ordinary connector; deployment binding and policy authority are injected by the service. */
+export class WebCapabilityConnector {
+    declarations;
+    execute;
+    id = WEB_CONNECTOR_ID;
+    version = WEB_CONNECTOR_VERSION;
+    constructor(declarations, execute) {
+        this.declarations = declarations;
+        this.execute = execute;
+    }
+    signature(operation) {
+        return operation === 'extract' ? WEB_OPERATION_SIGNATURE : undefined;
+    }
+    executionBoundMs() {
+        return 30_000;
+    }
+    async invoke(call) {
+        const input = webOperationInputSchema.safeParse(call.args);
+        const declaration = input.success
+            ? this.declarations.find((value) => value.name === input.data.name)
+            : undefined;
+        if (call.operation !== 'extract' ||
+            declaration === undefined ||
+            !input.success ||
+            call.capabilityBudget === undefined) {
+            throw new ConnectorInvocationError('capability_policy_denied', { retryable: false });
+        }
+        try {
+            return {
+                ...(await this.execute(declaration, input.data.request, call)),
+                __noodleResultMeta: { 'noodle/ephemeralEvidence': true },
+            };
+        }
+        catch (error) {
+            throw new ConnectorInvocationError(error instanceof CapabilityError ? error.code : 'capability_unavailable', { retryable: false });
+        }
+    }
+}
+//# sourceMappingURL=web-capabilities.js.map

package/node_modules/@noodle-borg/runtime/package.json

@@ -26,6 +26,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
+    "@noodle-borg/managed-capabilities": "0.0.0",
     "@noodle-borg/compiler": "0.0.0",
     "@noodle-borg/module": "0.0.0"
   },

package/node_modules/@noodle-borg/service/dist/deployment-deletion.js

@@ -0,0 +1,40 @@
+import { normalizeServerVersion } from '@noodle-borg/module';
+import { sameTenantRecord } from './deployment-versioning.js';
+import { validateTenantRef } from './store/validate.js';
+/** Shared, side-effect-free decision made inside each adapter's mutation boundary. */
+export function planDeploymentDeletion(records, ref, selection) {
+    const safe = validateTenantRef(ref);
+    const version = selection.kind === 'version' && selection.serverVersion !== undefined
+        ? normalizeServerVersion(selection.serverVersion)
+        : undefined;
+    const deleted = records.filter((record) => sameTenantRecord(record, safe) &&
+        (selection.kind === 'deployment'
+            ? record.deploymentId === selection.deploymentId
+            : record.serverVersion === version));
+    if (deleted.length === 0)
+        return {
+            ok: false,
+            code: selection.kind === 'deployment' ? 'deployment_not_found' : 'version_not_found',
+        };
+    if (records.some((record) => record.orgSlug === safe.org &&
+        record.appSlug === safe.app &&
+        record.archivedAt !== undefined)) {
+        return { ok: false, code: 'app_archived' };
+    }
+    if (selection.kind === 'deployment') {
+        if (deleted.some((record) => record.active))
+            return { ok: false, code: 'active_deployment' };
+    }
+    else {
+        if (deleted.some((record) => record.active && record.deploymentLock !== undefined))
+            return { ok: false, code: 'deployment_locked' };
+        const expected = new Set(selection.expectedDeploymentIds);
+        if (expected.size !== selection.expectedDeploymentIds.length ||
+            expected.size !== deleted.length ||
+            deleted.some((record) => !expected.has(record.deploymentId))) {
+            return { ok: false, code: 'deployment_delete_conflict' };
+        }
+    }
+    return { ok: true, deleted };
+}
+//# sourceMappingURL=deployment-deletion.js.map