@noodleseed/one 0.169.0 → 0.171.0

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

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+import { CAPABILITY_ERROR_CODES } from './errors.js';
+import { WEB_EXTRACT_LIMITS as limits } from './limits.js';
+const domainSchema = z
+    .string()
+    .max(253)
+    .regex(/^(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z][a-z0-9-]*$/);
+export const capabilityNameSchema = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[a-z][a-z0-9_]*$/);
+export const webPolicySchema = z
+    .object({
+    maxUrls: z.number().int().min(1).max(limits.maxUrls).optional(),
+    maxCalls: z.number().int().min(1).max(limits.maxCalls).optional(),
+    timeoutMs: z.number().int().min(100).max(limits.timeoutMs).optional(),
+    maxTextBytes: z.number().int().min(256).max(limits.maxTextBytes).optional(),
+    domains: z.array(domainSchema).min(1).max(32).optional(),
+})
+    .strict();
+export const webCapabilityBaseSchema = z
+    .object({
+    name: capabilityNameSchema,
+    class: z.literal('web.extract.v1'),
+    title: z.string().trim().min(1).max(120),
+    description: z.string().trim().min(1).max(1000),
+    provider: z.object({ kind: z.literal('noodle-managed') }).strict(),
+    policy: webPolicySchema.optional(),
+})
+    .strict();
+export const webExtractRequestSchema = z
+    .object({
+    urls: z.array(z.string().min(1).max(limits.maxUrlCharacters)).min(1).max(limits.maxUrls),
+    domains: z.array(domainSchema).min(1).max(32).optional(),
+})
+    .strict();
+const sourceSchema = z
+    .object({
+    ref: z.string().min(1).max(80),
+    url: z.string().max(limits.maxUrlCharacters).url(),
+    title: z.string().max(512).optional(),
+    retrievedAt: z.iso.datetime(),
+    publishedAt: z.iso.datetime().optional(),
+    observedAt: z.iso.datetime().optional(),
+    expiresAt: z.iso.datetime().optional(),
+    attribution: z.string().max(512).optional(),
+    rights: z.string().max(512).optional(),
+})
+    .strict();
+export const webExtractResultSchema = z
+    .object({
+    status: z.enum(['complete', 'partial']),
+    items: z
+        .array(z
+        .object({
+        requestIndex: z
+            .number()
+            .int()
+            .min(0)
+            .max(limits.maxUrls - 1),
+        sourceRef: z.string().min(1).max(80),
+        content: z
+            .object({
+            format: z.literal('text'),
+            text: z.string().min(1).max(limits.maxTextBytes),
+        })
+            .strict(),
+        links: z
+            .array(z
+            .object({
+            url: z.string().max(limits.maxUrlCharacters).url(),
+            label: z.string().max(200).optional(),
+        })
+            .strict())
+            .max(limits.maxLinks),
+        truncated: z.boolean(),
+    })
+        .strict())
+        .min(1)
+        .max(limits.maxUrls),
+    sources: z.array(sourceSchema).min(1).max(limits.maxUrls),
+    warnings: z
+        .array(z
+        .object({
+        requestIndex: z
+            .number()
+            .int()
+            .min(0)
+            .max(limits.maxUrls - 1),
+        code: z.enum([...CAPABILITY_ERROR_CODES, 'content_truncated']),
+    })
+        .strict())
+        .max(limits.maxUrls * 2),
+})
+    .strict();
+export const WEB_CONNECTOR_ID = 'noodle_web';
+export const WEB_CONNECTOR_VERSION = '1.0.0';
+export const webOperationInputSchema = z
+    .object({ name: capabilityNameSchema, request: webExtractRequestSchema })
+    .strict();
+export const WEB_OPERATION_SIGNATURE = {
+    type: 'read',
+    input: z.toJSONSchema(webOperationInputSchema),
+    output: z.toJSONSchema(webExtractResultSchema),
+};
+export const WEB_CATALOG_CONNECTOR = {
+    id: WEB_CONNECTOR_ID,
+    version: WEB_CONNECTOR_VERSION,
+    kind: 'builtin',
+    operations: { extract: WEB_OPERATION_SIGNATURE },
+};
+//# sourceMappingURL=contracts.js.map

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

