arkgate 4.8.22 → 4.8.24

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

@@ -9,8 +9,8 @@
  */
 
 import { ArkOrderError } from './ark-order-error.mjs';
-import { CAPACITY_OPS, DEFAULT_MAX_XI_KEYS } from './ark-order-types.mjs';
-import { deterministicHash, stableSerialize } from './stableHash';
+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) {
@@ -27,7 +27,7 @@ export function isForbiddenPlaneMethod(name) {
 function isPrimitive(value) {
     return (value === null ||
         typeof value === 'string' ||
-        typeof value === 'number' ||
+        (typeof value === 'number' && Number.isFinite(value)) ||
         typeof value === 'boolean');
 }
 export function freezeRecord(input, label) {
@@ -38,10 +38,14 @@ export function freezeRecord(input, label) {
     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] = value;
+        out[key] = Object.is(value, -0) ? 0 : value;
     }
     return Object.freeze(out);
 }
@@ -141,7 +145,6 @@ export function refreshSigmaRecord(input) {
         releasedAt: input.now,
     });
 }
-const XI_TTL_KEY_RE = /^(ttl|freshUntil|fresh_until|maxAge|max_age)$/i;
 export function assertXiHasNoTtl(xi) {
     for (const key of Object.keys(xi)) {
         if (XI_TTL_KEY_RE.test(key)) {
@@ -159,9 +162,12 @@ export function assertInformationBudget(projection, budget) {
         }
     }
 }
+/**
+ * σ 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) {
-    if (input.maxAgeMs === undefined)
-        return;
     const until = input.sigma.freshUntil;
     if (typeof until === 'number') {
         if (input.now > until) {
@@ -169,6 +175,8 @@ export function assertSigmaFresh(input) {
         }
         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');
@@ -312,6 +320,8 @@ export function proposePatternChange(input) {
     }
     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');
@@ -320,10 +330,37 @@ export function proposePatternChange(input) {
         nextXi: candidate.xi,
         blastRadius,
         invalidations,
+        baseXiHash: input.current.xiHash,
+        baseVersion: input.current.version,
     };
 }
-/** D1 valve: freeze ProposeResult.nextXi. Empty blast still fails. */
+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 },
@@ -338,9 +375,14 @@ export function applyProposedRelease(input) {
     }
     const previous = input.projector(input.current, input.current.sigma);
     const next = input.projector(candidate, candidate.sigma);
-    const { blastRadius } = blastRadiusOf(previous, next);
+    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/ark-order-sensors.mjs

@@ -8,105 +8,9 @@
  * Pure CLI helper (bin/lib/ark-order-sensors.mjs). Zero Node I/O.
  */
 
-import { extractArkOrderGenericUpdatesFromSource, extractArkOrderIngestWritesXiFromSource, extractArkOrderPlaneCallsFromSource, extractArkOrderReleaseKeyCountsFromSource, extractArkOrderXiFieldWritesFromSource, isArkOrderModuleSpecifier, } from './ark-order-facts.mjs';
+import { extractArkOrderBudgetLeaksFromSource, extractArkOrderGenericUpdatesFromSource, extractArkOrderIngestWritesXiFromSource, extractArkOrderModuleImportsFromSource, extractArkOrderPlaneCallsFromSource, extractArkOrderReleaseKeyCountsFromSource, extractArkOrderXiFieldWritesFromSource, extractArkOrderXiTtlKeysFromSource, arkOrderGlobToRegExp as globToRegExp, isArkOrderModuleSpecifier, } from './ark-order-facts.mjs';
 import { extraMergeTeethAllowed, } from './extra-merge-teeth.mjs';
 import { deterministicNextAction } from './remediation.mjs';
