@noodleseed/one 0.168.0 → 0.170.0

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

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

@@ -0,0 +1,160 @@
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { CapabilityBudget } from './budget.js';
+import { webCapabilityBaseSchema } from './contracts.js';
+import { CapabilityError } from './errors.js';
+import { capabilityInspectionSchema, capabilityListResponseSchema, capabilityPolicyUpdateSchema, capabilityScopeSchema, capabilityTestRequestSchema, capabilityTestResponseSchema, } from './operator-contracts.js';
+import { CapabilityPolicyConflict } from './policy-store.js';
+const path = /^\/v1\/orgs\/([^/]+)\/apps\/([^/]+)\/envs\/([^/]+)\/capabilities(?:\/([^/]+)(?:\/(policy|test))?)?$/;
+/** Operator diagnostic commands share policy/admission; they never expose source bodies. */
+export function capabilityOperatorRoute(service) {
+    return {
+        id: 'managed-capabilities',
+        match: (_method, url) => path.test(url.pathname),
+        handle: async (req, res, ctx) => {
+            try {
+                const match = path.exec(new URL(req.url ?? '/', 'http://service.invalid').pathname);
+                if (!match)
+                    return send(res, 404, { error: 'not_found' });
+                const scope = capabilityScopeSchema.parse({
+                    org: match[1],
+                    app: match[2],
+                    env: match[3],
+                    name: match[4] ?? 'list',
+                });
+                const { name, ...tenant } = scope;
+                const action = match[5];
+                const reading = req.method === 'GET' && action === undefined;
+                if (!reading &&
+                    !(req.method === 'PUT' && action === 'policy') &&
+                    !(req.method === 'POST' && action === 'test')) {
+                    return send(res, 405, { error: 'method_not_allowed' });
+                }
+                const auth = await ctx.tenantControl?.authorize(req, {
+                    org: scope.org,
+                    permission: reading ? 'org:member' : 'org:manage',
+                });
+                if (auth?.ok !== true || auth.identity === undefined)
+                    return send(res, auth?.ok === false ? auth.status : 401, {
+                        error: 'capability_forbidden',
+                    });
+                const target = await ctx.capabilityDeployments?.get(req, tenant);
+                if (target === undefined)
+                    return send(res, 404, { error: 'deployment_not_found' });
+                // The service has already compiled and authorized these declarations. Diagnostics need only intent.
+                const declarations = target.declarations.map((raw) => webCapabilityBaseSchema.strip().parse(raw));
+                if (match[4] === undefined) {
+                    return send(res, 200, capabilityListResponseSchema.parse({
+                        deploymentId: target.deploymentId,
+                        capabilities: await Promise.all(declarations.map((d) => service.inspect(tenant, d))),
+                    }));
+                }
+                const declaration = declarations.find((d) => d.name === name);
+                if (declaration === undefined)
+                    return send(res, 404, { error: 'capability_not_found' });
+                if (reading)
+                    return send(res, 200, capabilityInspectionSchema.parse(await service.inspect(tenant, declaration)));
+                const body = await jsonBody(req);
+                if (action === 'policy') {
+                    const update = capabilityPolicyUpdateSchema.parse(body);
+                    const record = await service.configure(tenant, declaration, {
+                        ...update,
+                        actor: auth.identity.subject,
+                    });
+                    await ctx.audit?.emit({
+                        eventType: 'capability.policy.updated',
+                        ...tenant,
+                        actorSubject: auth.identity.subject,
+                        deploymentId: target.deploymentId,
+                        details: { name, revision: record.revision, enabled: record.policy.enabled },
+                    });
+                    return send(res, 200, capabilityInspectionSchema.parse(await service.inspect(tenant, declaration)));
+                }
+                const test = capabilityTestRequestSchema.parse(body);
+                const cancelled = new AbortController();
+                const abort = () => cancelled.abort();
+                req.once('aborted', abort);
+                res.once('close', abort);
+                try {
+                    const result = await service.execute(declaration, test.request, {
+                        tenant,
+                        deploymentId: target.deploymentId,
+                        executionId: randomUUID(),
+                        subject: auth.identity.subject,
+                        anonymous: false,
+                        authorized: true,
+                        budget: new CapabilityBudget(),
+                        signal: cancelled.signal,
+                    }, test.mode === 'fixture'
+                        ? {
+                            read: async ({ url }) => ({
+                                url,
+                                title: 'Diagnostic fixture',
+                                text: 'Synthetic diagnostic evidence. No website was fetched.',
+                                links: [],
+                                retrievedAt: new Date().toISOString(),
+                            }),
+                        }
+                        : undefined);
+                    return send(res, 200, capabilityTestResponseSchema.parse({
+                        mode: test.mode,
+                        status: result.status,
+                        pages: result.items.length,
+                        sources: result.sources.map(({ ref, url, retrievedAt }) => ({
+                            ref,
+                            url,
+                            retrievedAt,
+                        })),
+                        warnings: result.warnings,
+                    }));
+                }
+                finally {
+                    req.off('aborted', abort);
+                    res.off('close', abort);
+                }
+            }
+            catch (error) {
+                const status = error instanceof CapabilityPolicyConflict
+                    ? 409
+                    : error instanceof z.ZodError
+                        ? 400
+                        : error instanceof CapabilityError
+                            ? 422
+                            : 503;
+                send(res, status, {
+                    error: error instanceof CapabilityPolicyConflict
+                        ? 'capability_policy_conflict'
+                        : error instanceof z.ZodError
+                            ? 'invalid_request'
+                            : error instanceof CapabilityError
+                                ? error.code
+                                : 'capability_unavailable',
+                });
+            }
+        },
+    };
+}
+async function jsonBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const raw of req) {
+        const chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+        size += chunk.length;
+        if (size > 16_384)
+            throw new CapabilityError('capability_source_rejected');
+        chunks.push(chunk);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new CapabilityError('capability_source_rejected');
+    }
+}
+function send(res, status, value) {
+    if (res.destroyed || res.writableEnded)
+        return;
+    res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+    res.end(JSON.stringify(value));
+}
+//# sourceMappingURL=operator-route.js.map

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