@@ -0,0 +1,8 @@
+export declare const CAPABILITY_ERROR_CODES: readonly ["capability_unavailable", "capability_binding_invalid", "capability_requirement_unsupported", "capability_policy_denied", "capability_budget_exhausted", "capability_source_rejected", "capability_provider_failed", "capability_result_invalid", "capability_cancelled"];
+export type CapabilityErrorCode = (typeof CAPABILITY_ERROR_CODES)[number];
+/** Messages are fixed safe codes: never retain a URL, provider payload or a nested cause. */
+export declare class CapabilityError extends Error {
+    readonly code: CapabilityErrorCode;
+    constructor(code: CapabilityErrorCode);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1,21 @@
+export const CAPABILITY_ERROR_CODES = [
+    'capability_unavailable',
+    'capability_binding_invalid',
+    'capability_requirement_unsupported',
+    'capability_policy_denied',
+    'capability_budget_exhausted',
+    'capability_source_rejected',
+    'capability_provider_failed',
+    'capability_result_invalid',
+    'capability_cancelled',
+];
+/** Messages are fixed safe codes: never retain a URL, provider payload or a nested cause. */
+export class CapabilityError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'CapabilityError';
+    }
+}
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1,26 @@
+import type { CapabilityBudget } from './budget.js';
+import { type WebCapability, type WebExtractResult, type WebPolicy } from './contracts.js';
+export interface PublicPageReaderPort {
+    read(request: {
+        readonly url: string;
+        readonly domains?: readonly string[];
+        readonly signal: AbortSignal;
+        readonly beforeRequest: () => void;
+        readonly maxBytes: number;
+    }): Promise<unknown>;
+}
+export interface WebExtractDeps {
+    readonly reader: PublicPageReaderPort;
+    readonly budget: CapabilityBudget;
+    readonly enabled: boolean;
+    /** Computed from verified caller claims and the underlying declaration, never from tool arguments. */
+    readonly authorized: boolean;
+    readonly operatorPolicy: WebPolicy;
+    readonly signal?: AbortSignal;
+    /** Durable, attributable admission. A refusal or outage must not dispatch the reader. */
+    readonly admit: () => Promise<boolean>;
+}
+export declare function effectiveWebPolicy(developer?: WebPolicy, operator?: WebPolicy): WebPolicy;
+/** One governed path for generated MCP tools, assistant calls and composed operations. */
+export declare function executeWebExtract(declaration: WebCapability, input: unknown, deps: WebExtractDeps): Promise<WebExtractResult>;
+//# sourceMappingURL=executor.d.ts.map

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

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+import { webExtractRequestSchema, webExtractResultSchema, webPolicySchema, } from './contracts.js';
+import { CapabilityError } from './errors.js';
+import { WEB_EXTRACT_LIMITS as limits } from './limits.js';
+import { publicPageUrl } from './urls.js';
+const pageSchema = z
+    .object({
+    url: z.string().max(limits.maxUrlCharacters),
+    title: z.string().max(512),
+    text: z.string().min(1).max(limits.maxPageBytes),
+    retrievedAt: z.iso.datetime(),
+    links: z
+        .array(z
+        .object({
+        url: z.string().max(limits.maxUrlCharacters),
+        label: z.string().max(200).optional(),
+    })
+        .strict())
+        .max(limits.maxLinks),
+})
+    .strict();
+export function effectiveWebPolicy(developer = {}, operator = {}) {
+    const a = webPolicySchema.parse(developer);
+    const b = webPolicySchema.parse(operator);
+    const domains = intersectDomains(a.domains, b.domains);
+    return {
+        maxUrls: Math.min(a.maxUrls ?? limits.maxUrls, b.maxUrls ?? limits.maxUrls),
+        maxCalls: Math.min(a.maxCalls ?? limits.maxCalls, b.maxCalls ?? limits.maxCalls),
+        timeoutMs: Math.min(a.timeoutMs ?? limits.timeoutMs, b.timeoutMs ?? limits.timeoutMs),
+        maxTextBytes: Math.min(a.maxTextBytes ?? limits.maxTextBytes, b.maxTextBytes ?? limits.maxTextBytes),
+        ...(domains === undefined ? {} : { domains }),
+    };
+}
+function intersectDomains(a, b) {
+    return a === undefined
+        ? b === undefined
+            ? undefined
+            : [...b]
+        : b === undefined
+            ? [...a]
+            : a.filter((host) => b.includes(host));
+}
+/** One governed path for generated MCP tools, assistant calls and composed operations. */
+export async function executeWebExtract(declaration, input, deps) {
+    if (!deps.enabled)
+        throw new CapabilityError('capability_unavailable');
+    if (!deps.authorized)
+        throw new CapabilityError('capability_policy_denied');
+    if (deps.signal?.aborted)
+        throw new CapabilityError('capability_cancelled');
+    const request = webExtractRequestSchema.safeParse(input);
+    if (!request.success)
+        throw new CapabilityError('capability_source_rejected');
+    const policy = effectiveWebPolicy(declaration.policy, deps.operatorPolicy);
+    const domains = intersectDomains(policy.domains, request.data.domains);
+    if (request.data.urls.length > (policy.maxUrls ?? limits.maxUrls))
+        throw new CapabilityError('capability_policy_denied');
+    const urls = request.data.urls.map((url) => publicPageUrl(url, domains).href);
+    if (new Set(urls).size !== urls.length)
+        throw new CapabilityError('capability_source_rejected');
+    const deadline = deps.budget.reserve(urls, policy);
+    const signal = deps.signal === undefined ? deadline : AbortSignal.any([deadline, deps.signal]);
+    let admitted;
+    try {
+        admitted = await withinSignal(signal, deps.admit);
+    }
+    catch {
+        if (signal.aborted)
+            throw new CapabilityError(deps.signal?.aborted ? 'capability_cancelled' : 'capability_budget_exhausted');
+        throw new CapabilityError('capability_unavailable');
+    }
+    if (!admitted)
+        throw new CapabilityError('capability_budget_exhausted');
+    const parts = await Promise.all(urls.map(async (url, requestIndex) => {
+        try {
+            return await deps.budget.withSlot(signal, async () => {
+                const raw = await withinSignal(signal, () => deps.reader.read({
+                    url,
+                    signal,
+                    maxBytes: limits.maxPageBytes,
+                    beforeRequest: () => {
+                        signal.throwIfAborted();
+                        deps.budget.beforeRequest();
+                    },
+                    ...(domains === undefined ? {} : { domains }),
+                }));
+                const parsed = pageSchema.safeParse(raw);
+                if (!parsed.success)
+                    throw new CapabilityError('capability_result_invalid');
+                const page = parsed.data;
+                const sourceUrl = publicPageUrl(page.url, domains);
+                for (const link of page.links) {
+                    if (publicPageUrl(link.url, domains).origin !== sourceUrl.origin)
+                        throw new CapabilityError('capability_result_invalid');
+                }
+                const content = deps.budget.text(page.text, policy.maxTextBytes ?? limits.maxTextBytes);
+                const ref = `source_${requestIndex + 1}`;
+                return {
+                    item: {
+                        requestIndex,
+                        sourceRef: ref,
+                        content: { format: 'text', text: content.text },
+                        links: page.links,
+                        truncated: content.truncated,
+                    },
+                    source: {
+                        ref,
+                        url: sourceUrl.href,
+                        retrievedAt: page.retrievedAt,
+                        ...(page.title === '' ? {} : { title: page.title }),
+                    },
+                    warnings: content.truncated
+                        ? [{ requestIndex, code: 'content_truncated' }]
+                        : [],
+                };
+            });
+        }
+        catch (error) {
+            const code = error instanceof CapabilityError ? error.code : 'capability_provider_failed';
+            return { warnings: [{ requestIndex, code }] };
+        }
+    }));
+    if (signal.aborted)
+        throw new CapabilityError(deps.signal?.aborted ? 'capability_cancelled' : 'capability_budget_exhausted');
+    const items = parts.flatMap((part) => ('item' in part ? [part.item] : []));
+    const sources = parts.flatMap((part) => ('source' in part ? [part.source] : []));
+    const warnings = parts.flatMap((part) => part.warnings);
+    if (items.length === 0)
+        throw new CapabilityError('capability_provider_failed');
+    const result = webExtractResultSchema.safeParse({
+        status: warnings.length === 0 ? 'complete' : 'partial',
+        items,
+        sources,
+        warnings,
+    });
+    if (!result.success)
+        throw new CapabilityError('capability_result_invalid');
+    return result.data;
+}
+/** A late/misbehaving adapter cannot hold the caller past cancellation or the trusted deadline. */
+function withinSignal(signal, run) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(signal.reason);
+        signal.addEventListener('abort', abort, { once: true });
+        Promise.resolve()
+            .then(() => {
+            signal.throwIfAborted();
+            return run();
+        })
+            .then(resolve, reject)
+            .finally(() => signal.removeEventListener('abort', abort));
+    });
+}
+//# sourceMappingURL=executor.js.map

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