-/**
- * XIWRITE-001: same engine as `globToRegExp` in src/domain/layerMatch.ts.
- * Inlined so generate:cli-pure emits a self-contained bin/lib/ark-order-sensors.mjs
- * (layerMatch is derived to bin/ark-layer-match.mjs, not a bin/lib sibling).
- */
-const appliesToRegexpCache = new Map();
-function escapeAppliesToLiteral(ch) {
-    return /[.*+?^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
-}
-function normalizeAppliesToGlob(pattern) {
-    let out = '';
-    for (let i = 0; i < pattern.length; i += 1) {
-        const c = pattern[i];
-        if (c === '\\' && i + 1 < pattern.length) {
-            const next = pattern[i + 1];
-            if ('*?{}[],'.includes(next) || next === '\\') {
-                out += '\\' + next;
-                i += 1;
-                continue;
-            }
-            out += '/';
-            continue;
-        }
-        out += c;
-    }
-    return out;
-}
-function appliesToBracesBalanced(glob) {
-    let depth = 0;
-    for (let i = 0; i < glob.length; i += 1) {
-        const c = glob[i];
-        if (c === '\\') {
-            i += 1;
-            continue;
-        }
-        if (c === '{')
-            depth += 1;
-        else if (c === '}') {
-            depth -= 1;
-            if (depth < 0)
-                return false;
-        }
-    }
-    return depth === 0;
-}
-function globToRegExp(pattern) {
-    const cached = appliesToRegexpCache.get(pattern);
-    if (cached)
-        return cached;
-    const glob = normalizeAppliesToGlob(pattern);
-    const useBraces = appliesToBracesBalanced(glob);
-    let out = '';
-    let braceDepth = 0;
-    for (let i = 0; i < glob.length; i += 1) {
-        const c = glob[i];
-        if (c === '\\' && i + 1 < glob.length) {
-            out += escapeAppliesToLiteral(glob[i + 1]);
-            i += 1;
-        }
-        else if (c === '*') {
-            if (glob[i + 1] === '*') {
-                if (glob[i + 2] === '/') {
-                    out += '(?:.*/)?';
-                    i += 2;
-                }
-                else {
-                    out += '.*';
-                    i += 1;
-                }
-            }
-            else {
-                out += '[^/]*';
-            }
-        }
-        else if (c === '?') {
-            out += '[^/]';
-        }
-        else if (c === '{' && useBraces) {
-            out += '(?:';
-            braceDepth += 1;
-        }
-        else if (c === '}' && useBraces && braceDepth > 0) {
-            out += ')';
-            braceDepth -= 1;
-        }
-        else if (c === ',' && useBraces && braceDepth > 0) {
-            out += '|';
-        }
-        else {
-            out += escapeAppliesToLiteral(c);
-        }
-    }
-    const re = new RegExp(`^${out}$`);
-    appliesToRegexpCache.set(pattern, re);
-    return re;
-}
 export const ARKORDER_TIER1_SENSOR_IDS = [
     'arkorder-missing-plane',
     'arkorder-kernel-in-domain',
@@ -212,6 +116,12 @@ export function evaluateArkOrderSensors(input) {
     for (const ingest of input.ingestWritesXi ?? []) {
         findings.push(finding(extra, 'arkorder-ingest-writes-xi', ingest.file, ingest.line, 'ingest() result is assigned into a Release or ξ store; ingest may absorb or escalate, never mint a pattern.', undefined, teethAllowed));
     }
+    for (const ttl of input.xiTtlKeys ?? []) {
+        findings.push(finding(extra, 'arkorder-xi-ttl', ttl.file, ttl.line, `ξ key ${JSON.stringify(ttl.key)} is a freshness field; freshness belongs on σ (freshUntil), never on ξ.`, { target: ttl.key }, teethAllowed));
+    }
+    for (const leak of input.budgetLeaks ?? []) {
+        findings.push(finding(extra, 'arkorder-information-budget', leak.file, leak.line, `Projection allowedKinds lists ${JSON.stringify(leak.kind)}, which informationBudget.cannotObserve denies.`, { target: leak.kind }, teethAllowed));
+    }
     const managed = new Set(extra.managedLayers);
     for (const write of xiKeys.length === 0 ? [] : input.xiFieldWrites ?? []) {
         const fromLayer = input.layerForFile(write.file);
@@ -230,22 +140,39 @@ export function evaluateArkOrderEditorSensors(input) {
     if (!input.arkOrder)
         return [];
     const planeCalls = extractArkOrderPlaneCallsFromSource(input.file, input.source);
-    const genericUpdates = extractArkOrderGenericUpdatesFromSource(input.file, input.source);
+    const receivers = { planeRoots: input.arkOrder.planeRoots ?? [] };
+    const genericUpdates = extractArkOrderGenericUpdatesFromSource(input.file, input.source, receivers);
     const xiKeys = input.arkOrder.xiKeys ?? [];
+    // kernel-in-domain needs the file's own layer (name + intent prefixes) and the
+    // arkgate/order specifiers of this one source — the write-path twin of CI facts.
+    const layers = input.fromLayer
+        ? [
+            {
+                name: input.fromLayer,
+                patterns: [],
+                intentPrefixes: [...(input.intentPrefixes ?? [])],
+            },
+        ]
+        : [];
     return evaluateArkOrderSensors({
         arkOrder: input.arkOrder,
-        layers: [],
+        layers,
         planeCalls,
         genericUpdates,
         planeRootHits: [],
         xiFieldWrites: extractArkOrderXiFieldWritesFromSource(input.file, input.source, xiKeys),
         ingestWritesXi: extractArkOrderIngestWritesXiFromSource(input.file, input.source),
         releaseKeyCounts: extractArkOrderReleaseKeyCountsFromSource(input.file, input.source),
-        dependencies: [],
+        xiTtlKeys: extractArkOrderXiTtlKeysFromSource(input.file, input.source, receivers),
+        budgetLeaks: extractArkOrderBudgetLeaksFromSource(input.file, input.source),
+        dependencies: extractArkOrderModuleImportsFromSource(input.file, input.source),
         layerForFile: () => input.fromLayer,
+        ...(input.classification ? { classification: input.classification } : {}),
     }).findings.filter((item) => item.sensor === 'arkorder-generic-update' ||
         item.sensor === 'arkorder-kernel-in-domain' ||
         item.sensor === 'arkorder-xi-field-write' ||
         item.sensor === 'arkorder-ingest-writes-xi' ||
-        item.sensor === 'arkorder-too-many-params');
+        item.sensor === 'arkorder-too-many-params' ||
+        item.sensor === 'arkorder-xi-ttl' ||
+        item.sensor === 'arkorder-information-budget');
 }

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

@@ -9,6 +9,8 @@
  */
 
 export const DEFAULT_MAX_XI_KEYS = 7;
+/** ξ keys that name freshness. Freshness is σ, never ξ (runtime and static sensor share this). */
+export const XI_TTL_KEY_RE = /^(ttl|freshUntil|fresh_until|maxAge|max_age)$/i;
 export const INGEST_RESIDUAL_KINDS = ['absorb', 'escalate_up', 'hold'];
 export const INGEST_REASON_CODES = ['not-in-pattern', 'stale-sigma', 'pack', 'capacity'];
 export const CAPACITY_OPS = ['lte', 'lt', 'gte', 'gt'];

package/bin/lib/ark-run-doctor.mjs

@@ -9,6 +9,7 @@
  */
 
 import { composeMergePlanesHonesty, extraMergeTeethAllowed, isArkRunRuleId, } from './extra-merge-teeth.mjs';
+import { unresolvableLayerFlowLayers } from './source-policy.mjs';
 export const ARK_RUN_DOCTOR_SCHEMA_VERSION = '1.0';
 const RESIDUAL_RULE_CAP = 12;
 /** Compact / details — only when `arkRun` is on. Absence stays silent. */
@@ -47,6 +48,12 @@ function extraFromConfig(arkRun) {
  */
 export function summarizeArkRunSection(input = {}) {
     const extra = extraFromConfig(input.arkRun);
+    const layerFlowUnresolvable = extra.present && Array.isArray(input.layerFlow?.layers)
+        ? unresolvableLayerFlowLayers({
+            layers: input.layerFlow.layers,
+            rules: Array.isArray(input.layerFlow.rules) ? input.layerFlow.rules : [],
+        })
+        : [];
     const uniqueIds = extra.present ? uniqueArkRunRuleIds(input.findings) : [];
     const ruleIds = uniqueIds.slice(0, RESIDUAL_RULE_CAP);
     const residualCount = uniqueIds.length;
@@ -100,6 +107,7 @@ export function summarizeArkRunSection(input = {}) {
         failMergeWhen: mergePlanes.failMergeWhen,
         note,
         mergePlanes,
+        layerFlowUnresolvable,
     };
 }
 /** Thin status slice — counts only; residual null means unknown, not green. */
@@ -144,6 +152,12 @@ export function formatArkRunDoctorLines(section) {
     else {
         lines.push('Residual: none on this scan (not a score — green extras ≠ finished kernel wiring).');
     }
+    const unresolvable = Array.isArray(section.layerFlowUnresolvable)
+        ? section.layerFlowUnresolvable
+        : [];
+    if (unresolvable.length > 0) {
+        lines.push(`Runtime layer flow: ${unresolvable.join(', ')} name(s) in a deny rule but map to no intent (no intentPrefixes, not a canonical layer). A kernel from this config cannot enforce those rules — add intentPrefixes (ARKRUN_LAYER_FLOW_UNRESOLVABLE).`);
+    }
     if (section.failMergeWhen)
         lines.push(section.failMergeWhen);
     return lines;