@crowdedkingdoms/crowdyjs 11.1.0 → 12.1.0

package/dist/crowdy-agent/index.d.ts

@@ -0,0 +1,16 @@
+import { CrowdyAgentToolRegistry } from './registry.js';
+/** Frozen minimum registry for `crowdy.agent-tools/1`. */
+export declare const CROWDY_AGENT_TOOL_REGISTRY_V1: CrowdyAgentToolRegistry;
+export declare const CROWDY_AGENT_REGISTRY_V1: CrowdyAgentToolRegistry;
+export { CrowdyAgentBrowserToolDispatcher, type CrowdyAgentBrowserDispatcherOptionsV1, type CrowdyAgentBrowserToolContextV1, type CrowdyAgentBrowserToolHandlerV1, type CrowdyAgentBrowserToolHandlersV1, } from './browser-dispatcher.js';
+export { CrowdyStudioAgentController, CrowdyStudioAgentController as CrowdyStudioAgentClient, type CrowdyStudioAgentConnectionState, type CrowdyStudioAgentControllerOptionsV1, type CrowdyStudioAgentStateV1, } from './controller.js';
+export { CrowdyAgentGraphQLTransport, type CrowdyAgentGraphQLSubscriptionClient, type CrowdyAgentGraphQLTransportOptions, } from './graphql-transport.js';
+export { CROWDY_AGENT_ERROR_CODES, CrowdyAgentError, CrowdyAgentOutcomeUnknownError, toAgentError, type AgentErrorV1, type CrowdyAgentErrorCode, } from './errors.js';
+export { FORBIDDEN_AGENT_TOOL_SURFACES, CrowdyAgentToolRegistry, isDescriptorDigest, type CrowdyAgentRegistryFilter, } from './registry.js';
+export { FORBIDDEN_AGENT_AUTHORITY_FIELDS, assertBoundedJsonSchema, canonicalJson, deepFreeze, digestCanonicalJson, isDecimalString, sha256Digest, validateJsonSchemaValue, type JsonPrimitive, type JsonSchema, type JsonSchemaArray, type JsonSchemaBoolean, type JsonSchemaNull, type JsonSchemaNumber, type JsonSchemaObject, type JsonSchemaString, type JsonSchemaUnion, type JsonSchemaValidationOptions, } from './schema.js';
+export { CROWDY_AGENT_TOOL_DESCRIPTORS_V1 } from './tool-descriptors.js';
+export { createCrowdyStudioAgentTools, crowdyStudioAgentProjectTargets, type CrowdyStudioAgentToolsOptionsV1, } from './studio-tools.js';
+export { CROWDY_AGENT_GRAPHQL_OPERATIONS_V1, type CrowdyAgentAttachResultV1, type CrowdyAgentConnectionV1, type CrowdyAgentCreateSessionInputV1, type CrowdyAgentEdgeV1, type CrowdyAgentEventSubscriptionHandlersV1, type CrowdyAgentEventSubscriptionV1, type CrowdyAgentHistoryPageV1, type CrowdyAgentPageInfoV1, type CrowdyStudioAgentTransportV1, } from './transport.js';
+export { CROWDY_AGENT_EVENT_TYPES } from './types.js';
+export type { CrowdyAgentApprovalPolicy, CrowdyAgentApprovalStatus, CrowdyAgentApprovalV1, CrowdyAgentBudgetDimensionV1, CrowdyAgentBudgetV1, CrowdyAgentHeartbeatV1, CrowdyAgentCheckpointFileV1, CrowdyAgentCheckpointV1, CrowdyAgentEventPayloadMap, CrowdyAgentEventType, CrowdyAgentEventV1, CrowdyAgentIdempotencyClass, CrowdyAgentLeaseStatus, CrowdyAgentLeaseV1, CrowdyAgentMessageV1, CrowdyAgentMode, CrowdyAgentPreemptionReason, CrowdyAgentRedactionAction, CrowdyAgentRedactionRuleV1, CrowdyAgentRegisteredToolV1, CrowdyAgentRunStatus, CrowdyAgentRunV1, CrowdyAgentScopeRequirementV1, CrowdyAgentSessionStatus, CrowdyAgentSessionV1, CrowdyAgentToolCallStatus, CrowdyAgentToolCallAckV1, CrowdyAgentToolDescriptorV1, CrowdyAgentToolExecutor, CrowdyAgentToolInvocationV1, CrowdyAgentToolResultStatus, CrowdyAgentToolResultV1, CrowdyAgentToolRisk, CrowdyAgentToolTimelineItemV1, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/crowdy-agent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/crowdy-agent/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAGxD,0DAA0D;AAC1D,eAAO,MAAM,6BAA6B,yBAEzC,CAAC;AACF,eAAO,MAAM,wBAAwB,yBAAgC,CAAC;AAEtE,OAAO,EACL,gCAAgC,EAChC,KAAK,qCAAqC,EAC1C,KAAK,+BAA+B,EACpC,KAAK,+BAA+B,EACpC,KAAK,gCAAgC,GACtC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,2BAA2B,EAC3B,2BAA2B,IAAI,uBAAuB,EACtD,KAAK,gCAAgC,EACrC,KAAK,oCAAoC,EACzC,KAAK,wBAAwB,GAC9B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,2BAA2B,EAC3B,KAAK,oCAAoC,EACzC,KAAK,kCAAkC,GACxC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,wBAAwB,EACxB,gBAAgB,EAChB,8BAA8B,EAC9B,YAAY,EACZ,KAAK,YAAY,EACjB,KAAK,oBAAoB,GAC1B,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,6BAA6B,EAC7B,uBAAuB,EACvB,kBAAkB,EAClB,KAAK,yBAAyB,GAC/B,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,gCAAgC,EAChC,uBAAuB,EACvB,aAAa,EACb,UAAU,EACV,mBAAmB,EACnB,eAAe,EACf,YAAY,EACZ,uBAAuB,EACvB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,2BAA2B,GACjC,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,EACL,4BAA4B,EAC5B,+BAA+B,EAC/B,KAAK,+BAA+B,GACrC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,kCAAkC,EAClC,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,EAC5B,KAAK,+BAA+B,EACpC,KAAK,iBAAiB,EACtB,KAAK,sCAAsC,EAC3C,KAAK,8BAA8B,EACnC,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,4BAA4B,GAClC,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACtD,YAAY,EACV,yBAAyB,EACzB,yBAAyB,EACzB,qBAAqB,EACrB,4BAA4B,EAC5B,mBAAmB,EACnB,sBAAsB,EACtB,2BAA2B,EAC3B,uBAAuB,EACvB,0BAA0B,EAC1B,oBAAoB,EACpB,kBAAkB,EAClB,2BAA2B,EAC3B,sBAAsB,EACtB,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,2BAA2B,EAC3B,0BAA0B,EAC1B,0BAA0B,EAC1B,2BAA2B,EAC3B,oBAAoB,EACpB,gBAAgB,EAChB,6BAA6B,EAC7B,wBAAwB,EACxB,oBAAoB,EACpB,yBAAyB,EACzB,wBAAwB,EACxB,2BAA2B,EAC3B,uBAAuB,EACvB,2BAA2B,EAC3B,2BAA2B,EAC3B,uBAAuB,EACvB,mBAAmB,EACnB,6BAA6B,GAC9B,MAAM,YAAY,CAAC"}

package/dist/crowdy-agent/index.js

@@ -0,0 +1,15 @@
+import { CrowdyAgentToolRegistry } from './registry.js';
+import { CROWDY_AGENT_TOOL_DESCRIPTORS_V1 } from './tool-descriptors.js';
+/** Frozen minimum registry for `crowdy.agent-tools/1`. */
+export const CROWDY_AGENT_TOOL_REGISTRY_V1 = new CrowdyAgentToolRegistry(CROWDY_AGENT_TOOL_DESCRIPTORS_V1);
+export const CROWDY_AGENT_REGISTRY_V1 = CROWDY_AGENT_TOOL_REGISTRY_V1;
+export { CrowdyAgentBrowserToolDispatcher, } from './browser-dispatcher.js';
+export { CrowdyStudioAgentController, CrowdyStudioAgentController as CrowdyStudioAgentClient, } from './controller.js';
+export { CrowdyAgentGraphQLTransport, } from './graphql-transport.js';
+export { CROWDY_AGENT_ERROR_CODES, CrowdyAgentError, CrowdyAgentOutcomeUnknownError, toAgentError, } from './errors.js';
+export { FORBIDDEN_AGENT_TOOL_SURFACES, CrowdyAgentToolRegistry, isDescriptorDigest, } from './registry.js';
+export { FORBIDDEN_AGENT_AUTHORITY_FIELDS, assertBoundedJsonSchema, canonicalJson, deepFreeze, digestCanonicalJson, isDecimalString, sha256Digest, validateJsonSchemaValue, } from './schema.js';
+export { CROWDY_AGENT_TOOL_DESCRIPTORS_V1 } from './tool-descriptors.js';
+export { createCrowdyStudioAgentTools, crowdyStudioAgentProjectTargets, } from './studio-tools.js';
+export { CROWDY_AGENT_GRAPHQL_OPERATIONS_V1, } from './transport.js';
+export { CROWDY_AGENT_EVENT_TYPES } from './types.js';

package/dist/crowdy-agent/registry.d.ts

@@ -0,0 +1,29 @@
+import type { CrowdyAgentMode, CrowdyAgentRegisteredToolV1, CrowdyAgentToolDescriptorV1, CrowdyAgentToolExecutor } from './types.js';
+/** Names whose presence would create ambient or arbitrary authority. */
+export declare const FORBIDDEN_AGENT_TOOL_SURFACES: readonly ["graphql", "fetch", "http", "url", "socket", "shell", "process", "filesystem", "dom", "keyboard", "mouse", "pointer", "host_call", "playercodebroker", "udp", "token", "cookie", "storage", "devtools", "database", "buddy"];
+export interface CrowdyAgentRegistryFilter {
+    readonly mode?: CrowdyAgentMode;
+    readonly executor?: CrowdyAgentToolExecutor;
+    /** Effective scopes filter descriptors; it never grants a scope. */
+    readonly availableScopes?: ReadonlySet<string>;
+}
+/** Immutable, exact-lookup registry pinned by a canonical digest. */
+export declare class CrowdyAgentToolRegistry {
+    readonly contractVersion: "crowdy.agent-tools/1";
+    readonly registryDigest: `sha256:${string}`;
+    private readonly entries;
+    private readonly byLogical;
+    private readonly byWire;
+    constructor(descriptors: readonly CrowdyAgentToolDescriptorV1[]);
+    list(filter?: CrowdyAgentRegistryFilter): readonly CrowdyAgentRegisteredToolV1[];
+    get(name: string, version: string): CrowdyAgentRegisteredToolV1 | undefined;
+    require(name: string, version: string): CrowdyAgentRegisteredToolV1;
+    /** Exact, case-sensitive provider wire-name reverse lookup. */
+    fromWireName(wireName: string): CrowdyAgentRegisteredToolV1;
+    validateInput(name: string, version: string, value: unknown): void;
+    validateOutput(name: string, version: string, value: unknown): void;
+    /** Resolve conditional requirements from already validated arguments. */
+    requiredScopes(name: string, version: string, argumentsValue: unknown): readonly string[];
+}
+export declare function isDescriptorDigest(value: string): value is `sha256:${string}`;
+//# sourceMappingURL=registry.d.ts.map

package/dist/crowdy-agent/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/crowdy-agent/registry.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,eAAe,EACf,2BAA2B,EAC3B,2BAA2B,EAC3B,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAUpB,wEAAwE;AACxE,eAAO,MAAM,6BAA6B,wOAsB/B,CAAC;AAEZ,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,QAAQ,CAAC,EAAE,uBAAuB,CAAC;IAC5C,oEAAoE;IACpE,QAAQ,CAAC,eAAe,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAChD;AAED,qEAAqE;AACrE,qBAAa,uBAAuB;IAClC,QAAQ,CAAC,eAAe,EAAG,sBAAsB,CAAU;IAC3D,QAAQ,CAAC,cAAc,EAAE,UAAU,MAAM,EAAE,CAAC;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyC;IACjE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkD;IAC5E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkD;gBAE7D,WAAW,EAAE,SAAS,2BAA2B,EAAE;IA8B/D,IAAI,CAAC,MAAM,GAAE,yBAA8B,GAAG,SAAS,2BAA2B,EAAE;IAepF,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,2BAA2B,GAAG,SAAS;IAI3E,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,2BAA2B;IAcnE,+DAA+D;IAC/D,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,2BAA2B;IAW3D,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAMlE,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAMnE,yEAAyE;IACzE,cAAc,CACZ,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,OAAO,GACtB,SAAS,MAAM,EAAE;CAyBrB;AAoMD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,UAAU,MAAM,EAAE,CAE7E"}

package/dist/crowdy-agent/registry.js

@@ -0,0 +1,281 @@
+import { CrowdyAgentError } from './errors.js';
+import { assertBoundedJsonSchema, canonicalJson, deepFreeze, digestCanonicalJson, validateJsonSchemaValue, } from './schema.js';
+const WIRE_NAME = /^[A-Za-z0-9_-]{1,64}$/u;
+const LOGICAL_NAME = /^(?:studio|project|workspace|library|template|diagnostics|runtime|game)\.[a-z0-9_]+(?:\.[a-z0-9_]+)*$/u;
+const SEMVER = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$/u;
+const DIGEST = /^sha256:[0-9a-f]{64}$/u;
+const REDACTION_PATH = /^\$(?:\.[A-Za-z_][A-Za-z0-9_]*|\[\*\])*$/u;
+/** Names whose presence would create ambient or arbitrary authority. */
+export const FORBIDDEN_AGENT_TOOL_SURFACES = Object.freeze([
+    'graphql',
+    'fetch',
+    'http',
+    'url',
+    'socket',
+    'shell',
+    'process',
+    'filesystem',
+    'dom',
+    'keyboard',
+    'mouse',
+    'pointer',
+    'host_call',
+    'playercodebroker',
+    'udp',
+    'token',
+    'cookie',
+    'storage',
+    'devtools',
+    'database',
+    'buddy',
+]);
+/** Immutable, exact-lookup registry pinned by a canonical digest. */
+export class CrowdyAgentToolRegistry {
+    constructor(descriptors) {
+        this.contractVersion = 'crowdy.agent-tools/1';
+        this.byLogical = new Map();
+        this.byWire = new Map();
+        if (descriptors.length === 0 || descriptors.length > 256) {
+            throw descriptorError('Registry must contain 1 to 256 tools');
+        }
+        const entries = descriptors
+            .map((descriptor) => registerDescriptor(descriptor))
+            .sort((left, right) => descriptorKey(left.descriptor).localeCompare(descriptorKey(right.descriptor)));
+        for (const entry of entries) {
+            const key = descriptorKey(entry.descriptor);
+            if (this.byLogical.has(key)) {
+                throw descriptorError(`Duplicate tool descriptor ${key}`);
+            }
+            if (this.byWire.has(entry.descriptor.wireName)) {
+                throw descriptorError(`Duplicate tool wire name ${entry.descriptor.wireName}`);
+            }
+            this.byLogical.set(key, entry);
+            this.byWire.set(entry.descriptor.wireName, entry);
+        }
+        this.entries = deepFreeze(entries);
+        this.registryDigest = digestCanonicalJson({
+            contract: this.contractVersion,
+            descriptors: entries.map(({ descriptor, descriptorDigest }) => ({
+                descriptor,
+                descriptorDigest,
+            })),
+        });
+    }
+    list(filter = {}) {
+        return this.entries.filter(({ descriptor }) => {
+            if (filter.mode && !descriptor.modes.includes(filter.mode))
+                return false;
+            if (filter.executor && descriptor.executor !== filter.executor)
+                return false;
+            if (filter.availableScopes) {
+                return descriptor.scopes
+                    .filter((requirement) => !requirement.when)
+                    .every((requirement) => filter.availableScopes?.has(requirement.scope));
+            }
+            return true;
+        });
+    }
+    get(name, version) {
+        return this.byLogical.get(`${name}@${version}`);
+    }
+    require(name, version) {
+        const entry = this.get(name, version);
+        if (!entry) {
+            const knownName = this.entries.some(({ descriptor }) => descriptor.name === name);
+            throw new CrowdyAgentError(knownName ? 'AGENT_TOOL_VERSION_UNSUPPORTED' : 'AGENT_TOOL_UNKNOWN', knownName
+                ? `Unsupported ${name} tool version ${version}`
+                : `Unknown agent tool ${name}`);
+        }
+        return entry;
+    }
+    /** Exact, case-sensitive provider wire-name reverse lookup. */
+    fromWireName(wireName) {
+        const entry = this.byWire.get(wireName);
+        if (!entry) {
+            throw new CrowdyAgentError('AGENT_TOOL_UNKNOWN', `Unknown agent tool wire name ${wireName}`);
+        }
+        return entry;
+    }
+    validateInput(name, version, value) {
+        validateJsonSchemaValue(this.require(name, version).descriptor.inputSchema, value, {
+            direction: 'INPUT',
+        });
+    }
+    validateOutput(name, version, value) {
+        validateJsonSchemaValue(this.require(name, version).descriptor.outputSchema, value, {
+            direction: 'OUTPUT',
+        });
+    }
+    /** Resolve conditional requirements from already validated arguments. */
+    requiredScopes(name, version, argumentsValue) {
+        const entry = this.require(name, version);
+        this.validateInput(name, version, argumentsValue);
+        return entry.descriptor.scopes
+            .filter((requirement) => {
+            if (!requirement.when)
+                return true;
+            const values = resolveArgumentPath(argumentsValue, requirement.when.argumentPath);
+            return requirement.when.operator === 'EQUALS'
+                ? values.some((value) => Object.is(value, requirement.when?.value))
+                : values.some((value) => Array.isArray(value) &&
+                    value.some((entry) => Object.is(entry, requirement.when?.value))) ||
+                    values.some((value) => Object.is(value, requirement.when?.value));
+        })
+            .map((requirement) => requirement.scope);
+    }
+}
+function registerDescriptor(source) {
+    validateDescriptor(source);
+    const descriptor = deepFreeze(JSON.parse(canonicalJson(source)));
+    const descriptorDigest = digestCanonicalJson(descriptor);
+    return deepFreeze({ descriptor, descriptorDigest });
+}
+function validateDescriptor(descriptor) {
+    if (descriptor.schemaVersion !== 'crowdy.agent-tool/1') {
+        throw descriptorError('Unsupported descriptor schemaVersion');
+    }
+    if (!LOGICAL_NAME.test(descriptor.name)) {
+        throw descriptorError(`Invalid logical tool name ${descriptor.name}`);
+    }
+    if (!WIRE_NAME.test(descriptor.wireName)) {
+        throw descriptorError(`Invalid tool wire name ${descriptor.wireName}`);
+    }
+    if (!SEMVER.test(descriptor.version)) {
+        throw descriptorError(`Invalid tool semantic version ${descriptor.version}`);
+    }
+    const major = descriptor.version.split('.')[0];
+    if (!descriptor.wireName.endsWith(`_v${major}`)) {
+        throw descriptorError(`Tool wire name ${descriptor.wireName} must include major suffix _v${major}`);
+    }
+    const authoritySurface = `${descriptor.name}.${descriptor.wireName}`.toLowerCase();
+    const forbidden = FORBIDDEN_AGENT_TOOL_SURFACES.find((part) => authoritySurface.includes(part));
+    if (forbidden) {
+        throw descriptorError(`Tool ${descriptor.name} exposes forbidden surface ${forbidden}`);
+    }
+    if (descriptor.summary.length < 8 || descriptor.summary.length > 240) {
+        throw descriptorError(`${descriptor.name} summary must be 8 to 240 characters`);
+    }
+    if (descriptor.modes.length === 0 ||
+        new Set(descriptor.modes).size !== descriptor.modes.length) {
+        throw descriptorError(`${descriptor.name} modes must be non-empty and unique`);
+    }
+    assertBoundedJsonSchema(descriptor.inputSchema, {
+        rejectAuthorityFields: true,
+    });
+    assertBoundedJsonSchema(descriptor.outputSchema, {
+        rejectAuthorityFields: false,
+    });
+    if (!Number.isSafeInteger(descriptor.timeoutMs) ||
+        descriptor.timeoutMs < 50 ||
+        descriptor.timeoutMs > 120000) {
+        throw descriptorError(`${descriptor.name} timeout must be 50..120000ms`);
+    }
+    if (!Number.isSafeInteger(descriptor.approval.maxTtlSeconds) ||
+        descriptor.approval.maxTtlSeconds < 0 ||
+        descriptor.approval.maxTtlSeconds > 300) {
+        throw descriptorError(`${descriptor.name} approval TTL must be 0..300 seconds`);
+    }
+    const approvalRequired = ['DESTRUCTIVE', 'TRUST_CONSENT', 'ECONOMIC', 'IRREVERSIBLE'].includes(descriptor.risk.class);
+    if (approvalRequired && descriptor.approval.policy !== 'REQUIRED') {
+        throw descriptorError(`${descriptor.name} risk requires exact human approval`);
+    }
+    if (descriptor.approval.policy === 'NONE' &&
+        (descriptor.approval.reasons.length !== 0 ||
+            descriptor.approval.maxTtlSeconds !== 0)) {
+        throw descriptorError(`${descriptor.name} no-approval metadata is inconsistent`);
+    }
+    if (descriptor.approval.policy !== 'NONE' &&
+        (descriptor.approval.reasons.length === 0 ||
+            descriptor.approval.maxTtlSeconds === 0)) {
+        throw descriptorError(`${descriptor.name} approval reasons and TTL are required`);
+    }
+    if (descriptor.executor === 'BROWSER' &&
+        !['PURE', 'TOOL_CALL_ONCE', 'NON_RETRYABLE'].includes(descriptor.idempotency.class)) {
+        throw descriptorError(`${descriptor.name} browser idempotency class is unsafe`);
+    }
+    validateKeyScope(descriptor);
+    validateRedaction(descriptor);
+    if (descriptor.scopes.length > 16) {
+        throw descriptorError(`${descriptor.name} has too many scope requirements`);
+    }
+    for (const requirement of descriptor.scopes) {
+        if (!/^[a-z][a-z0-9_.]{1,79}$/u.test(requirement.scope)) {
+            throw descriptorError(`${descriptor.name} has invalid scope ${requirement.scope}`);
+        }
+        if (requirement.when &&
+            (!REDACTION_PATH.test(requirement.when.argumentPath) ||
+                requirement.when.argumentPath.includes('[*]') === false &&
+                    requirement.when.operator === 'CONTAINS')) {
+            throw descriptorError(`${descriptor.name} has invalid conditional scope`);
+        }
+    }
+}
+function validateKeyScope(descriptor) {
+    const expected = descriptor.idempotency.class === 'PURE'
+        ? 'NONE'
+        : descriptor.idempotency.class === 'KEYED'
+            ? 'USER_TOOL_ARGUMENTS'
+            : 'TOOL_CALL';
+    if (descriptor.idempotency.keyScope !== expected) {
+        throw descriptorError(`${descriptor.name} idempotency key scope must be ${expected}`);
+    }
+}
+function validateRedaction(descriptor) {
+    if (!Number.isSafeInteger(descriptor.redaction.maxPersistedBytes) ||
+        descriptor.redaction.maxPersistedBytes < 0 ||
+        descriptor.redaction.maxPersistedBytes > 65536) {
+        throw descriptorError(`${descriptor.name} persisted byte bound is invalid`);
+    }
+    for (const rule of [
+        ...descriptor.redaction.input,
+        ...descriptor.redaction.output,
+    ]) {
+        if (!REDACTION_PATH.test(rule.path)) {
+            throw descriptorError(`${descriptor.name} has invalid redaction path ${rule.path}`);
+        }
+        if (rule.action === 'TRUNCATE' &&
+            (!Number.isSafeInteger(rule.maxBytes) ||
+                (rule.maxBytes ?? 0) < 1 ||
+                (rule.maxBytes ?? 0) > descriptor.redaction.maxPersistedBytes)) {
+            throw descriptorError(`${descriptor.name} truncate rule needs bounded maxBytes`);
+        }
+        if (rule.action !== 'TRUNCATE' && rule.maxBytes !== undefined) {
+            throw descriptorError(`${descriptor.name} maxBytes is only valid for TRUNCATE`);
+        }
+    }
+}
+function descriptorKey(descriptor) {
+    return `${descriptor.name}@${descriptor.version}`;
+}
+function descriptorError(message) {
+    return new CrowdyAgentError('AGENT_TOOL_DESCRIPTOR_INVALID', message);
+}
+function resolveArgumentPath(value, path) {
+    const segments = path
+        .slice(2)
+        .split('.')
+        .filter(Boolean);
+    let values = [value];
+    for (const segment of segments) {
+        const wildcard = segment.endsWith('[*]');
+        const key = wildcard ? segment.slice(0, -3) : segment;
+        const next = [];
+        for (const candidate of values) {
+            if (candidate === null ||
+                typeof candidate !== 'object' ||
+                Array.isArray(candidate)) {
+                continue;
+            }
+            const child = candidate[key];
+            if (wildcard && Array.isArray(child))
+                next.push(...child);
+            else if (!wildcard)
+                next.push(child);
+        }
+        values = next;
+    }
+    return values;
+}
+export function isDescriptorDigest(value) {
+    return DIGEST.test(value);
+}

package/dist/crowdy-agent/schema.d.ts

@@ -0,0 +1,72 @@
+export type JsonPrimitive = string | number | boolean | null;
+interface JsonSchemaBase {
+    readonly description?: string;
+    readonly enum?: readonly JsonPrimitive[];
+    readonly const?: JsonPrimitive;
+}
+export interface JsonSchemaString extends JsonSchemaBase {
+    readonly type: 'string';
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: string;
+    readonly format?: 'uuid' | 'date-time';
+}
+export interface JsonSchemaNumber extends JsonSchemaBase {
+    readonly type: 'number' | 'integer';
+    readonly minimum?: number;
+    readonly maximum?: number;
+}
+export interface JsonSchemaBoolean extends JsonSchemaBase {
+    readonly type: 'boolean';
+}
+export interface JsonSchemaNull extends JsonSchemaBase {
+    readonly type: 'null';
+}
+export interface JsonSchemaArray extends JsonSchemaBase {
+    readonly type: 'array';
+    readonly minItems?: number;
+    readonly maxItems: number;
+    readonly uniqueItems?: boolean;
+    readonly items: JsonSchema;
+}
+export interface JsonSchemaObject extends JsonSchemaBase {
+    readonly type: 'object';
+    readonly additionalProperties: false;
+    readonly required: readonly string[];
+    readonly properties: Readonly<Record<string, JsonSchema>>;
+    readonly minProperties?: number;
+    readonly maxProperties?: number;
+}
+export interface JsonSchemaUnion {
+    readonly oneOf: readonly JsonSchema[];
+    readonly description?: string;
+}
+export type JsonSchema = JsonSchemaString | JsonSchemaNumber | JsonSchemaBoolean | JsonSchemaNull | JsonSchemaArray | JsonSchemaObject | JsonSchemaUnion;
+export interface JsonSchemaValidationOptions {
+    /** Stable code distinguishes provider arguments from executor results. */
+    direction?: 'INPUT' | 'OUTPUT' | 'SCHEMA';
+    maxDepth?: number;
+    maxNodes?: number;
+    maxBytes?: number;
+}
+/**
+ * Fields the model must never supply. They are injected from authenticated
+ * session, dispatch, approval, and lease context.
+ */
+export declare const FORBIDDEN_AGENT_AUTHORITY_FIELDS: readonly ["userId", "ownerUserId", "appId", "projectId", "gridId", "sessionId", "runId", "toolCallId", "clientEpoch", "leaseId", "lease", "approval", "approvalGrant", "argumentHash", "descriptorDigest", "idempotencyKey", "deadline", "token", "authorization", "headers", "endpoint", "url", "permissions", "authority"];
+/** Validate a schema itself before it enters an immutable registry. */
+export declare function assertBoundedJsonSchema(schema: JsonSchemaObject, options?: {
+    rejectAuthorityFields?: boolean;
+}): void;
+/** Strictly validate JSON data and reject unknown fields or unbounded values. */
+export declare function validateJsonSchemaValue(schema: JsonSchema, value: unknown, options?: JsonSchemaValidationOptions): void;
+/** RFC-8785-compatible canonical JSON for the JSON subset used by contracts. */
+export declare function canonicalJson(value: unknown): string;
+/** Synchronous browser-safe SHA-256 used for descriptor and content digests. */
+export declare function sha256Digest(value: string | Uint8Array): `sha256:${string}`;
+export declare function digestCanonicalJson(value: unknown): `sha256:${string}`;
+/** Recursively freeze a JSON-like contract object. */
+export declare function deepFreeze<T>(value: T): Readonly<T>;
+export declare function isDecimalString(value: string): boolean;
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/dist/crowdy-agent/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/crowdy-agent/schema.ts"],"names":[],"mappings":"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"}