@@ -0,0 +1,15 @@
+export declare const WEB_EXTRACT_LIMITS: {
+    readonly maxUrls: 5;
+    readonly maxCalls: 3;
+    readonly maxConcurrency: 2;
+    readonly maxPageBytes: number;
+    readonly maxTextBytes: number;
+    readonly maxTurnTextBytes: number;
+    readonly maxRobotsBytes: number;
+    readonly maxUrlCharacters: 2048;
+    readonly maxLinks: 30;
+    readonly maxRedirects: 2;
+    readonly maxHttpAttempts: 20;
+    readonly timeoutMs: 30000;
+};
+//# sourceMappingURL=limits.d.ts.map

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

@@ -0,0 +1,15 @@
+export const WEB_EXTRACT_LIMITS = {
+    maxUrls: 5,
+    maxCalls: 3,
+    maxConcurrency: 2,
+    maxPageBytes: 1024 * 1024,
+    maxTextBytes: 32 * 1024,
+    maxTurnTextBytes: 128 * 1024,
+    maxRobotsBytes: 512 * 1024,
+    maxUrlCharacters: 2048,
+    maxLinks: 30,
+    maxRedirects: 2,
+    maxHttpAttempts: 20,
+    timeoutMs: 30_000,
+};
+//# sourceMappingURL=limits.js.map

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