@@ -0,0 +1,34 @@
+import { type CapabilityPolicyRecord, type CapabilityPolicyUpdate, type CapabilityScope } from './operator-contracts.js';
+export * from './operator-contracts.js';
+export interface CapabilityPolicyStore {
+    readonly durable: boolean;
+    get(scope: CapabilityScope): Promise<CapabilityPolicyRecord | undefined>;
+    replace(scope: CapabilityScope, update: CapabilityPolicyUpdate): Promise<CapabilityPolicyRecord>;
+}
+export declare class CapabilityPolicyConflict extends Error {
+    constructor();
+}
+export declare function capabilityScopeKey(scope: CapabilityScope): string;
+export declare function checkedPolicyUpdate(update: CapabilityPolicyUpdate): {
+    actor: string;
+    fingerprint: string;
+    expectedRevision: number;
+    mutationId: string;
+    policy: {
+        enabled: boolean;
+        dailyCalls: number;
+        maxUrls?: number | undefined;
+        maxCalls?: number | undefined;
+        timeoutMs?: number | undefined;
+        maxTextBytes?: number | undefined;
+        domains?: string[] | undefined;
+    };
+};
+/** Development/test only. Hosted composition rejects a non-durable policy or counter store. */
+export declare class InMemoryCapabilityPolicyStore implements CapabilityPolicyStore {
+    #private;
+    readonly durable = false;
+    get(scope: CapabilityScope): Promise<CapabilityPolicyRecord | undefined>;
+    replace(scope: CapabilityScope, input: CapabilityPolicyUpdate): Promise<CapabilityPolicyRecord>;
+}
+//# sourceMappingURL=policy-store.d.ts.map

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

@@ -0,0 +1,61 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { capabilityPolicyUpdateSchema, capabilityScopeSchema, } from './operator-contracts.js';
+export * from './operator-contracts.js';
+export class CapabilityPolicyConflict extends Error {
+    constructor() {
+        super('capability_policy_conflict');
+    }
+}
+export function capabilityScopeKey(scope) {
+    const parsed = capabilityScopeSchema.parse(scope);
+    return JSON.stringify([
+        parsed.org,
+        parsed.app,
+        parsed.env,
+        `capability.web-extract.${parsed.name}.provider`,
+    ]);
+}
+export function checkedPolicyUpdate(update) {
+    const { actor, ...body } = update;
+    const parsed = capabilityPolicyUpdateSchema.parse(body);
+    z.string().min(1).max(512).parse(actor);
+    const fingerprint = createHash('sha256')
+        .update(JSON.stringify({ ...parsed, actor }))
+        .digest('hex');
+    return { ...parsed, actor, fingerprint };
+}
+/** Development/test only. Hosted composition rejects a non-durable policy or counter store. */
+export class InMemoryCapabilityPolicyStore {
+    durable = false;
+    #records = new Map();
+    async get(scope) {
+        const entry = this.#records.get(capabilityScopeKey(scope));
+        return entry === undefined ? undefined : structuredClone(entry.record);
+    }
+    async replace(scope, input) {
+        const key = capabilityScopeKey(scope);
+        const update = checkedPolicyUpdate(input);
+        const prior = this.#records.get(key);
+        if (prior?.mutationId === update.mutationId) {
+            if (prior.fingerprint !== update.fingerprint)
+                throw new CapabilityPolicyConflict();
+            return structuredClone(prior.record);
+        }
+        if ((prior?.record.revision ?? 0) !== update.expectedRevision)
+            throw new CapabilityPolicyConflict();
+        const record = {
+            revision: update.expectedRevision + 1,
+            policy: update.policy,
+            actor: update.actor,
+            updatedAt: new Date().toISOString(),
+        };
+        this.#records.set(key, {
+            record,
+            mutationId: update.mutationId,
+            fingerprint: update.fingerprint,
+        });
+        return structuredClone(record);
+    }
+}
+//# sourceMappingURL=policy-store.js.map

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

