arkgate 4.8.24 → 4.8.25

package/bin/lib/ark-order-invariants.mjs

@@ -1,388 +0,0 @@
-/**
- * GENERATED FILE — do not edit by hand.
- *
- * Canonical algorithm: src/domain/arkOrderInvariants.ts
- * Regenerate: node scripts/generate-cli-pure.mjs
- * Drift check: node scripts/generate-cli-pure.mjs --check
- *
- * Pure CLI helper (bin/lib/ark-order-invariants.mjs). Zero Node I/O.
- */
-
-import { ArkOrderError } from './ark-order-error.mjs';
-import { CAPACITY_OPS, DEFAULT_MAX_XI_KEYS, XI_TTL_KEY_RE } from './ark-order-types.mjs';
-import { deterministicHash, stableSerialize } from './stable-hash.mjs';
-export { DEFAULT_MAX_XI_KEYS };
-/** D7: consumer still owns handlers — this only names the travel verb. */
-export function ingestTravelAction(residual) {
-    if (residual.kind === 'absorb')
-        return 'send';
-    if (residual.kind === 'escalate_up' && residual.target === 'human')
-        return 'raises';
-    return 'none';
-}
-const FORBIDDEN_PLANE_METHODS = ['update', 'patch', 'set', 'mutate'];
-export function isForbiddenPlaneMethod(name) {
-    return FORBIDDEN_PLANE_METHODS.includes(name);
-}
-function isPrimitive(value) {
-    return (value === null ||
-        typeof value === 'string' ||
-        (typeof value === 'number' && Number.isFinite(value)) ||
-        typeof value === 'boolean');
-}
-export function freezeRecord(input, label) {
-    const keys = Object.keys(input);
-    if (keys.length === 0 && label === 'ξ') {
-        throw new ArkOrderError('ARKORDER_EMPTY_XI', 'ξ must name at least one slow mode');
-    }
-    const out = {};
-    for (const key of keys.sort()) {
-        const value = input[key];
-        if (typeof value === 'number' && !Number.isFinite(value)) {
-            // JSON (and so the hash) turns NaN/±Infinity into null: no stable identity.
-            throw new ArkOrderError('ARKORDER_NESTED_XI', `${label} key ${JSON.stringify(key)} is a non-finite number (NaN/±Infinity has no stable identity)`);
-        }
-        if (!isPrimitive(value)) {
-            throw new ArkOrderError('ARKORDER_NESTED_XI', `${label} key ${JSON.stringify(key)} is not a slow primitive (nested values are microstate)`);
-        }
-        out[key] = Object.is(value, -0) ? 0 : value;
-    }
-    return Object.freeze(out);
-}
-export function assertXiKeyCap(xi, maxXiKeys) {
-    const n = Object.keys(xi).length;
-    if (n === 0) {
-        throw new ArkOrderError('ARKORDER_EMPTY_XI', 'ξ must name at least one slow mode');
-    }
-    if (n > maxXiKeys) {
-        throw new ArkOrderError('ARKORDER_TOO_MANY_PARAMS', `ξ has ${n} keys; maxXiKeys is ${maxXiKeys} (Haken: few slow modes)`);
-    }
-}
-export function assertXiSchema(xi, schema) {
-    if (!schema)
-        return;
-    const properties = schema.properties ?? {};
-    const additional = schema.additionalProperties !== false ? true : false;
-    for (const key of Object.keys(xi)) {
-        const prop = properties[key];
-        if (!prop) {
-            if (!additional) {
-                throw new ArkOrderError('ARKORDER_SCHEMA', `ξ key ${JSON.stringify(key)} is not in xiSchema.properties`);
-            }
-            continue;
-        }
-        if (prop.enum && !prop.enum.some((allowed) => allowed === xi[key])) {
-            throw new ArkOrderError('ARKORDER_SCHEMA', `ξ key ${JSON.stringify(key)} value is not in enum`);
-        }
-        if (prop.type === 'null' && xi[key] !== null) {
-            throw new ArkOrderError('ARKORDER_SCHEMA', `ξ key ${JSON.stringify(key)} must be null`);
-        }
-        if (prop.type && prop.type !== 'null' && typeof xi[key] !== prop.type) {
-            throw new ArkOrderError('ARKORDER_SCHEMA', `ξ key ${JSON.stringify(key)} must be ${prop.type}`);
-        }
-    }
-}
-function catalogDigestFor(xi, catalogDigest) {
-    if (typeof catalogDigest !== 'string')
-        return undefined;
-    if (!Object.prototype.hasOwnProperty.call(xi, 'catalogReleaseId'))
-        return undefined;
-    return catalogDigest;
-}
-export function hashReleasePayload(xi, sigma, catalogDigest) {
-    const digest = catalogDigestFor(xi, catalogDigest);
-    if (digest !== undefined)
-        return deterministicHash(stableSerialize({ xi, sigma, catalogDigest: digest }));
-    return deterministicHash(stableSerialize({ xi, sigma }));
-}
-export function hashXiIdentity(xi, catalogDigest) {
-    const digest = catalogDigestFor(xi, catalogDigest);
-    if (digest !== undefined)
-        return deterministicHash(stableSerialize({ xi, catalogDigest: digest }));
-    return deterministicHash(stableSerialize({ xi }));
-}
-export function hashSigmaIdentity(sigma) {
-    return deterministicHash(stableSerialize({ sigma }));
-}
-export function xiRecordsEqual(left, right) {
-    return stableSerialize(left) === stableSerialize(right);
-}
-/** D1: after the first freeze, a later release() may not change ξ. */
-export function assertUnvalvedRelease(current, nextXi) {
-    if (!current)
-        return;
-    if (xiRecordsEqual(current.xi, nextXi))
-        return;
-    throw new ArkOrderError('ARKORDER_UNVALVED_RELEASE', 'ξ is frozen; change the pattern with proposeRelease then apply(ProposeResult)');
-}
-export function createFrozenRelease(input) {
-    assertXiKeyCap(input.xi, input.maxXiKeys);
-    const xi = freezeRecord(input.xi, 'ξ');
-    assertXiHasNoTtl(xi);
-    assertXiSchema(xi, input.xiSchema);
-    const sigma = freezeRecord(input.sigma ?? {}, 'σ');
-    const release = Object.freeze({
-        version: input.version,
-        hash: hashReleasePayload(xi, sigma, input.catalogDigest),
-        xiHash: hashXiIdentity(xi, input.catalogDigest),
-        sigmaHash: hashSigmaIdentity(sigma),
-        xi,
-        sigma,
-        releasedAt: input.now,
-    });
-    return release;
-}
-/** D2: refresh σ without minting a pattern. xiHash must not change. */
-export function refreshSigmaRecord(input) {
-    const sigma = freezeRecord(input.sigma, 'σ');
-    return Object.freeze({
-        version: input.current.version,
-        hash: hashReleasePayload(input.current.xi, sigma, input.catalogDigest),
-        xiHash: input.current.xiHash,
-        sigmaHash: hashSigmaIdentity(sigma),
-        xi: input.current.xi,
-        sigma,
-        releasedAt: input.now,
-    });
-}
-export function assertXiHasNoTtl(xi) {
-    for (const key of Object.keys(xi)) {
-        if (XI_TTL_KEY_RE.test(key)) {
-            throw new ArkOrderError('ARKORDER_XI_TTL', `ξ key ${JSON.stringify(key)} is a freshness field; TTL belongs on σ, never on ξ`);
-        }
-    }
-}
-export function assertInformationBudget(projection, budget) {
-    if (!budget || budget.cannotObserve.length === 0)
-        return;
-    const denied = new Set(budget.cannotObserve);
-    for (const kind of projection.allowedKinds) {
-        if (denied.has(kind)) {
-            throw new ArkOrderError('ARKORDER_INFORMATION_BUDGET', `projection allows ${JSON.stringify(kind)}; informationBudget.cannotObserve forbids it`);
-        }
-    }
-}
-/**
- * σ freshness. A numeric σ.freshUntil is honored on its own and wins over the age
- * check; otherwise `maxAgeMs` (sigmaMaxAgeMs) bounds the age from σ.releasedAt or
- * the Release freeze time. Neither set means σ never goes stale.
- */
-export function assertSigmaFresh(input) {
-    const until = input.sigma.freshUntil;
-    if (typeof until === 'number') {
-        if (input.now > until) {
-            throw new ArkOrderError('ARKORDER_STALE_SIGMA', 'σ freshUntil has elapsed; ξ does not TTL');
-        }
-        return;
-    }
-    if (input.maxAgeMs === undefined)
-        return;
-    const origin = typeof input.sigma.releasedAt === 'number' ? input.sigma.releasedAt : input.releasedAt;
-    if (typeof origin === 'number' && input.now - origin > input.maxAgeMs) {
-        throw new ArkOrderError('ARKORDER_STALE_SIGMA', 'σ is older than sigmaMaxAgeMs; ξ does not TTL');
-    }
-}
-export function fieldEventIdentity(event) {
-    return deterministicHash(stableSerialize({ kind: event.kind, payload: event.payload ?? null }));
-}
-function bindResidual(event, xiHash) {
-    return { event, xiHash, eventId: fieldEventIdentity(event) };
-}
-const CAPACITY_OP_SET = new Set(CAPACITY_OPS);
-function isCapacityOp(value) {
-    return typeof value === 'string' && CAPACITY_OP_SET.has(value);
-}
-function numericLeaf(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
-function compareCapacity(left, op, right) {
-    if (op === 'lte')
-        return left <= right;
-    if (op === 'lt')
-        return left < right;
-    if (op === 'gte')
-        return left >= right;
-    return left > right;
-}
-function packHasFunction(value) {
-    if (typeof value === 'function')
-        return true;
-    if (value === null || typeof value !== 'object')
-        return false;
-    if (Array.isArray(value))
-        return value.some(packHasFunction);
-    return Object.values(value).some(packHasFunction);
-}
-function evaluateCapacity(event, sigma, pack) {
-    const rows = pack.capacity ?? [];
-    for (const row of rows) {
-        if (packHasFunction(row) || !isCapacityOp(row.op))
-            return 'pack';
-        if (row.kind !== event.kind)
-            continue;
-        const payload = event.payload && typeof event.payload === 'object' && !Array.isArray(event.payload)
-            ? numericLeaf(event.payload[row.payloadKey])
-            : undefined;
-        const limit = numericLeaf(sigma[row.sigmaKey]);
-        if (payload === undefined || limit === undefined)
-            return 'pack';
-        if (!compareCapacity(payload, row.op, limit))
-            return 'capacity';
-    }
-    return 'ok';
-}
-export function classifyIngest(projection, event, packs = [], xiHash = '', sigma = Object.freeze({})) {
-    const kind = event.kind;
-    const bound = bindResidual(event, xiHash);
-    for (const pack of packs) {
-        if (packHasFunction(pack.capacity) || packHasFunction(pack.escalateKinds)) {
-            return {
-                ...bound,
-                kind: 'hold',
-                reasonCode: 'pack',
-                reason: `pack ${pack.id} is not data-only; user predicates are forbidden`,
-            };
-        }
-        if (pack.escalateKinds?.includes(kind)) {
-            const target = pack.escalateTarget ?? 'human';
-            return {
-                ...bound,
-                kind: 'escalate_up',
-                reasonCode: 'pack',
-                reason: `pack ${pack.id} slaves kind ${JSON.stringify(kind)} to a pattern change`,
-                target,
-            };
-        }
-    }
-    if (!projection.allowedKinds.includes(kind)) {
-        return {
-            ...bound,
-            kind: 'escalate_up',
-            reasonCode: 'not-in-pattern',
-            reason: `kind ${JSON.stringify(kind)} is not allowed by h(ξ); field cannot rewrite the pattern`,
-            target: 'human',
-        };
-    }
-    for (const pack of packs) {
-        const cap = evaluateCapacity(event, sigma, pack);
-        if (cap === 'ok')
-            continue;
-        return {
-            ...bound,
-            kind: 'hold',
-            reasonCode: cap,
-            reason: cap === 'capacity'
-                ? `pack ${pack.id} capacity ${JSON.stringify(event.kind)} does not hold`
-                : `pack ${pack.id} capacity is not numeric data`,
-        };
-    }
-    return { ...bound, kind: 'absorb' };
-}
-export function blastRadiusOf(previous, next) {
-    const prev = new Set(previous.allowedKinds);
-    const nxt = new Set(next.allowedKinds);
-    const blast = new Set();
-    for (const kind of prev) {
-        if (!nxt.has(kind))
-            blast.add(kind);
-    }
-    for (const kind of nxt) {
-        if (!prev.has(kind))
-            blast.add(kind);
-    }
-    for (const item of next.invalidated)
-        blast.add(item);
-    return {
-        blastRadius: [...blast].sort(),
-        invalidations: [...next.invalidated].sort(),
-    };
-}
-export function proposePatternChange(input) {
-    const merged = { ...input.current.xi };
-    for (const [key, value] of Object.entries(input.delta)) {
-        if (value === undefined) {
-            delete merged[key];
-            continue;
-        }
-        merged[key] = value;
-    }
-    const candidate = createFrozenRelease({
-        xi: merged,
-        sigma: { ...input.current.sigma },
-        version: input.current.version + 1,
-        now: input.now,
-        maxXiKeys: input.maxXiKeys,
-        xiSchema: input.xiSchema,
-        catalogDigest: input.catalogDigest,
-    });
-    if (candidate.hash === input.current.hash) {
-        throw new ArkOrderError('ARKORDER_EMPTY_BLAST', 'delta does not change ξ; that is not a pattern change');
-    }
-    const previous = input.projector(input.current, input.current.sigma);
-    const next = input.projector(candidate, candidate.sigma);
-    // A pattern the budget denies is never offered for review.
-    assertInformationBudget(next, input.informationBudget);
-    const { blastRadius, invalidations } = blastRadiusOf(previous, next);
-    if (blastRadius.length === 0) {
-        throw new ArkOrderError('ARKORDER_EMPTY_BLAST', 'pattern change has empty blast radius; that key is not an order parameter');
-    }
-    return {
-        nextXi: candidate.xi,
-        blastRadius,
-        invalidations,
-        baseXiHash: input.current.xiHash,
-        baseVersion: input.current.version,
-    };
-}
-function sameSortedList(left, right) {
-    if (!Array.isArray(left) || left.length !== right.length)
-        return false;
-    const sorted = [...left].map(String).sort();
-    return sorted.every((item, index) => item === right[index]);
-}
-function staleProposal(detail) {
-    return new ArkOrderError('ARKORDER_STALE_PROPOSAL', `${detail}; re-run proposeRelease against the current Release and review the new blast radius`);
-}
-/**
- * D1 valve: freeze ProposeResult.nextXi. The proposal must be bound to the current
- * Release (baseXiHash + baseVersion) and its reviewed blastRadius / invalidations must
- * equal the transition actually committed — otherwise ARKORDER_STALE_PROPOSAL.
- * Empty blast still fails; a pattern the information budget denies never persists.
- */
-export function applyProposedRelease(input) {
-    const proposal = input.proposal;
-    if (!proposal ||
-        typeof proposal !== 'object' ||
-        !proposal.nextXi ||
-        typeof proposal.nextXi !== 'object') {
-        throw staleProposal('apply() requires a ProposeResult from proposeRelease');
-    }
-    if (proposal.baseXiHash !== input.current.xiHash ||
-        proposal.baseVersion !== input.current.version) {
-        throw staleProposal(`proposal was computed against a different Release (base v${String(proposal.baseVersion)}, current v${input.current.version})`);
-    }
-    const candidate = createFrozenRelease({
-        xi: { ...input.proposal.nextXi },
-        sigma: { ...input.current.sigma },
-        version: input.current.version + 1,
-        now: input.now,
-        maxXiKeys: input.maxXiKeys,
-        xiSchema: input.xiSchema,
-        catalogDigest: input.catalogDigest,
-    });
-    if (xiRecordsEqual(candidate.xi, input.current.xi)) {
-        throw new ArkOrderError('ARKORDER_EMPTY_BLAST', 'delta does not change ξ; that is not a pattern change');
-    }
-    const previous = input.projector(input.current, input.current.sigma);
-    const next = input.projector(candidate, candidate.sigma);
-    assertInformationBudget(next, input.informationBudget);
-    const { blastRadius, invalidations } = blastRadiusOf(previous, next);
-    if (blastRadius.length === 0) {
-        throw new ArkOrderError('ARKORDER_EMPTY_BLAST', 'pattern change has empty blast radius; that key is not an order parameter');
-    }
-    if (!sameSortedList(proposal.blastRadius, blastRadius) ||
-        !sameSortedList(proposal.invalidations, invalidations)) {
-        throw staleProposal('the reviewed blast radius is not the transition apply() would commit');
-    }
-    return candidate;
-}

package/bin/lib/stable-hash.mjs

@@ -1,90 +0,0 @@
-/**
- * GENERATED FILE — do not edit by hand.
- *
- * Canonical algorithm: src/domain/stableHash.ts
- * Regenerate: node scripts/generate-cli-pure.mjs
- * Drift check: node scripts/generate-cli-pure.mjs --check
- *
- * Pure CLI helper (bin/lib/stable-hash.mjs). Zero Node I/O.
- */
-
-/** Stable FNV-1a hash. Identity/fingerprint only — not a security primitive. */
-export function deterministicHash(value) {
-    let hash = 0x811c9dc5;
-    for (let index = 0; index < value.length; index += 1) {
-        hash ^= value.charCodeAt(index);
-        hash = Math.imul(hash, 0x01000193);
-    }
-    return `fnv1a-${(hash >>> 0).toString(16).padStart(8, '0')}`;
-}
-/** Serialize JSON-like values with sorted object keys for reproducible hashes. */
-export function stableSerialize(value) {
-    if (value === null || typeof value !== 'object')
-        return JSON.stringify(value);
-    if (Array.isArray(value))
-        return `[${value.map(stableSerialize).join(',')}]`;
-    const object = value;
-    return `{${Object.keys(object)
-        .sort()
-        .map((key) => `${JSON.stringify(key)}:${stableSerialize(object[key])}`)
-        .join(',')}}`;
-}
-function feedText(text, state) {
-    let hash = state.hash;
-    for (let index = 0; index < text.length; index += 1) {
-        hash ^= text.charCodeAt(index);
-        hash = Math.imul(hash, 0x01000193);
-    }
-    state.hash = hash;
-}
-function feedStable(value, state) {
-    if (Array.isArray(value)) {
-        feedText('[', state);
-        for (let index = 0; index < value.length; index += 1) {
-            if (index > 0)
-                feedText(',', state);
-            // `map` skips holes and `join` renders an undefined element as ''.
-            if (!(index in value))
-                continue;
-            const item = value[index];
-            if (item !== null && typeof item === 'object')
-                feedStable(item, state);
-            else {
-                const text = JSON.stringify(item);
-                if (text !== undefined)
-                    feedText(text, state);
-            }
-        }
-        feedText(']', state);
-        return;
-    }
-    const object = value;
-    const keys = Object.keys(object).sort();
-    feedText('{', state);
-    for (let index = 0; index < keys.length; index += 1) {
-        if (index > 0)
-            feedText(',', state);
-        const key = keys[index];
-        feedText(`${JSON.stringify(key)}:`, state);
-        const item = object[key];
-        // A template literal renders an undefined serialization as 'undefined'.
-        if (item !== null && typeof item === 'object')
-            feedStable(item, state);
-        else
-            feedText(`${JSON.stringify(item)}`, state);
-    }
-    feedText('}', state);
-}
-/**
- * `deterministicHash(stableSerialize(value))`, byte for byte, without building
- * the serialized text. A large fact set hashes without first materializing a
- * multi-megabyte string and every intermediate join.
- */
-export function stableHash(value) {
-    if (value === null || typeof value !== 'object') {
-        return deterministicHash(stableSerialize(value));
-    }
-    const state = { hash: 0x811c9dc5 };
-    feedStable(value, state);
-    return `fnv1a-${(state.hash >>> 0).toString(16).padStart(8, '0')}`;
-}