@@ -0,0 +1,159 @@
+import { z } from 'zod';
+export declare const capabilityScopeSchema: z.ZodObject<{
+    org: z.ZodString;
+    app: z.ZodString;
+    env: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type CapabilityScope = z.infer<typeof capabilityScopeSchema>;
+export declare const operatorCapabilityPolicySchema: z.ZodObject<{
+    maxUrls: z.ZodOptional<z.ZodNumber>;
+    maxCalls: z.ZodOptional<z.ZodNumber>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    maxTextBytes: z.ZodOptional<z.ZodNumber>;
+    domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    enabled: z.ZodBoolean;
+    dailyCalls: z.ZodNumber;
+}, z.core.$strict>;
+export type OperatorCapabilityPolicy = z.infer<typeof operatorCapabilityPolicySchema>;
+export declare const capabilityPolicyUpdateSchema: z.ZodObject<{
+    expectedRevision: z.ZodNumber;
+    mutationId: z.ZodString;
+    policy: z.ZodObject<{
+        maxUrls: z.ZodOptional<z.ZodNumber>;
+        maxCalls: z.ZodOptional<z.ZodNumber>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxTextBytes: z.ZodOptional<z.ZodNumber>;
+        domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        enabled: z.ZodBoolean;
+        dailyCalls: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CapabilityPolicyUpdate = z.infer<typeof capabilityPolicyUpdateSchema> & {
+    readonly actor: string;
+};
+export declare const capabilityPolicyRecordSchema: z.ZodObject<{
+    revision: z.ZodNumber;
+    policy: z.ZodObject<{
+        maxUrls: z.ZodOptional<z.ZodNumber>;
+        maxCalls: z.ZodOptional<z.ZodNumber>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxTextBytes: z.ZodOptional<z.ZodNumber>;
+        domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        enabled: z.ZodBoolean;
+        dailyCalls: z.ZodNumber;
+    }, z.core.$strict>;
+    actor: z.ZodString;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type CapabilityPolicyRecord = z.infer<typeof capabilityPolicyRecordSchema>;
+export declare const capabilityInspectionSchema: z.ZodObject<{
+    name: z.ZodString;
+    class: z.ZodLiteral<"web.extract.v1">;
+    title: z.ZodString;
+    serviceKey: z.ZodString;
+    available: z.ZodBoolean;
+    profile: z.ZodEnum<{
+        "managed-learning-cohort": "managed-learning-cohort";
+        "local-first-party": "local-first-party";
+    }>;
+    revision: z.ZodNumber;
+    developerPolicy: z.ZodObject<{
+        maxUrls: z.ZodOptional<z.ZodNumber>;
+        maxCalls: z.ZodOptional<z.ZodNumber>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxTextBytes: z.ZodOptional<z.ZodNumber>;
+        domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    operatorPolicy: z.ZodObject<{
+        maxUrls: z.ZodOptional<z.ZodNumber>;
+        maxCalls: z.ZodOptional<z.ZodNumber>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxTextBytes: z.ZodOptional<z.ZodNumber>;
+        domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        enabled: z.ZodBoolean;
+        dailyCalls: z.ZodNumber;
+    }, z.core.$strict>;
+    effectivePolicy: z.ZodObject<{
+        maxUrls: z.ZodOptional<z.ZodNumber>;
+        maxCalls: z.ZodOptional<z.ZodNumber>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxTextBytes: z.ZodOptional<z.ZodNumber>;
+        domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    actor: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>;
+export declare const capabilityListResponseSchema: z.ZodObject<{
+    deploymentId: z.ZodString;
+    capabilities: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        class: z.ZodLiteral<"web.extract.v1">;
+        title: z.ZodString;
+        serviceKey: z.ZodString;
+        available: z.ZodBoolean;
+        profile: z.ZodEnum<{
+            "managed-learning-cohort": "managed-learning-cohort";
+            "local-first-party": "local-first-party";
+        }>;
+        revision: z.ZodNumber;
+        developerPolicy: z.ZodObject<{
+            maxUrls: z.ZodOptional<z.ZodNumber>;
+            maxCalls: z.ZodOptional<z.ZodNumber>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            maxTextBytes: z.ZodOptional<z.ZodNumber>;
+            domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        operatorPolicy: z.ZodObject<{
+            maxUrls: z.ZodOptional<z.ZodNumber>;
+            maxCalls: z.ZodOptional<z.ZodNumber>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            maxTextBytes: z.ZodOptional<z.ZodNumber>;
+            domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            enabled: z.ZodBoolean;
+            dailyCalls: z.ZodNumber;
+        }, z.core.$strict>;
+        effectivePolicy: z.ZodObject<{
+            maxUrls: z.ZodOptional<z.ZodNumber>;
+            maxCalls: z.ZodOptional<z.ZodNumber>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            maxTextBytes: z.ZodOptional<z.ZodNumber>;
+            domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        actor: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CapabilityListResponse = z.infer<typeof capabilityListResponseSchema>;
+export declare const capabilityTestRequestSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        fixture: "fixture";
+        live: "live";
+    }>;
+    request: z.ZodObject<{
+        urls: z.ZodArray<z.ZodString>;
+        domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const capabilityTestResponseSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        fixture: "fixture";
+        live: "live";
+    }>;
+    status: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+    }>;
+    pages: z.ZodNumber;
+    sources: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        url: z.ZodString;
+        retrievedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        requestIndex: z.ZodNumber;
+        code: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CapabilityTestResponse = z.infer<typeof capabilityTestResponseSchema>;
+//# sourceMappingURL=operator-contracts.d.ts.map

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

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { capabilityNameSchema, webExtractRequestSchema, webPolicySchema } from './contracts.js';
+const scopePart = z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[a-zA-Z0-9_-]+$/);
+export const capabilityScopeSchema = z
+    .object({ org: scopePart, app: scopePart, env: scopePart, name: capabilityNameSchema })
+    .strict();
+export const operatorCapabilityPolicySchema = webPolicySchema.extend({
+    enabled: z.boolean(),
+    dailyCalls: z.number().int().min(0).max(1000),
+});
+export const capabilityPolicyUpdateSchema = z
+    .object({
+    expectedRevision: z
+        .number()
+        .int()
+        .min(0)
+        .max(Number.MAX_SAFE_INTEGER - 1),
+    mutationId: z
+        .string()
+        .min(1)
+        .max(128)
+        .regex(/^[a-zA-Z0-9_-]+$/),
+    policy: operatorCapabilityPolicySchema,
+})
+    .strict();
+export const capabilityPolicyRecordSchema = z
+    .object({
+    revision: z.number().int().positive(),
+    policy: operatorCapabilityPolicySchema,
+    actor: z.string().min(1).max(512),
+    updatedAt: z.iso.datetime(),
+})
+    .strict();
+export const capabilityInspectionSchema = z
+    .object({
+    name: capabilityNameSchema,
+    class: z.literal('web.extract.v1'),
+    title: z.string(),
+    serviceKey: z.string(),
+    available: z.boolean(),
+    profile: z.enum(['managed-learning-cohort', 'local-first-party']),
+    revision: z.number().int().nonnegative(),
+    developerPolicy: webPolicySchema,
+    operatorPolicy: operatorCapabilityPolicySchema,
+    effectivePolicy: webPolicySchema.extend({ domains: z.array(z.string()).max(32).optional() }),
+    actor: z.string().optional(),
+    updatedAt: z.iso.datetime().optional(),
+})
+    .strict();
+export const capabilityListResponseSchema = z
+    .object({ deploymentId: z.string(), capabilities: z.array(capabilityInspectionSchema) })
+    .strict();
+export const capabilityTestRequestSchema = z
+    .object({ mode: z.enum(['fixture', 'live']), request: webExtractRequestSchema })
+    .strict();
+export const capabilityTestResponseSchema = z
+    .object({
+    mode: z.enum(['fixture', 'live']),
+    status: z.enum(['complete', 'partial']),
+    pages: z.number().int().nonnegative(),
+    sources: z.array(z.object({ ref: z.string(), url: z.string().url(), retrievedAt: z.iso.datetime() }).strict()),
+    warnings: z.array(z.object({ requestIndex: z.number().int(), code: z.string() }).strict()),
+})
+    .strict();
+//# sourceMappingURL=operator-contracts.js.map

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

@@ -0,0 +1,5 @@
+import type { ModuleRoute } from '@noodle-borg/module';
+import type { CapabilityService } from './service.js';
+/** Operator diagnostic commands share policy/admission; they never expose source bodies. */
+export declare function capabilityOperatorRoute(service: CapabilityService): ModuleRoute;
+//# sourceMappingURL=operator-route.d.ts.map