@@ -0,0 +1,10 @@
+export { CapabilityBudget, type CapabilityBudgetSnapshot } from './budget.js';
+export * from './contracts.js';
+export { CAPABILITY_ERROR_CODES, CapabilityError, type CapabilityErrorCode } from './errors.js';
+export { effectiveWebPolicy, executeWebExtract, type PublicPageReaderPort, type WebExtractDeps, } from './executor.js';
+export { WEB_EXTRACT_LIMITS } from './limits.js';
+export { capabilityOperatorRoute } from './operator-route.js';
+export * from './policy-store.js';
+export { type CapabilityInvocation, CapabilityService, type CapabilityServiceOptions, } from './service.js';
+export { publicPageUrl } from './urls.js';
+//# sourceMappingURL=portable.d.ts.map

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

@@ -0,0 +1,10 @@
+export { CapabilityBudget } from './budget.js';
+export * from './contracts.js';
+export { CAPABILITY_ERROR_CODES, CapabilityError } from './errors.js';
+export { effectiveWebPolicy, executeWebExtract, } from './executor.js';
+export { WEB_EXTRACT_LIMITS } from './limits.js';
+export { capabilityOperatorRoute } from './operator-route.js';
+export * from './policy-store.js';
+export { CapabilityService, } from './service.js';
+export { publicPageUrl } from './urls.js';
+//# sourceMappingURL=portable.js.map

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

@@ -0,0 +1,83 @@
+import type { AtomicDailyCounterStore } from '@noodle-borg/admission-limits/portable';
+import type { CapabilityBudget } from './budget.js';
+import type { WebCapability, WebExtractResult } from './contracts.js';
+import { type PublicPageReaderPort } from './executor.js';
+import { type CapabilityPolicyStore, type CapabilityPolicyUpdate, type CapabilityScope } from './policy-store.js';
+type Tenant = Pick<CapabilityScope, 'org' | 'app' | 'env'>;
+export interface CapabilityServiceOptions {
+    readonly profile: 'development' | 'hosted';
+    readonly policies: CapabilityPolicyStore;
+    readonly counters: AtomicDailyCounterStore;
+    readonly reader: PublicPageReaderPort;
+    /** Exact hosted cohort targets. Empty or absent disables all hosted extraction. */
+    readonly enabledScopes?: readonly Tenant[];
+    readonly audit?: (fields: Readonly<Record<string, string | number | boolean>> & Tenant) => void | Promise<void>;
+}
+export interface CapabilityInvocation {
+    readonly tenant: Tenant;
+    readonly deploymentId: string;
+    readonly executionId: string;
+    readonly subject?: string;
+    readonly anonymous: boolean;
+    readonly network?: string;
+    readonly authorized: boolean;
+    readonly budget: CapabilityBudget;
+    readonly signal?: AbortSignal;
+}
+/** Policy/admission authority shared by normal tools and operator diagnostics. Never resolves a model. */
+export declare class CapabilityService {
+    readonly options: CapabilityServiceOptions;
+    constructor(options: CapabilityServiceOptions);
+    enabled(tenant: Tenant): boolean;
+    inspect(tenant: Tenant, declaration: WebCapability): Promise<{
+        actor?: string;
+        updatedAt?: string;
+        name: string;
+        class: "web.extract.v1";
+        title: string;
+        serviceKey: string;
+        available: boolean;
+        profile: string;
+        revision: number;
+        developerPolicy: {
+            maxUrls?: number | undefined;
+            maxCalls?: number | undefined;
+            timeoutMs?: number | undefined;
+            maxTextBytes?: number | undefined;
+            domains?: string[] | undefined;
+        };
+        operatorPolicy: {
+            enabled: boolean;
+            dailyCalls: number;
+            maxUrls?: number | undefined;
+            maxCalls?: number | undefined;
+            timeoutMs?: number | undefined;
+            maxTextBytes?: number | undefined;
+            domains?: string[] | undefined;
+        };
+        effectivePolicy: {
+            maxUrls?: number | undefined;
+            maxCalls?: number | undefined;
+            timeoutMs?: number | undefined;
+            maxTextBytes?: number | undefined;
+            domains?: string[] | undefined;
+        };
+    }>;
+    configure(tenant: Tenant, declaration: WebCapability, update: CapabilityPolicyUpdate): Promise<{
+        revision: number;
+        policy: {
+            enabled: boolean;
+            dailyCalls: number;
+            maxUrls?: number | undefined;
+            maxCalls?: number | undefined;
+            timeoutMs?: number | undefined;
+            maxTextBytes?: number | undefined;
+            domains?: string[] | undefined;
+        };
+        actor: string;
+        updatedAt: string;
+    }>;
+    execute(declaration: WebCapability, input: unknown, context: CapabilityInvocation, reader?: PublicPageReaderPort): Promise<WebExtractResult>;
+}
+export {};
+//# sourceMappingURL=service.d.ts.map