@ornexus/neocortex 4.60.18 → 4.60.20

package/packages/shared/dist/nx-invoke-signature.js

@@ -0,0 +1,233 @@
+/**
+ * P205.03 -- dependency-free nx-invoke-v1 HTTP Message Signatures profile.
+ *
+ * The module accepts exact caller-supplied bytes. It never serializes parsed
+ * JSON and never reads configuration, environment secrets, or storage keys.
+ */
+import { createHash, createHmac, hkdfSync, randomBytes, timingSafeEqual, } from 'node:crypto';
+export const NX_INVOKE_LABEL = 'nx-invoke';
+export const NX_INVOKE_TAG = 'neocortex-invoke-v1';
+export const NX_INVOKE_ALGORITHM = 'hmac-sha256';
+export const NX_INVOKE_CONTENT_TYPE = 'application/json';
+export const NX_INVOKE_SIGNATURE_TTL_SECONDS = 120;
+export const NX_INVOKE_MAX_LIFETIME_SECONDS = 300;
+export const NX_INVOKE_MAX_AGE_SECONDS = 300;
+export const NX_INVOKE_CLOCK_SKEW_SECONDS = 30;
+export const NX_INVOKE_COVERED_COMPONENTS = Object.freeze([
+    '@method',
+    '@path',
+    '@query',
+    'content-type',
+    'content-digest',
+    'x-client-version',
+]);
+const SIGNATURE_INPUT_PREFIX = 'nx-invoke=("@method" "@path" "@query" "content-type" "content-digest" "x-client-version")';
+const HKDF_SALT = createHash('sha256')
+    .update('neocortex/http-message-signature/salt/v1', 'utf8')
+    .digest();
+const HKDF_INFO = Buffer.concat([
+    Buffer.from('neocortex/invoke-request/v1', 'utf8'),
+    Buffer.from([0]),
+    Buffer.from(NX_INVOKE_ALGORITHM, 'ascii'),
+]);
+const KEY_ID_DOMAIN = Buffer.from('neocortex/invoke-key-id/v1', 'utf8');
+const BASE64URL_32_RE = /^[A-Za-z0-9_-]{43}$/;
+const BASE64_32_RE = /^[A-Za-z0-9+/]{43}=$/;
+const CLIENT_VERSION_RE = /^[A-Za-z0-9._+-]{1,64}$/;
+const SAFE_INTEGER_RE = /^(0|[1-9][0-9]{0,15})$/;
+function exactBase64Url32(value) {
+    if (!BASE64URL_32_RE.test(value))
+        return null;
+    const decoded = Buffer.from(value, 'base64url');
+    if (decoded.length !== 32 || decoded.toString('base64url') !== value)
+        return null;
+    return decoded;
+}
+function exactBase6432(value) {
+    if (!BASE64_32_RE.test(value))
+        return null;
+    const decoded = Buffer.from(value, 'base64');
+    if (decoded.length !== 32 || decoded.toString('base64') !== value)
+        return null;
+    return decoded;
+}
+function safeSeconds(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function splitRawTarget(target) {
+    if (!target.startsWith('/') || /[\u0000-\u0020\u007f#]/.test(target))
+        return null;
+    const queryIndex = target.indexOf('?');
+    const path = queryIndex === -1 ? target : target.slice(0, queryIndex);
+    const query = queryIndex === -1 ? '?' : target.slice(queryIndex);
+    return { path: path || '/', query };
+}
+function contentDigest(body) {
+    const digest = createHash('sha256').update(body).digest();
+    return { header: `sha-256=:${digest.toString('base64')}:`, digest };
+}
+export function deriveNxInvokeKey(bearerToken) {
+    if (!bearerToken || /[^\x21-\x7e]/.test(bearerToken)) {
+        throw new Error('invalid-bearer-token');
+    }
+    return Buffer.from(hkdfSync('sha256', Buffer.from(bearerToken, 'ascii'), HKDF_SALT, HKDF_INFO, 32));
+}
+export function deriveNxInvokeKeyId(key) {
+    if (key.byteLength !== 32)
+        throw new Error('invalid-derived-key-length');
+    return createHmac('sha256', key).update(KEY_ID_DOMAIN).digest('base64url');
+}
+export function buildNxInvokeSignatureInput(metadata) {
+    return `${SIGNATURE_INPUT_PREFIX};created=${metadata.created};expires=${metadata.expires};nonce="${metadata.nonce}";keyid="${metadata.keyId}";alg="${NX_INVOKE_ALGORITHM}";tag="${NX_INVOKE_TAG}"`;
+}
+export function parseNxInvokeSignatureInput(value) {
+    const match = new RegExp(`^${SIGNATURE_INPUT_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}` +
+        ';created=([0-9]+);expires=([0-9]+);nonce="([A-Za-z0-9_-]+)";keyid="([A-Za-z0-9_-]+)";alg="hmac-sha256";tag="neocortex-invoke-v1"$').exec(value);
+    if (!match || !SAFE_INTEGER_RE.test(match[1]) || !SAFE_INTEGER_RE.test(match[2]))
+        return null;
+    const created = Number(match[1]);
+    const expires = Number(match[2]);
+    if (!safeSeconds(created) || !safeSeconds(expires))
+        return null;
+    if (!exactBase64Url32(match[3]) || !exactBase64Url32(match[4]))
+        return null;
+    return { created, expires, nonce: match[3], keyId: match[4] };
+}
+export function buildNxInvokeSignatureBase(input) {
+    const method = input.method.toUpperCase();
+    if (method !== input.method || !/^[A-Z]+$/.test(method))
+        throw new Error('invalid-method');
+    const target = splitRawTarget(input.target);
+    if (!target)
+        throw new Error('invalid-target');
+    if (input.contentType !== NX_INVOKE_CONTENT_TYPE)
+        throw new Error('invalid-content-type');
+    if (!CLIENT_VERSION_RE.test(input.clientVersion))
+        throw new Error('invalid-client-version');
+    return Buffer.from([
+        `"@method": ${method}`,
+        `"@path": ${target.path}`,
+        `"@query": ${target.query}`,
+        `"content-type": ${input.contentType}`,
+        `"content-digest": ${input.contentDigest}`,
+        `"x-client-version": ${input.clientVersion}`,
+        `"@signature-params": ${input.signatureInput.slice(`${NX_INVOKE_LABEL}=`.length)}`,
+    ].join('\n'), 'utf8');
+}
+export function signNxInvokeRequest(input) {
+    const now = input.nowSeconds ?? Math.floor(Date.now() / 1000);
+    const expires = input.expiresSeconds ?? now + NX_INVOKE_SIGNATURE_TTL_SECONDS;
+    if (!safeSeconds(now) || !safeSeconds(expires) || expires <= now || expires - now > NX_INVOKE_MAX_LIFETIME_SECONDS) {
+        throw new Error('invalid-signature-time');
+    }
+    if (!CLIENT_VERSION_RE.test(input.clientVersion))
+        throw new Error('invalid-client-version');
+    const target = splitRawTarget(input.target);
+    if (!target)
+        throw new Error('invalid-target');
+    const nonceBytes = input.nonceBytes ? Buffer.from(input.nonceBytes) : randomBytes(32);
+    if (nonceBytes.length !== 32)
+        throw new Error('invalid-nonce-length');
+    const nonce = nonceBytes.toString('base64url');
+    const key = deriveNxInvokeKey(input.bearerToken);
+    const keyId = deriveNxInvokeKeyId(key);
+    const metadata = { created: now, expires, nonce, keyId };
+    const signatureInput = buildNxInvokeSignatureInput(metadata);
+    const body = Buffer.from(input.body);
+    const digest = contentDigest(body);
+    const signatureBase = buildNxInvokeSignatureBase({
+        method: input.method,
+        target: input.target,
+        contentType: NX_INVOKE_CONTENT_TYPE,
+        contentDigest: digest.header,
+        clientVersion: input.clientVersion,
+        signatureInput,
+    });
+    const signature = createHmac('sha256', key).update(signatureBase).digest('base64');
+    key.fill(0);
+    return {
+        body,
+        metadata,
+        headers: Object.freeze({
+            'Content-Type': NX_INVOKE_CONTENT_TYPE,
+            'Content-Digest': digest.header,
+            'Signature-Input': signatureInput,
+            Signature: `${NX_INVOKE_LABEL}=:${signature}:`,
+            'X-Client-Version': input.clientVersion,
+        }),
+        signatureBase,
+    };
+}
+function fail(reason) {
+    return { ok: false, reason };
+}
+export function verifyNxInvokeRequest(input) {
+    if (input.contentType !== NX_INVOKE_CONTENT_TYPE)
+        return fail('invalid-content-type');
+    if (!CLIENT_VERSION_RE.test(input.clientVersion))
+        return fail('invalid-client-version');
+    if (!splitRawTarget(input.target))
+        return fail('invalid-target');
+    const metadata = parseNxInvokeSignatureInput(input.signatureInput);
+    if (!metadata)
+        return fail('invalid-profile');
+    const now = input.nowSeconds ?? Math.floor(Date.now() / 1000);
+    if (!safeSeconds(now))
+        return fail('invalid-created');
+    if (metadata.expires <= metadata.created || metadata.expires - metadata.created > NX_INVOKE_MAX_LIFETIME_SECONDS) {
+        return fail('invalid-lifetime');
+    }
+    if (metadata.created > now + NX_INVOKE_CLOCK_SKEW_SECONDS || metadata.created < now - NX_INVOKE_MAX_AGE_SECONDS) {
+        return fail('signature-expired');
+    }
+    if (metadata.expires < now - NX_INVOKE_CLOCK_SKEW_SECONDS)
+        return fail('signature-expired');
+    if (!exactBase64Url32(metadata.nonce))
+        return fail('invalid-nonce');
+    const receivedKeyId = exactBase64Url32(metadata.keyId);
+    if (!receivedKeyId)
+        return fail('invalid-key-id');
+    const digestMatch = /^sha-256=:([A-Za-z0-9+/]{43}=):$/.exec(input.contentDigest);
+    const receivedDigest = digestMatch ? exactBase6432(digestMatch[1]) : null;
+    if (!receivedDigest)
+        return fail('invalid-content-digest');
+    const actualDigest = contentDigest(input.body).digest;
+    if (!timingSafeEqual(receivedDigest, actualDigest))
+        return fail('invalid-content-digest');
+    const signatureMatch = /^nx-invoke=:([A-Za-z0-9+/]{43}=):$/.exec(input.signature);
+    const receivedSignature = signatureMatch ? exactBase6432(signatureMatch[1]) : null;
+    if (!receivedSignature)
+        return fail('invalid-signature');
+    let key;
+    try {
+        key = deriveNxInvokeKey(input.bearerToken);
+    }
+    catch {
+        return fail('invalid-key-id');
+    }
+    const expectedKeyId = Buffer.from(deriveNxInvokeKeyId(key), 'base64url');
+    if (!timingSafeEqual(receivedKeyId, expectedKeyId)) {
+        key.fill(0);
+        return fail('invalid-key-id');
+    }
+    let signatureBase;
+    try {
+        signatureBase = buildNxInvokeSignatureBase({
+            method: input.method,
+            target: input.target,
+            contentType: input.contentType,
+            contentDigest: input.contentDigest,
+            clientVersion: input.clientVersion,
+            signatureInput: input.signatureInput,
+        });
+    }
+    catch {
+        key.fill(0);
+        return fail('invalid-profile');
+    }
+    const expectedSignature = createHmac('sha256', key).update(signatureBase).digest();
+    key.fill(0);
+    if (!timingSafeEqual(receivedSignature, expectedSignature))
+        return fail('invalid-signature');
+    return { ok: true, metadata, signatureBase };
+}

package/packages/shared/dist/strict-readonly.js

@@ -0,0 +1,381 @@
+import { createHash } from 'node:crypto';
+export const STRICT_READ_ONLY_POLICY = 'strict-read-only-v1';
+export const STRICT_READ_ONLY_RECEIPT_SCHEMA = 'nx-strict-readonly-receipt-v1';
+export const STRICT_READ_ONLY_SECURITY_SCHEMA = 'nx-security-admission-receipt-v1';
+export const STRICT_READ_ONLY_MAX_DESCRIPTORS = 64;
+export const STRICT_READ_ONLY_MAX_COUNT = 0x7fff_ffff;
+export const STRICT_READ_ONLY_PHASES = ['client-preflight', 'security-admission', 'server-before', 'engine', 'server-after', 'client-writeback'];
+export const STRICT_READ_ONLY_DOMAINS = ['client-persistence', 'server-business', 'external-effect', 'security-admission'];
+export const STRICT_READ_ONLY_OPERATIONS = ['create', 'update', 'delete', 'consume', 'enqueue', 'spawn', 'send'];
+export const STRICT_READ_ONLY_CATEGORIES = {
+    'client-persistence': ['first-run-marker', 'auth-cache', 'tier-cache', 'state-repair', 'checkpoint-consume', 'pending-claim', 'continuity-store', 'state-writeback', 'scheduler-session'],
+    'server-business': ['checkpoint-persist', 'quota', 'history', 'analytics', 'audit', 'evidence', 'funnel', 'scheduler-session'],
+    'external-effect': ['telemetry', 'network-mutation', 'process', 'git'],
+    'security-admission': ['replay-claim', 'rate-safety', 'abuse-protection'],
+};
+export class StrictReadOnlyError extends Error {
+    code;
+    retryable = false;
+    remediationClass;
+    constructor(code, remediationClass = 'integrity') {
+        super(code);
+        this.code = code;
+        this.name = 'StrictReadOnlyError';
+        this.remediationClass = remediationClass;
+    }
+}
+/**
+ * Closed projection manifests consumed by the client and server gateways.
+ * Keeping these descriptors beside the taxonomy prevents either gateway from
+ * growing an independent list of effects while preserving their separate
+ * command-registry admission decisions.
+ */
+export const STRICT_READ_ONLY_CLIENT_PROJECTION = Object.freeze([
+    Object.freeze({ phase: 'client-preflight', domain: 'client-persistence', category: 'first-run-marker', operation: 'create' }),
+    Object.freeze({ phase: 'client-preflight', domain: 'client-persistence', category: 'auth-cache', operation: 'update' }),
+    Object.freeze({ phase: 'client-preflight', domain: 'client-persistence', category: 'tier-cache', operation: 'update' }),
+    Object.freeze({ phase: 'client-preflight', domain: 'client-persistence', category: 'state-repair', operation: 'update' }),
+    Object.freeze({ phase: 'client-preflight', domain: 'client-persistence', category: 'checkpoint-consume', operation: 'consume' }),
+    Object.freeze({ phase: 'client-preflight', domain: 'client-persistence', category: 'pending-claim', operation: 'update' }),
+    Object.freeze({ phase: 'client-preflight', domain: 'client-persistence', category: 'continuity-store', operation: 'create' }),
+    Object.freeze({ phase: 'client-preflight', domain: 'client-persistence', category: 'continuity-store', operation: 'update' }),
+    Object.freeze({ phase: 'client-writeback', domain: 'client-persistence', category: 'state-writeback', operation: 'update' }),
+    Object.freeze({ phase: 'client-preflight', domain: 'client-persistence', category: 'scheduler-session', operation: 'create' }),
+    Object.freeze({ phase: 'client-preflight', domain: 'external-effect', category: 'process', operation: 'spawn' }),
+    Object.freeze({ phase: 'client-preflight', domain: 'external-effect', category: 'git', operation: 'spawn' }),
+    Object.freeze({ phase: 'client-preflight', domain: 'external-effect', category: 'network-mutation', operation: 'send' }),
+    Object.freeze({ phase: 'client-writeback', domain: 'client-persistence', category: 'auth-cache', operation: 'update' }),
+    Object.freeze({ phase: 'client-writeback', domain: 'client-persistence', category: 'tier-cache', operation: 'update' }),
+    Object.freeze({ phase: 'client-writeback', domain: 'client-persistence', category: 'pending-claim', operation: 'update' }),
+    Object.freeze({ phase: 'client-writeback', domain: 'client-persistence', category: 'continuity-store', operation: 'update' }),
+]);
+export const STRICT_READ_ONLY_SERVER_PROJECTION = Object.freeze([
+    Object.freeze({ phase: 'server-before', domain: 'server-business', category: 'checkpoint-persist', operation: 'create' }),
+    Object.freeze({ phase: 'server-before', domain: 'server-business', category: 'audit', operation: 'create' }),
+    Object.freeze({ phase: 'engine', domain: 'server-business', category: 'checkpoint-persist', operation: 'delete' }),
+    Object.freeze({ phase: 'engine', domain: 'server-business', category: 'audit', operation: 'create' }),
+    Object.freeze({ phase: 'server-before', domain: 'server-business', category: 'quota', operation: 'update' }),
+    Object.freeze({ phase: 'server-after', domain: 'server-business', category: 'history', operation: 'create' }),
+    Object.freeze({ phase: 'server-after', domain: 'server-business', category: 'analytics', operation: 'create' }),
+    Object.freeze({ phase: 'server-after', domain: 'server-business', category: 'audit', operation: 'create' }),
+    Object.freeze({ phase: 'server-after', domain: 'server-business', category: 'evidence', operation: 'create' }),
+    Object.freeze({ phase: 'server-after', domain: 'server-business', category: 'funnel', operation: 'create' }),
+    Object.freeze({ phase: 'server-after', domain: 'external-effect', category: 'telemetry', operation: 'send' }),
+    Object.freeze({ phase: 'server-after', domain: 'external-effect', category: 'network-mutation', operation: 'send' }),
+    Object.freeze({ phase: 'engine', domain: 'external-effect', category: 'process', operation: 'spawn' }),
+    Object.freeze({ phase: 'engine', domain: 'external-effect', category: 'git', operation: 'spawn' }),
+    Object.freeze({ phase: 'engine', domain: 'server-business', category: 'scheduler-session', operation: 'update' }),
+]);
+const phaseSet = new Set(STRICT_READ_ONLY_PHASES);
+const domainSet = new Set(STRICT_READ_ONLY_DOMAINS);
+const operationSet = new Set(STRICT_READ_ONLY_OPERATIONS);
+function exactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+export function parseStrictReadOnlyIntent(value) {
+    if (value === undefined || value === null)
+        return null;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new StrictReadOnlyError('readonly-policy-unsupported', 'policy');
+    const record = value;
+    if (!exactKeys(record, ['schemaVersion', 'policy', 'registryVersion', 'registryChecksum'])
+        || record.schemaVersion !== 1 || record.policy !== STRICT_READ_ONLY_POLICY
+        || typeof record.registryVersion !== 'string' || record.registryVersion.length < 1 || record.registryVersion.length > 32
+        || typeof record.registryChecksum !== 'string' || !/^[a-f0-9]{64}$/.test(record.registryChecksum)) {
+        throw new StrictReadOnlyError('readonly-policy-unsupported', 'policy');
+    }
+    return Object.freeze(record);
+}
+function validateDescriptor(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)
+        || (!exactKeys(input, ['phase', 'domain', 'category', 'operation'])
+            && !exactKeys(input, ['phase', 'domain', 'category', 'operation', 'count']))) {
+        throw new StrictReadOnlyError('readonly-effect-unknown');
+    }
+    if (!phaseSet.has(input.phase) || !domainSet.has(input.domain) || !operationSet.has(input.operation)) {
+        throw new StrictReadOnlyError('readonly-effect-unknown');
+    }
+    const categories = STRICT_READ_ONLY_CATEGORIES[input.domain];
+    if (!categories.includes(input.category))
+        throw new StrictReadOnlyError('readonly-effect-unknown');
+    const count = input.count ?? 1;
+    if (!Number.isSafeInteger(count) || count < 1)
+        throw new StrictReadOnlyError('readonly-effect-unknown');
+    return Object.freeze({
+        phase: input.phase,
+        domain: input.domain,
+        category: input.category,
+        operation: input.operation,
+        count: Math.min(count, STRICT_READ_ONLY_MAX_COUNT),
+    });
+}
+function descriptorKey(descriptor) {
+    return `${descriptor.phase}\0${descriptor.domain}\0${descriptor.category}\0${descriptor.operation}`;
+}
+function sha256(value) {
+    return createHash('sha256').update(value, 'utf8').digest('hex');
+}
+export function canonicalizeInvokeEffects(descriptors) {
+    const aggregated = new Map();
+    for (const raw of descriptors) {
+        const descriptor = validateDescriptor(raw);
+        const key = descriptorKey(descriptor);
+        const prior = aggregated.get(key);
+        if (!prior && aggregated.size >= STRICT_READ_ONLY_MAX_DESCRIPTORS) {
+            throw new StrictReadOnlyError('readonly-projection-capacity-exceeded', 'boundary');
+        }
+        aggregated.set(key, Object.freeze({ ...descriptor, count: Math.min(STRICT_READ_ONLY_MAX_COUNT, (prior?.count ?? 0) + descriptor.count) }));
+    }
+    return Object.freeze([...aggregated.values()].sort((a, b) => Buffer.from(descriptorKey(a)).compare(Buffer.from(descriptorKey(b)))));
+}
+const capabilityOwner = new WeakMap();
+const capabilityDescriptor = new WeakMap();
+const consumedCapabilities = new WeakSet();
+const CAPABILITY = Symbol('InvokeEffectCapability');
+export class InvokeEffectContext {
+    invocationId;
+    mode;
+    intent;
+    registryGeneration;
+    requestFingerprintPrefix;
+    stateValue = 'created';
+    projected = [];
+    sealedProjection = null;
+    applied = new Set();
+    deniedCode;
+    constructor(invocationId, mode, intent, registryGeneration, requestFingerprintPrefix) {
+        this.invocationId = invocationId;
+        this.mode = mode;
+        this.intent = intent;
+        this.registryGeneration = registryGeneration;
+        this.requestFingerprintPrefix = requestFingerprintPrefix;
+        if (!/^[a-zA-Z0-9_-]{8,128}$/.test(invocationId) || !/^[a-f0-9]{8,32}$/.test(requestFingerprintPrefix)) {
+            throw new StrictReadOnlyError('readonly-authority-missing');
+        }
+        if ((mode === 'strict') !== (intent !== null))
+            throw new StrictReadOnlyError('readonly-authority-conflict');
+    }
+    get state() { return this.stateValue; }
+    get failureCode() { return this.deniedCode; }
+    beginProjection() {
+        if (this.stateValue !== 'created')
+            return this.deny('readonly-authority-conflict');
+        this.stateValue = 'projecting';
+    }
+    project(input) {
+        if (this.stateValue === 'sealed' || this.stateValue === 'strict_projected' || this.stateValue === 'committed')
+            return this.deny('readonly-late-effect-denied');
+        if (this.stateValue !== 'projecting')
+            return this.deny('readonly-authority-missing');
+        try {
+            const next = validateDescriptor(input);
+            canonicalizeInvokeEffects([...this.projected, next]);
+            this.projected.push(next);
+        }
+        catch (error) {
+            this.deny(error instanceof StrictReadOnlyError ? error.code : 'readonly-effect-unknown');
+        }
+    }
+    seal() {
+        if (this.stateValue !== 'projecting')
+            return this.deny('readonly-authority-conflict');
+        this.sealedProjection = canonicalizeInvokeEffects(this.projected);
+        this.stateValue = 'sealed';
+        return this.sealedProjection;
+    }
+    capability(input) {
+        if (this.stateValue !== 'sealed' || this.mode === 'strict' || !this.sealedProjection)
+            return this.deny('readonly-effect-unregistered');
+        const descriptor = validateDescriptor(input);
+        const key = descriptorKey(descriptor);
+        if (!this.sealedProjection.some((item) => descriptorKey(item) === key))
+            return this.deny('readonly-effect-unregistered');
+        const capability = Object.freeze({ [CAPABILITY]: true });
+        capabilityOwner.set(capability, this);
+        capabilityDescriptor.set(capability, key);
+        return capability;
+    }
+    apply(capability, effect) {
+        if (this.stateValue === 'denied')
+            throw new StrictReadOnlyError(this.deniedCode ?? 'readonly-authority-missing');
+        if (this.mode === 'strict')
+            return this.deny('readonly-effect-unregistered');
+        if (capabilityOwner.get(capability) !== this)
+            return this.deny('readonly-authority-conflict');
+        const key = capabilityDescriptor.get(capability);
+        if (!key || consumedCapabilities.has(capability))
+            return this.deny('readonly-effect-unregistered');
+        this.stateValue = 'applying';
+        let result;
+        try {
+            result = effect();
+        }
+        catch (error) {
+            this.stateValue = 'sealed';
+            throw error;
+        }
+        consumedCapabilities.add(capability);
+        this.applied.add(key);
+        this.stateValue = 'sealed';
+        return result;
+    }
+    async applyAsync(capability, effect) {
+        if (this.stateValue === 'denied')
+            throw new StrictReadOnlyError(this.deniedCode ?? 'readonly-authority-missing');
+        if (this.mode === 'strict')
+            return this.deny('readonly-effect-unregistered');
+        if (capabilityOwner.get(capability) !== this)
+            return this.deny('readonly-authority-conflict');
+        const key = capabilityDescriptor.get(capability);
+        if (!key || consumedCapabilities.has(capability))
+            return this.deny('readonly-effect-unregistered');
+        this.stateValue = 'applying';
+        try {
+            const result = await effect();
+            consumedCapabilities.add(capability);
+            this.applied.add(key);
+            this.stateValue = 'sealed';
+            return result;
+        }
+        catch (error) {
+            this.stateValue = 'sealed';
+            throw error;
+        }
+    }
+    execute(descriptor, effect, projected) {
+        if (this.stateValue !== 'sealed')
+            return this.deny('readonly-authority-missing');
+        this.assertRegisteredDescriptor(descriptor);
+        if (this.mode === 'strict')
+            return projected();
+        return this.apply(this.capability(descriptor), effect);
+    }
+    executeAsync(descriptor, effect, projected) {
+        if (this.stateValue !== 'sealed')
+            return Promise.reject(new StrictReadOnlyError('readonly-authority-missing'));
+        try {
+            this.assertRegisteredDescriptor(descriptor);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        if (this.mode === 'strict')
+            return projected();
+        return this.applyAsync(this.capability(descriptor), effect);
+    }
+    complete(security = emptySecurityAdmissionReceipt()) {
+        if (this.stateValue !== 'sealed' || !this.sealedProjection)
+            return this.deny('readonly-receipt-mismatch');
+        this.stateValue = this.mode === 'strict' ? 'strict_projected' : 'committed';
+        const canonical = JSON.stringify(this.sealedProjection);
+        return Object.freeze({
+            schema: STRICT_READ_ONLY_RECEIPT_SCHEMA,
+            policy: this.intent?.policy ?? null,
+            effectiveMode: this.mode,
+            registryGeneration: this.registryGeneration.slice(0, 32),
+            requestFingerprintPrefix: this.requestFingerprintPrefix,
+            projectionFingerprint: sha256(`nx-effect-projection-v1\0${canonical}`),
+            descriptorCount: this.sealedProjection.length,
+            wouldHaveMutated: this.sealedProjection,
+            security,
+            completed: true,
+            projectBusinessMutation: this.mode === 'normal' && this.applied.size > 0,
+        });
+    }
+    assertReceiptBinding(receipt) {
+        if (!this.sealedProjection
+            || receipt.registryGeneration !== this.registryGeneration.slice(0, 32)
+            || JSON.stringify(receipt.wouldHaveMutated) !== JSON.stringify(this.sealedProjection)) {
+            throw new StrictReadOnlyError('readonly-receipt-mismatch');
+        }
+    }
+    deny(code) {
+        this.stateValue = 'denied';
+        this.deniedCode = code;
+        throw new StrictReadOnlyError(code);
+    }
+    assertRegisteredDescriptor(input) {
+        if (!this.sealedProjection)
+            return this.deny('readonly-authority-missing');
+        let descriptor;
+        try {
+            descriptor = validateDescriptor(input);
+        }
+        catch (error) {
+            return this.deny(error instanceof StrictReadOnlyError ? error.code : 'readonly-effect-unknown');
+        }
+        const key = descriptorKey(descriptor);
+        if (!this.sealedProjection.some((item) => descriptorKey(item) === key)) {
+            return this.deny('readonly-effect-unregistered');
+        }
+    }
+}
+export function emptySecurityAdmissionReceipt() {
+    return Object.freeze({ schema: STRICT_READ_ONLY_SECURITY_SCHEMA, replay: 'not-applicable', rate: 'not-applicable', abuse: 'not-applicable' });
+}
+export function verifyStrictReadOnlyReceipt(expected, value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new StrictReadOnlyError('readonly-receipt-mismatch');
+    const receipt = value;
+    if (!exactKeys(value, [
+        'schema', 'policy', 'effectiveMode', 'registryGeneration', 'requestFingerprintPrefix',
+        'projectionFingerprint', 'descriptorCount', 'wouldHaveMutated', 'security', 'completed',
+        'projectBusinessMutation',
+    ])
+        || !receipt.security || typeof receipt.security !== 'object' || Array.isArray(receipt.security)
+        || !exactKeys(receipt.security, ['schema', 'replay', 'rate', 'abuse'])
+        || receipt.security.schema !== STRICT_READ_ONLY_SECURITY_SCHEMA
+        || !['accepted', 'not-applicable'].includes(receipt.security.replay)
+        || !['accepted', 'not-applicable'].includes(receipt.security.rate)
+        || !['accepted', 'not-applicable'].includes(receipt.security.abuse)
+        || receipt.schema !== STRICT_READ_ONLY_RECEIPT_SCHEMA || receipt.effectiveMode !== expected.mode
+        || receipt.policy !== expected.intent?.policy || receipt.requestFingerprintPrefix !== expected.requestFingerprintPrefix
+        || receipt.completed !== true || (expected.mode === 'strict' && receipt.projectBusinessMutation !== false)
+        || !Array.isArray(receipt.wouldHaveMutated) || receipt.descriptorCount !== receipt.wouldHaveMutated.length
+        || receipt.descriptorCount > STRICT_READ_ONLY_MAX_DESCRIPTORS
+        || receipt.projectionFingerprint !== sha256(`nx-effect-projection-v1\0${JSON.stringify(canonicalizeInvokeEffects(receipt.wouldHaveMutated))}`)) {
+        throw new StrictReadOnlyError('readonly-receipt-mismatch');
+    }
+    expected.assertReceiptBinding(receipt);
+}
+export function createInvokeEffectContext(input) {
+    const intent = parseStrictReadOnlyIntent(input.intent);
+    if (intent && (!input.registryAllowsStrict))
+        throw new StrictReadOnlyError('readonly-registry-denied', 'policy');
+    if (intent && (intent.registryVersion !== input.registryVersion || intent.registryChecksum !== input.registryChecksum)) {
+        throw new StrictReadOnlyError('readonly-authority-conflict');
+    }
+    return new InvokeEffectContext(input.invocationId, intent ? 'strict' : 'normal', intent, `${input.registryVersion}:${input.registryChecksum.slice(0, 12)}`, sha256(`nx-request-public-prefix-v1\0${input.requestCanonicalBytes}`).slice(0, 16));
+}
+export const STRICT_PROCESS_PROFILES = Object.freeze({
+    'node-version': Object.freeze({ executable: 'node', argv: ['--version'] }),
+    'git-status': Object.freeze({ executable: 'git', argv: ['status', '--short', '--branch'] }),
+    'git-rev-parse': Object.freeze({ executable: 'git', argv: ['rev-parse', '--show-toplevel'] }),
+});
+export function resolveClosedProcessProfile(profile, cwd) {
+    const selected = STRICT_PROCESS_PROFILES[profile];
+    const absoluteCwd = cwd.startsWith('/') || /^[A-Za-z]:[\\/]/u.test(cwd);
+    if (!selected || !absoluteCwd || /[\r\n\0]/u.test(cwd) || cwd.split(/[\\/]/u).includes('..')) {
+        throw new StrictReadOnlyError('readonly-physical-boundary-unsafe', 'boundary');
+    }
+    const env = profile.startsWith('git-')
+        ? Object.freeze({
+            PATH: '/usr/bin:/bin',
+            GIT_OPTIONAL_LOCKS: '0',
+            GIT_CONFIG_NOSYSTEM: '1',
+            GIT_CONFIG_GLOBAL: '/dev/null',
+            GIT_CONFIG_COUNT: '4',
+            GIT_CONFIG_KEY_0: 'core.hooksPath', GIT_CONFIG_VALUE_0: '/dev/null',
+            GIT_CONFIG_KEY_1: 'core.fsmonitor', GIT_CONFIG_VALUE_1: 'false',
+            GIT_CONFIG_KEY_2: 'maintenance.auto', GIT_CONFIG_VALUE_2: 'false',
+            GIT_CONFIG_KEY_3: 'gc.auto', GIT_CONFIG_VALUE_3: '0',
+        })
+        : Object.freeze({ PATH: '/usr/bin:/bin' });
+    return Object.freeze({ ...selected, cwd, shell: false, timeoutMs: 10_000, env });
+}
+export function assertDeclaredNetworkTransport(kind) {
+    if (kind !== 'invoke-query')
+        throw new StrictReadOnlyError('readonly-physical-boundary-unsafe', 'boundary');
+}