@futdevpro/fsm-dynamo 1.20.92 → 1.20.93

package/build-esm/_modules/request-safety/_collections/request-safety-inspector.util.js

@@ -0,0 +1,317 @@
+import { DyFM_RequestSafetyFinding_Type } from '../_enums/request-safety-finding.type-enum';
+/**
+ * BFR-CTM-034 — cross-runtime, content-free request safety inspector.
+ *
+ * ⚠️ **What this is for:** a value is about to cross a boundary (browser → transport, or transport →
+ * state mutation / provider dispatch). Once it has crossed, masking it afterwards is too late — the
+ * value has already been serialized, stored or sent. This inspector runs BEFORE that, and answers a
+ * single question: *may this cross?* — without ever repeating what it saw.
+ *
+ * ⛔ **No side effects, by construction.** No logging, no network, no storage, no timers, no `Math.random`,
+ * no environment access. That is not stylistic: the inspector runs on hostile input, so anything it
+ * touched would become an attack surface, and anything it logged would re-leak the value it rejected.
+ * The same source therefore runs unchanged in a browser, a Worker and Node.
+ *
+ * Supply inert data and a trusted product policy. Reflection on a JavaScript Proxy can execute its
+ * traps; this utility contains thrown errors but cannot sandbox that code. Likewise, node/string
+ * counters do not replace a separate process/sandbox memory and CPU limit.
+ */
+export class DyFM_RequestSafetyInspector_Util {
+    /**
+     * Format/invisible characters that hide a value from a naive matcher while remaining meaningful to a
+     * human reader or a downstream parser: zero-width space/non-joiner/joiner, word joiner, BOM, the
+     * bidirectional overrides, and the soft hyphen.
+     *
+     * ⭐ These are removed AFTER NFKC. NFKC alone does not drop them, so a `p​assword` key would
+     * still slip past a forbidden-key set that only normalizes.
+     */
+    static formatObfuscators = /[\u00ad\u200b-\u200f\u202a-\u202e\u2060-\u2064\ufeff]/g;
+    /**
+     * Normalizes a string for matching: NFKC, then format-obfuscator removal, then case folding.
+     *
+     * ⚠️ The order matters. NFKC first folds the full-width and compatibility forms (`ｐａｓｓｗｏｒｄ`,
+     * `𝐩𝐚𝐬𝐬𝐰𝐨𝐫𝐝`) onto their ASCII equivalents; only then can the invisible-character strip and the
+     * case fold see a plain string. Reversing the steps leaves obfuscated forms unmatched.
+     */
+    static normalize(value) {
+        return `${value ?? ''}`
+            .normalize('NFKC')
+            .replace(DyFM_RequestSafetyInspector_Util.formatObfuscators, '')
+            .toLowerCase();
+    }
+    /**
+     * Inspects `input` against a caller-owned policy.
+     *
+     * Fail-closed everywhere: an invalid policy, an unsupported value type, a hostile prototype, an
+     * accessor or a blown budget all DECLINE. There is no path that returns `accepted: true` because the
+     * inspector could not decide.
+     *
+     * @returns a content-free outcome; the input itself is never echoed in any form.
+     */
+    static inspect(input, policy) {
+        const snapshot = DyFM_RequestSafetyInspector_Util.snapshotPolicy(policy);
+        const counts = {};
+        let inspectedNodes = 0;
+        const namespace = snapshot?.namespace ?? 'unknown';
+        /** Adds only a stable namespaced finding and its aggregate count. */
+        const record = (finding) => {
+            const code = `${namespace}:${finding}`;
+            counts[code] = (counts[code] ?? 0) + 1;
+        };
+        if (!snapshot) {
+            // Invalid policy is not permission to proceed. Do not echo even its namespace.
+            const code = `unknown:${DyFM_RequestSafetyFinding_Type.invalidPolicy}`;
+            return {
+                contractVersion: 'dyfm-request-safety/1',
+                accepted: false,
+                findingCodes: [code],
+                findingCounts: { [code]: 1 },
+                inspectedNodes: 0,
+            };
+        }
+        policy = snapshot;
+        const forbiddenKeys = new Set((policy.forbiddenKeys ?? []).map((key) => DyFM_RequestSafetyInspector_Util.normalize(key)));
+        // Only the active path constitutes a cycle; acyclic shared subtrees are valid JSON input.
+        const ancestors = new Set();
+        let isNodeBudgetExhausted = false;
+        /** Visits data descriptors within the shared per-call budgets. */
+        const walk = (value, depth) => {
+            if (isNodeBudgetExhausted) {
+                return;
+            }
+            if (inspectedNodes >= policy.maxNodes) {
+                isNodeBudgetExhausted = true;
+                record(DyFM_RequestSafetyFinding_Type.nodeBudget);
+                return;
+            }
+            inspectedNodes++;
+            if (depth > policy.maxDepth) {
+                record(DyFM_RequestSafetyFinding_Type.depthBudget);
+                return;
+            }
+            if (value === null || typeof value === 'boolean' || typeof value === 'number') {
+                return;
+            }
+            if (typeof value === 'string') {
+                DyFM_RequestSafetyInspector_Util.inspectString(value, policy, record);
+                return;
+            }
+            if (typeof value === 'undefined') {
+                return;
+            }
+            if (typeof value !== 'object') {
+                // Functions, symbols and bigint are not carried by this contract.
+                record(DyFM_RequestSafetyFinding_Type.unsupportedValueType);
+                return;
+            }
+            if (ancestors.has(value)) {
+                record(DyFM_RequestSafetyFinding_Type.cycle);
+                return;
+            }
+            const isArray = Array.isArray(value);
+            const prototype = Object.getPrototypeOf(value);
+            if (isArray ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) {
+                // Serialization of custom prototypes may differ from the inspected data.
+                record(DyFM_RequestSafetyFinding_Type.unsupportedPrototype);
+                return;
+            }
+            ancestors.add(value);
+            try {
+                // Never invoke input iterators or read property values directly, including array indices.
+                const keys = Reflect.ownKeys(value);
+                if (isArray) {
+                    // Holes serialize too. Charge them arithmetically, without iterating a huge sparse array.
+                    const length = DyFM_RequestSafetyInspector_Util.arrayLength(value);
+                    const presentIndices = keys.filter((key) => (typeof key === 'string' && /^(?:0|[1-9]\d*)$/u.test(key) && Number(key) < length)).length;
+                    const holes = length - presentIndices;
+                    if (holes > policy.maxNodes - inspectedNodes) {
+                        inspectedNodes = policy.maxNodes;
+                        isNodeBudgetExhausted = true;
+                        record(DyFM_RequestSafetyFinding_Type.nodeBudget);
+                        return;
+                    }
+                    inspectedNodes += holes;
+                }
+                for (const key of keys) {
+                    if (isArray && key === 'length') {
+                        continue;
+                    }
+                    if (isNodeBudgetExhausted || inspectedNodes >= policy.maxNodes) {
+                        if (!isNodeBudgetExhausted) {
+                            record(DyFM_RequestSafetyFinding_Type.nodeBudget);
+                            isNodeBudgetExhausted = true;
+                        }
+                        break;
+                    }
+                    if (typeof key !== 'string') {
+                        inspectedNodes++;
+                        record(DyFM_RequestSafetyFinding_Type.unsupportedValueType);
+                        continue;
+                    }
+                    if (forbiddenKeys.has(DyFM_RequestSafetyInspector_Util.normalize(key))) {
+                        record(DyFM_RequestSafetyFinding_Type.forbiddenKey);
+                    }
+                    DyFM_RequestSafetyInspector_Util.inspectString(key, policy, record);
+                    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+                    if (!descriptor || !('value' in descriptor)) {
+                        inspectedNodes++;
+                        record(DyFM_RequestSafetyFinding_Type.accessor);
+                        continue;
+                    }
+                    walk(descriptor.value, depth + 1);
+                }
+            }
+            finally {
+                ancestors.delete(value);
+            }
+        };
+        try {
+            walk(input, 0);
+        }
+        catch {
+            // Proxy reflection can throw. Contain its error; this is not a sandbox for arbitrary proxy code.
+            record(DyFM_RequestSafetyFinding_Type.inspectionFailure);
+        }
+        const findingCodes = Object.keys(counts).sort();
+        return {
+            contractVersion: 'dyfm-request-safety/1',
+            accepted: findingCodes.length === 0,
+            findingCodes: findingCodes,
+            findingCounts: counts,
+            inspectedNodes: inspectedNodes,
+        };
+    }
+    /** Checks the string budget, canaries and the caller's sensitive/capability patterns. */
+    static inspectString(value, policy, record) {
+        const normalized = DyFM_RequestSafetyInspector_Util.normalize(value);
+        if (normalized.length > policy.maxStringLength) {
+            record(DyFM_RequestSafetyFinding_Type.stringBudget);
+            return;
+        }
+        for (const canary of policy.canaries ?? []) {
+            if (canary.length > 0 && normalized.includes(canary)) {
+                record(DyFM_RequestSafetyFinding_Type.canary);
+                break;
+            }
+        }
+        if (DyFM_RequestSafetyInspector_Util.matchesPattern(normalized, policy.sensitiveValuePatterns)) {
+            record(DyFM_RequestSafetyFinding_Type.sensitiveValue);
+        }
+        if (DyFM_RequestSafetyInspector_Util.matchesPattern(normalized, policy.unsupportedCapabilityPatterns)) {
+            record(DyFM_RequestSafetyFinding_Type.unsupportedCapability);
+        }
+    }
+    /**
+     * Records at most one finding per pattern group, using private per-inspection regex instances.
+     *
+     * Resetting the caller's cursor to zero was itself a mutation when it started at a nonzero offset,
+     * and threw for frozen patterns. Only the validated snapshot is mutable; the caller is never touched.
+     */
+    static matchesPattern(normalized, patterns) {
+        for (const pattern of patterns ?? []) {
+            pattern.lastIndex = 0;
+            if (pattern.test(normalized)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Validates the entire policy before input inspection, without invoking accessors or array iterators. */
+    static snapshotPolicy(policy) {
+        try {
+            if (!policy || typeof policy !== 'object') {
+                return null;
+            }
+            const prototype = Object.getPrototypeOf(policy);
+            if (prototype !== Object.prototype && prototype !== null) {
+                return null;
+            }
+            const allowedKeys = [
+                'namespace', 'maxDepth', 'maxNodes', 'maxStringLength', 'forbiddenKeys',
+                'canaries', 'sensitiveValuePatterns', 'unsupportedCapabilityPatterns',
+            ];
+            const values = {};
+            for (const key of Reflect.ownKeys(policy)) {
+                if (typeof key !== 'string' || !allowedKeys.includes(key)) {
+                    return null;
+                }
+                const descriptor = Object.getOwnPropertyDescriptor(policy, key);
+                if (!descriptor || !('value' in descriptor)) {
+                    return null;
+                }
+                values[key] = descriptor.value;
+            }
+            if (typeof values.namespace !== 'string' || !/^[a-z][a-z0-9_.|\-]{0,63}$/iu.test(values.namespace)) {
+                return null;
+            }
+            return {
+                namespace: values.namespace,
+                maxDepth: DyFM_RequestSafetyInspector_Util.positiveBudget(values.maxDepth),
+                maxNodes: DyFM_RequestSafetyInspector_Util.positiveBudget(values.maxNodes),
+                maxStringLength: DyFM_RequestSafetyInspector_Util.positiveBudget(values.maxStringLength),
+                forbiddenKeys: DyFM_RequestSafetyInspector_Util.snapshotList(values.forbiddenKeys, (entry) => {
+                    if (typeof entry !== 'string') {
+                        throw new Error('INVALID_POLICY');
+                    }
+                    return entry;
+                }),
+                canaries: DyFM_RequestSafetyInspector_Util.snapshotList(values.canaries, (entry) => {
+                    if (typeof entry !== 'string') {
+                        throw new Error('INVALID_POLICY');
+                    }
+                    return DyFM_RequestSafetyInspector_Util.normalize(entry);
+                }),
+                sensitiveValuePatterns: DyFM_RequestSafetyInspector_Util.snapshotList(values.sensitiveValuePatterns, DyFM_RequestSafetyInspector_Util.snapshotPattern),
+                unsupportedCapabilityPatterns: DyFM_RequestSafetyInspector_Util.snapshotList(values.unsupportedCapabilityPatterns, DyFM_RequestSafetyInspector_Util.snapshotPattern),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Copies dense policy lists through data descriptors, rejecting holes, accessors and custom properties. */
+    static snapshotList(value, convert) {
+        if (value === undefined) {
+            return [];
+        }
+        if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) {
+            throw new Error('INVALID_POLICY');
+        }
+        const length = DyFM_RequestSafetyInspector_Util.arrayLength(value);
+        if (Reflect.ownKeys(value).length !== length + 1) {
+            throw new Error('INVALID_POLICY');
+        }
+        const result = [];
+        for (let index = 0; index < length; index++) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (!descriptor || !('value' in descriptor)) {
+                throw new Error('INVALID_POLICY');
+            }
+            result.push(convert(descriptor.value));
+        }
+        return result;
+    }
+    /** Clones ordinary regexes without calling caller-defined test/source/flag members or touching lastIndex. */
+    static snapshotPattern(value) {
+        if (!(value instanceof RegExp) || Object.getPrototypeOf(value) !== RegExp.prototype ||
+            Reflect.ownKeys(value).some((key) => key !== 'lastIndex')) {
+            throw new Error('INVALID_POLICY');
+        }
+        return new RegExp(value.source, value.flags);
+    }
+    /** Narrows a required positive integer budget; errors remain inside the policy boundary. */
+    static positiveBudget(value) {
+        if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) {
+            throw new Error('INVALID_POLICY');
+        }
+        return value;
+    }
+    /** Reads and validates only the array's own length descriptor, never an input member access. */
+    static arrayLength(value) {
+        const length = Object.getOwnPropertyDescriptor(value, 'length')?.value;
+        if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0) {
+            throw new Error('INVALID_ARRAY');
+        }
+        return length;
+    }
+}

package/build-esm/_modules/request-safety/_enums/request-safety-finding.type-enum.js

@@ -0,0 +1,39 @@
+/**
+ * BFR-CTM-034 — the closed, content-free finding vocabulary.
+ *
+ * ⛔ These codes are the ONLY thing an inspection may say about *why* it declined. They deliberately
+ * describe the **class** of problem, never the offending value, key, path or pattern: a finding that
+ * echoes what it found turns a safety check into the very leak it was meant to prevent.
+ *
+ * The caller prefixes them with its own namespace, so two products can never confuse each other's
+ * findings while still sharing this vocabulary.
+ */
+export var DyFM_RequestSafetyFinding_Type;
+(function (DyFM_RequestSafetyFinding_Type) {
+    /** A key matched the caller's forbidden-key set (after normalization). */
+    DyFM_RequestSafetyFinding_Type["forbiddenKey"] = "forbidden-key";
+    /** A string value matched one of the caller's sensitive-value patterns. */
+    DyFM_RequestSafetyFinding_Type["sensitiveValue"] = "sensitive-value";
+    /** A string value matched one of the caller's unsupported-capability patterns. */
+    DyFM_RequestSafetyFinding_Type["unsupportedCapability"] = "unsupported-capability";
+    /** A caller-planted canary was found — proof that a rejected value reached the boundary. */
+    DyFM_RequestSafetyFinding_Type["canary"] = "canary";
+    /** The graph contains a cycle. */
+    DyFM_RequestSafetyFinding_Type["cycle"] = "cycle";
+    /** Nesting exceeded the caller's depth budget. */
+    DyFM_RequestSafetyFinding_Type["depthBudget"] = "depth-budget";
+    /** The node count exceeded the caller's budget. */
+    DyFM_RequestSafetyFinding_Type["nodeBudget"] = "node-budget";
+    /** A string exceeded the caller's length budget. */
+    DyFM_RequestSafetyFinding_Type["stringBudget"] = "string-budget";
+    /** A property is defined by an accessor (getter/setter) — reading it could execute caller code. */
+    DyFM_RequestSafetyFinding_Type["accessor"] = "accessor";
+    /** An object's prototype is neither `Object.prototype` nor `null`. */
+    DyFM_RequestSafetyFinding_Type["unsupportedPrototype"] = "unsupported-prototype";
+    /** A value is of a type the contract does not carry (function, symbol, bigint, class instance…). */
+    DyFM_RequestSafetyFinding_Type["unsupportedValueType"] = "unsupported-value-type";
+    /** The policy itself is invalid — fail-closed, the input is never inspected. */
+    DyFM_RequestSafetyFinding_Type["invalidPolicy"] = "invalid-policy";
+    /** Reflection failed; no exception message, input fragment or stack is returned. */
+    DyFM_RequestSafetyFinding_Type["inspectionFailure"] = "inspection-failure";
+})(DyFM_RequestSafetyFinding_Type || (DyFM_RequestSafetyFinding_Type = {}));

package/build-esm/_modules/request-safety/_models/request-safety.interface.js

@@ -0,0 +1 @@
+export {};

package/build-esm/_modules/request-safety/index.js

@@ -0,0 +1,3 @@
+export * from './_collections/request-safety-inspector.util';
+export * from './_enums/request-safety-finding.type-enum';
+export * from './_models/request-safety.interface';

package/build-esm/_modules/sandbox-runtime/_collections/zero-egress-receipt.util.js

@@ -0,0 +1,154 @@
+import { DyFM_ZeroEgressOutcome_Type } from '../_enums/zero-egress-outcome.type-enum';
+import { DyFM_zeroEgressResultCode } from './zero-egress-result-code.const';
+const dyfm_exactReceiptKeys = 'code,contractVersion,elapsedMs,outcome,outputBytes';
+/** Determines whether an unknown value is a non-array object with string-addressable fields. */
+function dyfm_isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Compares all own string keys, including non-enumerable keys, with the exact receipt shape. */
+function dyfm_hasExactReceiptKeys(value) {
+    const names = [];
+    for (const key of Reflect.ownKeys(value)) {
+        if (typeof key !== 'string') {
+            return false;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !descriptor.enumerable || !Object.hasOwn(descriptor, 'value')) {
+            return false;
+        }
+        names.push(key);
+    }
+    return names.sort().join(',') === dyfm_exactReceiptKeys
+        && Object.keys(value).sort().join(',') === dyfm_exactReceiptKeys;
+}
+/** Closed, immutable result-code registry indexed by its only valid terminal outcome. */
+export const DyFM_zeroEgressResultCodesByOutcome = Object.freeze({
+    [DyFM_ZeroEgressOutcome_Type.completed]: Object.freeze([
+        DyFM_zeroEgressResultCode.completed,
+    ]),
+    [DyFM_ZeroEgressOutcome_Type.cancelled]: Object.freeze([
+        DyFM_zeroEgressResultCode.cancelled,
+        DyFM_zeroEgressResultCode.cancelFallback,
+    ]),
+    [DyFM_ZeroEgressOutcome_Type.timedOut]: Object.freeze([
+        DyFM_zeroEgressResultCode.timeout,
+        DyFM_zeroEgressResultCode.hostTimeout,
+    ]),
+    [DyFM_ZeroEgressOutcome_Type.outputLimitExceeded]: Object.freeze([
+        DyFM_zeroEgressResultCode.outputLimit,
+    ]),
+    [DyFM_ZeroEgressOutcome_Type.integrityRejected]: Object.freeze([
+        DyFM_zeroEgressResultCode.artifactIntegrity,
+    ]),
+    [DyFM_ZeroEgressOutcome_Type.workerRejected]: Object.freeze([
+        DyFM_zeroEgressResultCode.workerError,
+        DyFM_zeroEgressResultCode.protocolInvalid,
+    ]),
+    [DyFM_ZeroEgressOutcome_Type.hostFailed]: Object.freeze([
+        DyFM_zeroEgressResultCode.admissionDenied,
+        DyFM_zeroEgressResultCode.admissionFailed,
+        DyFM_zeroEgressResultCode.artifactBudgetInvalid,
+        DyFM_zeroEgressResultCode.artifactInvalid,
+        DyFM_zeroEgressResultCode.artifactLimit,
+        DyFM_zeroEgressResultCode.bootstrapFailed,
+        DyFM_zeroEgressResultCode.bootstrapLoadFailed,
+        DyFM_zeroEgressResultCode.bootstrapUrlRequired,
+        DyFM_zeroEgressResultCode.bootstrapUrlUntrusted,
+        DyFM_zeroEgressResultCode.browserRequired,
+        DyFM_zeroEgressResultCode.contractUnsupported,
+        DyFM_zeroEgressResultCode.epochInvalid,
+        DyFM_zeroEgressResultCode.inputBudgetInvalid,
+        DyFM_zeroEgressResultCode.inputInvalid,
+        DyFM_zeroEgressResultCode.inputLimit,
+        DyFM_zeroEgressResultCode.integrityUnavailable,
+        DyFM_zeroEgressResultCode.messageInvalid,
+        DyFM_zeroEgressResultCode.outputBudgetInvalid,
+        DyFM_zeroEgressResultCode.randomSeedInvalid,
+        DyFM_zeroEgressResultCode.readyReplayed,
+        DyFM_zeroEgressResultCode.responseInvalid,
+        DyFM_zeroEgressResultCode.runAlreadyActive,
+        DyFM_zeroEgressResultCode.runIdInvalid,
+        DyFM_zeroEgressResultCode.timeoutInvalid,
+    ]),
+});
+const dyfm_allResultCodes = new Set(Object.values(DyFM_zeroEgressResultCodesByOutcome).flat());
+/** Strict cross-runtime validation and content-free projection for zero-egress terminal evidence. */
+export class DyFM_ZeroEgressReceipt_Util {
+    /** Narrows an untrusted value to one closed terminal outcome. */
+    static isOutcome(value) {
+        switch (value) {
+            case DyFM_ZeroEgressOutcome_Type.completed:
+            case DyFM_ZeroEgressOutcome_Type.cancelled:
+            case DyFM_ZeroEgressOutcome_Type.timedOut:
+            case DyFM_ZeroEgressOutcome_Type.outputLimitExceeded:
+            case DyFM_ZeroEgressOutcome_Type.integrityRejected:
+            case DyFM_ZeroEgressOutcome_Type.workerRejected:
+            case DyFM_ZeroEgressOutcome_Type.hostFailed:
+                return true;
+            default:
+                return false;
+        }
+    }
+    /** Narrows an untrusted value to one closed runtime result code. */
+    static isResultCode(value) {
+        return typeof value === 'string' && dyfm_allResultCodes.has(value);
+    }
+    /** Validates that a result code belongs to exactly the supplied terminal outcome. */
+    static isOutcomeCodePair(outcome, code) {
+        return this.isOutcome(outcome)
+            && this.isResultCode(code)
+            && DyFM_zeroEgressResultCodesByOutcome[outcome].includes(code);
+    }
+    /** Validates and copies an exact receipt without reflecting any rejected input. */
+    static validate(value) {
+        try {
+            if (!dyfm_isRecord(value)
+                || !dyfm_hasExactReceiptKeys(value)) {
+                return this.invalid();
+            }
+            const candidate = value;
+            if (candidate.contractVersion !== 'dyfm-zero-egress-receipt/1'
+                || !this.isOutcome(candidate.outcome)
+                || !this.isResultCode(candidate.code)
+                || !this.isOutcomeCodePair(candidate.outcome, candidate.code)
+                || !this.isDuration(candidate.elapsedMs)
+                || !this.isByteCount(candidate.outputBytes)
+                || (candidate.outcome !== DyFM_ZeroEgressOutcome_Type.completed
+                    && candidate.outputBytes !== 0)) {
+                return this.invalid();
+            }
+            const receipt = Object.freeze({
+                contractVersion: 'dyfm-zero-egress-receipt/1',
+                outcome: candidate.outcome,
+                code: candidate.code,
+                elapsedMs: candidate.elapsedMs,
+                outputBytes: candidate.outputBytes,
+            });
+            return Object.freeze({
+                contractVersion: 'dyfm-zero-egress-receipt-validation/1',
+                valid: true,
+                code: 'DYFM|ZERO_EGRESS_RECEIPT|VALID',
+                receipt: receipt,
+            });
+        }
+        catch {
+            return this.invalid();
+        }
+    }
+    static isDuration(value) {
+        return typeof value === 'number'
+            && Number.isFinite(value)
+            && value >= 0
+            && value <= Number.MAX_SAFE_INTEGER;
+    }
+    static isByteCount(value) {
+        return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+    }
+    static invalid() {
+        return Object.freeze({
+            contractVersion: 'dyfm-zero-egress-receipt-validation/1',
+            valid: false,
+            code: 'DYFM|ZERO_EGRESS_RECEIPT|INVALID',
+        });
+    }
+}

package/build-esm/_modules/sandbox-runtime/_collections/zero-egress-result-code.const.js

@@ -0,0 +1,36 @@
+/** Closed runtime values shared by browser hosts, servers, and persisted receipt consumers. */
+export const DyFM_zeroEgressResultCode = Object.freeze({
+    artifactBudgetInvalid: 'DYNX|SANDBOX|ARTIFACT_BUDGET_INVALID',
+    artifactIntegrity: 'DYNX|SANDBOX|ARTIFACT_INTEGRITY',
+    artifactInvalid: 'DYNX|SANDBOX|ARTIFACT_INVALID',
+    artifactLimit: 'DYNX|SANDBOX|ARTIFACT_LIMIT',
+    admissionDenied: 'DYNX|SANDBOX|ADMISSION_DENIED',
+    admissionFailed: 'DYNX|SANDBOX|ADMISSION_FAILED',
+    bootstrapFailed: 'DYNX|SANDBOX|BOOTSTRAP_FAILED',
+    bootstrapLoadFailed: 'DYNX|SANDBOX|BOOTSTRAP_LOAD_FAILED',
+    bootstrapUrlRequired: 'DYNX|SANDBOX|BOOTSTRAP_URL_REQUIRED',
+    bootstrapUrlUntrusted: 'DYNX|SANDBOX|BOOTSTRAP_URL_UNTRUSTED',
+    browserRequired: 'DYNX|SANDBOX|BROWSER_REQUIRED',
+    cancelFallback: 'DYNX|SANDBOX|CANCEL_FALLBACK',
+    cancelled: 'DYNX|SANDBOX|CANCELLED',
+    completed: 'DYNX|SANDBOX|COMPLETED',
+    contractUnsupported: 'DYNX|SANDBOX|CONTRACT_UNSUPPORTED',
+    epochInvalid: 'DYNX|SANDBOX|EPOCH_INVALID',
+    hostTimeout: 'DYNX|SANDBOX|HOST_TIMEOUT',
+    inputBudgetInvalid: 'DYNX|SANDBOX|INPUT_BUDGET_INVALID',
+    inputInvalid: 'DYNX|SANDBOX|INPUT_INVALID',
+    inputLimit: 'DYNX|SANDBOX|INPUT_LIMIT',
+    integrityUnavailable: 'DYNX|SANDBOX|INTEGRITY_UNAVAILABLE',
+    messageInvalid: 'DYNX|SANDBOX|MESSAGE_INVALID',
+    outputBudgetInvalid: 'DYNX|SANDBOX|OUTPUT_BUDGET_INVALID',
+    outputLimit: 'DYNX|SANDBOX|OUTPUT_LIMIT',
+    protocolInvalid: 'DYNX|SANDBOX|PROTOCOL_INVALID',
+    randomSeedInvalid: 'DYNX|SANDBOX|RANDOM_SEED_INVALID',
+    readyReplayed: 'DYNX|SANDBOX|READY_REPLAYED',
+    responseInvalid: 'DYNX|SANDBOX|RESPONSE_INVALID',
+    runAlreadyActive: 'DYNX|SANDBOX|RUN_ALREADY_ACTIVE',
+    runIdInvalid: 'DYNX|SANDBOX|RUN_ID_INVALID',
+    timeout: 'DYNX|SANDBOX|TIMEOUT',
+    timeoutInvalid: 'DYNX|SANDBOX|TIMEOUT_INVALID',
+    workerError: 'DYNX|SANDBOX|WORKER_ERROR',
+});

package/build-esm/_modules/sandbox-runtime/_enums/zero-egress-outcome.type-enum.js

@@ -0,0 +1,11 @@
+/** Stable terminal outcomes shared by zero-egress sandbox hosts and their consumers. */
+export var DyFM_ZeroEgressOutcome_Type;
+(function (DyFM_ZeroEgressOutcome_Type) {
+    DyFM_ZeroEgressOutcome_Type["completed"] = "completed";
+    DyFM_ZeroEgressOutcome_Type["cancelled"] = "cancelled";
+    DyFM_ZeroEgressOutcome_Type["timedOut"] = "timed-out";
+    DyFM_ZeroEgressOutcome_Type["outputLimitExceeded"] = "output-limit-exceeded";
+    DyFM_ZeroEgressOutcome_Type["integrityRejected"] = "integrity-rejected";
+    DyFM_ZeroEgressOutcome_Type["workerRejected"] = "worker-rejected";
+    DyFM_ZeroEgressOutcome_Type["hostFailed"] = "host-failed";
+})(DyFM_ZeroEgressOutcome_Type || (DyFM_ZeroEgressOutcome_Type = {}));

package/build-esm/_modules/sandbox-runtime/_models/zero-egress-receipt.interface.js

@@ -0,0 +1 @@
+export {};

package/build-esm/_modules/sandbox-runtime/index.js

@@ -0,0 +1,4 @@
+export * from './_collections/zero-egress-receipt.util';
+export * from './_collections/zero-egress-result-code.const';
+export * from './_enums/zero-egress-outcome.type-enum';
+export * from './_models/zero-egress-receipt.interface';

package/build-esm/_modules/security/_collections/stored-secret.util.js

@@ -0,0 +1,68 @@
+import { DyFM_SECRET_PATTERNS, } from '../../../_collections/utils/secret-mask.util';
+import { DyFM_StoredSecret } from '../_models/stored-secret.control-model';
+/** Default reveal — az elso 4 + utolso 4 karakter (egysegben a secret-mask util default-javal). */
+const DEFAULT_REVEAL = { prefix: 4, suffix: 4 };
+/**
+ * A DyFM_StoredSecret masked-reszenek levezetese egy USER-SAJAT nyers secret-bol — ENCRYPT/DECRYPT
+ * NELKUL megjelenitheto azonosito-reszt allit elo (`<prefix>...<suffix>` + a detektalt `kind` +
+ * a `keyLength`). A nyers ertek titkositasa NEM itt tortenik (a host/auth adja a kulcsot); ez a
+ * util csak a lathato reszt szamolja, hogy a UI / a fogyasztok visszafejtes nelkul azonositsanak.
+ */
+export class DyFM_StoredSecret_Util {
+    /**
+     * A secret fajtajanak detektalasa a kanonikus `DyFM_SECRET_PATTERNS`-szel (egysegesitett a
+     * masking-util kind-jeivel, pl. 'openai-key', 'anthropic-key', 'github-pat'). Az elso illeszkedo
+     * kind, vagy undefined ha egyik sem ismeri fel.
+     */
+    static detectKind(rawSecret) {
+        if (!rawSecret) {
+            return undefined;
+        }
+        for (const pattern of DyFM_SECRET_PATTERNS) {
+            // a patternek global flag-esek (stateful lastIndex) — minden teszt elott nullazzuk
+            pattern.regex.lastIndex = 0;
+            if (pattern.regex.test(rawSecret)) {
+                pattern.regex.lastIndex = 0;
+                return pattern.kind;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * A decrypt-nelkul megjelenitheto preview levezetese. Tul rovid secret-nel (vagy 0/0 reveal-nel)
+     * nem reveal-junk semmit (kulonben az egesz secret osszetapadhatna) — ilyenkor tisztan opaque
+     * `...` preview. A `keyLength` ettol fuggetlenul mindig a nyers hossz.
+     */
+    static derivePreview(rawSecret, reveal = DEFAULT_REVEAL) {
+        const kind = this.detectKind(rawSecret);
+        const keyLength = rawSecret ? rawSecret.length : 0;
+        const p = Math.max(0, reveal.prefix);
+        const s = Math.max(0, reveal.suffix);
+        if (!rawSecret || (p === 0 && s === 0) || rawSecret.length <= p + s + 4) {
+            return { maskedPreview: '...', keyLength: keyLength, kind: kind };
+        }
+        const head = rawSecret.slice(0, p);
+        const tail = rawSecret.slice(rawSecret.length - s);
+        return {
+            maskedPreview: `${head}...${tail}`,
+            keyLength: keyLength,
+            kind: kind,
+        };
+    }
+    /**
+     * Egy DyFM_StoredSecret osszeallitasa a USER-SAJAT nyers secret-bol — a masked-reszt levezeti,
+     * az `encryptedValue`-t a HIVO adja (a host/auth titkositja a `FDP_PRIVATE_API_KEY_CRYPT_KEY`-jel;
+     * a nyers ertek itt csak a preview-levezeteshez kell, NEM tarolodik el nyersen).
+     */
+    static build(set) {
+        const preview = this.derivePreview(set.rawSecret, set.reveal ?? DEFAULT_REVEAL);
+        return new DyFM_StoredSecret({
+            label: set.label,
+            kind: preview.kind,
+            maskedPreview: preview.maskedPreview,
+            keyLength: preview.keyLength,
+            encryptedValue: set.encryptedValue,
+            isActive: true,
+        });
+    }
+}