arkgate 4.7.5 → 4.8.0

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

@@ -0,0 +1,18 @@
+/**
+ * GENERATED FILE — do not edit by hand.
+ *
+ * Canonical algorithm: src/domain/arkOrderError.ts
+ * Regenerate: node scripts/generate-cli-pure.mjs
+ * Drift check: node scripts/generate-cli-pure.mjs --check
+ *
+ * Pure CLI helper (bin/lib/ark-order-error.mjs). Zero Node I/O.
+ */
+
+export class ArkOrderError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'ArkOrderError';
+        this.code = code;
+    }
+}

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

@@ -0,0 +1,53 @@
+/**
+ * GENERATED FILE — do not edit by hand.
+ *
+ * Canonical algorithm: src/domain/arkOrderFacts.ts
+ * Regenerate: node scripts/generate-cli-pure.mjs
+ * Drift check: node scripts/generate-cli-pure.mjs --check
+ *
+ * Pure CLI helper (bin/lib/ark-order-facts.mjs). Zero Node I/O.
+ */
+
+export const ARKORDER_PLANE_FACTORY = 'createOrderPlane';
+export const ARKORDER_FORBIDDEN_METHODS = ['update', 'patch', 'set', 'mutate'];
+export function isArkOrderModuleSpecifier(specifier) {
+    return specifier === 'arkgate/order' || specifier.startsWith('arkgate/order/');
+}
+function lineAt(content, index) {
+    let line = 1;
+    for (let i = 0; i < index && i < content.length; i += 1) {
+        if (content[i] === '\n')
+            line += 1;
+    }
+    return line;
+}
+function stripCommentsPreservingLines(content) {
+    return content
+        .replace(/\/\*[\s\S]*?\*\//g, (block) => block.replace(/[^\n]/g, ' '))
+        .replace(/(^|[^:])\/\/.*$/gm, (line) => line.replace(/\/\/.*$/, (c) => ' '.repeat(c.length)));
+}
+export function extractArkOrderPlaneCallsFromSource(file, content) {
+    const source = stripCommentsPreservingLines(content);
+    const facts = [];
+    const re = /\bcreateOrderPlane\s*(?:<[^>]*>)?\s*\(/g;
+    let match;
+    while ((match = re.exec(source)) !== null) {
+        facts.push({ file, line: lineAt(content, match.index), callee: ARKORDER_PLANE_FACTORY });
+    }
+    return facts;
+}
+export function extractArkOrderGenericUpdatesFromSource(file, content) {
+    const source = stripCommentsPreservingLines(content);
+    const facts = [];
+    const re = /\.((?:update|patch|set|mutate))\s*\(/g;
+    let match;
+    while ((match = re.exec(source)) !== null) {
+        const method = match[1];
+        const before = source.slice(Math.max(0, match.index - 80), match.index);
+        if (!/\b(?:plane|orderPlane|order)\s*$/.test(before) && !/\bcreateOrderPlane\b/.test(source)) {
+            continue;
+        }
+        facts.push({ file, line: lineAt(content, match.index), method });
+    }
+    return facts;
+}

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

@@ -0,0 +1,160 @@
+/**
+ * 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 { DEFAULT_MAX_XI_KEYS } from './ark-order-types.mjs';
+import { deterministicHash, stableSerialize } from './stableHash';
+export { DEFAULT_MAX_XI_KEYS };
+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' ||
+        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 (!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;
+    }
+    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}`);
+        }
+    }
+}
+export function hashReleasePayload(xi, sigma) {
+    return deterministicHash(stableSerialize({ xi, sigma }));
+}
+export function createFrozenRelease(input) {
+    assertXiKeyCap(input.xi, input.maxXiKeys);
+    const xi = freezeRecord(input.xi, 'ξ');
+    assertXiSchema(xi, input.xiSchema);
+    const sigma = freezeRecord(input.sigma ?? {}, 'σ');
+    const release = Object.freeze({
+        version: input.version,
+        hash: hashReleasePayload(xi, sigma),
+        xi,
+        sigma,
+        releasedAt: input.now,
+    });
+    return release;
+}
+export function classifyIngest(projection, event, packs = []) {
+    const kind = event.kind;
+    for (const pack of packs) {
+        if (pack.escalateKinds?.includes(kind)) {
+            return {
+                kind: 'escalate',
+                event,
+                reason: `pack ${pack.id} slaves kind ${JSON.stringify(kind)} to a pattern change`,
+            };
+        }
+    }
+    if (projection.allowedKinds.includes(kind)) {
+        return { kind: 'absorb', event };
+    }
+    return {
+        kind: 'escalate',
+        event,
+        reason: `kind ${JSON.stringify(kind)} is not allowed by h(ξ); field cannot rewrite the pattern`,
+    };
+}
+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,
+    });
+    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);
+    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,
+    };
+}

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

@@ -0,0 +1,118 @@
+/**
+ * GENERATED FILE — do not edit by hand.
+ *
+ * Canonical algorithm: src/domain/arkOrderSensors.ts
+ * Regenerate: node scripts/generate-cli-pure.mjs
+ * Drift check: node scripts/generate-cli-pure.mjs --check
+ *
+ * Pure CLI helper (bin/lib/ark-order-sensors.mjs). Zero Node I/O.
+ */
+
+import { extractArkOrderGenericUpdatesFromSource, extractArkOrderPlaneCallsFromSource, isArkOrderModuleSpecifier, } from './ark-order-facts.mjs';
+import { extraMergeTeethAllowed, } from './extra-merge-teeth.mjs';
+import { deterministicNextAction } from './remediation.mjs';
+export const ARKORDER_TIER1_SENSOR_IDS = [
+    'arkorder-missing-plane',
+    'arkorder-kernel-in-domain',
+    'arkorder-generic-update',
+    'arkorder-too-many-params',
+    'arkorder-ingest-writes-xi',
+];
+export const ARKORDER_RULE_IDS = {
+    'arkorder-missing-plane': 'ARKORDER_MISSING_PLANE',
+    'arkorder-kernel-in-domain': 'ARKORDER_KERNEL_IN_DOMAIN',
+    'arkorder-generic-update': 'ARKORDER_GENERIC_UPDATE',
+    'arkorder-too-many-params': 'ARKORDER_TOO_MANY_PARAMS',
+    'arkorder-ingest-writes-xi': 'ARKORDER_INGEST_WRITES_XI',
+};
+function isDomainRoleLayer(layer, intentPrefixes = []) {
+    const name = layer.trim();
+    if (/^domain(?:model)?$/i.test(name) || /^domain(?=[A-Z_\-\s])/i.test(name))
+        return true;
+    return intentPrefixes.some((prefix) => {
+        const normalized = prefix.trim().replace(/\.+$/, '');
+        return normalized === 'Domain' || normalized.startsWith('Domain.');
+    });
+}
+function finding(extra, sensor, file, line, message, extras, teethAllowed) {
+    const failsStrict = extra.mode === 'enforced' && teethAllowed;
+    return {
+        ruleId: ARKORDER_RULE_IDS[sensor],
+        sensor,
+        message,
+        file,
+        line,
+        ...(extras?.fromLayer ? { fromLayer: extras.fromLayer } : {}),
+        ...(extras?.target ? { target: extras.target } : {}),
+        severity: failsStrict ? 'error' : 'warning',
+        failsStrict,
+        nextAction: deterministicNextAction({
+            ruleId: ARKORDER_RULE_IDS[sensor],
+            fromLayer: extras?.fromLayer,
+            target: extras?.target,
+        }),
+    };
+}
+export function evaluateArkOrderSensors(input) {
+    const extra = input.arkOrder;
+    if (!extra)
+        return { findings: [], completenessReasons: [] };
+    const teethAllowed = extraMergeTeethAllowed(input.classification);
+    const findings = [];
+    const roots = extra.planeRoots;
+    if (extra.mode === 'enforced' && roots.length === 0) {
+        findings.push(finding(extra, 'arkorder-missing-plane', 'ark.config.json', 1, 'ArkOrder planeRoots is empty; no createOrderPlane site is declared.', undefined, teethAllowed));
+    }
+    else {
+        const hitsByRoot = new Map();
+        for (const hit of input.planeRootHits) {
+            const list = hitsByRoot.get(hit.matchedRoot) ?? [];
+            list.push(hit);
+            hitsByRoot.set(hit.matchedRoot, list);
+        }
+        for (const pattern of roots) {
+            const matched = hitsByRoot.get(pattern) ?? [];
+            if (matched.length === 0) {
+                findings.push(finding(extra, 'arkorder-missing-plane', 'ark.config.json', 1, `ArkOrder plane root ${JSON.stringify(pattern)} matched no governed files and has no createOrderPlane factory.`, { target: pattern }, teethAllowed));
+                continue;
+            }
+            if (matched.some((hit) => hit.hasPlaneFactory))
+                continue;
+            findings.push(finding(extra, 'arkorder-missing-plane', matched[0].file, 1, `ArkOrder plane root ${JSON.stringify(pattern)} has no createOrderPlane factory.`, { target: pattern }, teethAllowed));
+        }
+    }
+    const prefixes = new Map(input.layers.map((layer) => [layer.name, layer.intentPrefixes ?? []]));
+    for (const dependency of input.dependencies) {
+        const specifier = dependency.specifier;
+        if (!specifier || !isArkOrderModuleSpecifier(specifier))
+            continue;
+        const fromLayer = input.layerForFile(dependency.from);
+        if (!fromLayer)
+            continue;
+        if (!isDomainRoleLayer(fromLayer, prefixes.get(fromLayer) ?? []))
+            continue;
+        findings.push(finding(extra, 'arkorder-kernel-in-domain', dependency.from, dependency.line, 'Domain-role layer imports arkgate/order; Domain stays plane-free.', { fromLayer, target: specifier }, teethAllowed));
+    }
+    for (const update of input.genericUpdates) {
+        findings.push(finding(extra, 'arkorder-generic-update', update.file, update.line, `Generic ${update.method}() on the order plane rewrites ξ; Haken forbids it.`, { target: update.method }, teethAllowed));
+    }
+    findings.sort((left, right) => left.file.localeCompare(right.file) ||
+        left.ruleId.localeCompare(right.ruleId) ||
+        left.line - right.line);
+    return { findings, completenessReasons: [] };
+}
+export function evaluateArkOrderEditorSensors(input) {
+    if (!input.arkOrder)
+        return [];
+    const planeCalls = extractArkOrderPlaneCallsFromSource(input.file, input.source);
+    const genericUpdates = extractArkOrderGenericUpdatesFromSource(input.file, input.source);
+    return evaluateArkOrderSensors({
+        arkOrder: input.arkOrder,
+        layers: [],
+        planeCalls,
+        genericUpdates,
+        planeRootHits: [],
+        dependencies: [],
+        layerForFile: () => input.fromLayer,
+    }).findings.filter((item) => item.sensor === 'arkorder-generic-update' || item.sensor === 'arkorder-kernel-in-domain');
+}

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

@@ -0,0 +1,11 @@
+/**
+ * GENERATED FILE — do not edit by hand.
+ *
+ * Canonical algorithm: src/domain/arkOrderTypes.ts
+ * Regenerate: node scripts/generate-cli-pure.mjs
+ * Drift check: node scripts/generate-cli-pure.mjs --check
+ *
+ * Pure CLI helper (bin/lib/ark-order-types.mjs). Zero Node I/O.
+ */
+
+export const DEFAULT_MAX_XI_KEYS = 7;

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

@@ -111,9 +111,9 @@ function dependKinds(kind) {
 }
 function evaluateMissingRoot(extra, hits, teethAllowed) {
     const out = [];
-    const roots = extra.compositionRoots;
+    const roots = extra.kernelRoots ?? extra.compositionRoots;
     if (roots.length === 0) {
-        out.push(finding(extra, 'arkrun-missing-root', 'ark.config.json', 1, 'ArkRun compositionRoots is empty; no createArkKernel factory site is declared.', undefined, teethAllowed));
+        out.push(finding(extra, 'arkrun-missing-root', 'ark.config.json', 1, 'ArkRun kernelRoots is empty; no createArkKernel factory site is declared.', undefined, teethAllowed));
         return out;
     }
     const hitsByRoot = new Map();
@@ -125,14 +125,14 @@ function evaluateMissingRoot(extra, hits, teethAllowed) {
     for (const pattern of roots) {
         const matched = [...(hitsByRoot.get(pattern) ?? [])].sort((left, right) => left.file.localeCompare(right.file));
         if (matched.length === 0) {
-            out.push(finding(extra, 'arkrun-missing-root', 'ark.config.json', 1, `ArkRun composition root ${JSON.stringify(pattern)} matched no governed files and has no createArkKernel factory.`, { target: pattern }, teethAllowed));
+            out.push(finding(extra, 'arkrun-missing-root', 'ark.config.json', 1, `ArkRun kernel root ${JSON.stringify(pattern)} matched no governed files and has no createArkKernel factory.`, { target: pattern }, teethAllowed));
             continue;
         }
         // Factory required in the root set, not in every glob hit.
         if (matched.some((hit) => hit.hasKernelFactory))
             continue;
         const first = matched[0];
-        out.push(finding(extra, 'arkrun-missing-root', first.file, 1, `ArkRun composition root ${JSON.stringify(pattern)} has no createArkKernel / createStrictArkKernel factory.`, { target: pattern }, teethAllowed));
+        out.push(finding(extra, 'arkrun-missing-root', first.file, 1, `ArkRun kernel root ${JSON.stringify(pattern)} has no createArkKernel / createStrictArkKernel factory.`, { target: pattern }, teethAllowed));
     }
     return out;
 }
@@ -162,6 +162,13 @@ function evaluateDirectNew(extra, layers, managedNews, hits, layerForFile, teeth
     for (const constructed of managedNews) {
         if (admittedFactories.has(constructed.file))
             continue;
+        const name = constructed.typeName;
+        if (extra.ignoreDirectNewForErrors !== false && (name.endsWith('Error') || name === 'Error')) {
+            continue;
+        }
+        if (name.endsWith('DTO') || name.endsWith('VO')) {
+            continue;
+        }
         const fromLayer = layerForFile(constructed.file);
         if (!fromLayer || !managed.has(fromLayer))
             continue;
@@ -279,7 +286,8 @@ function fileMatchesCompositionRoot(pattern, file) {
 function compositionRootHitsForSource(extra, file, source) {
     const hasFactory = extractArkRunKernelCallsFromSource(file, source).some((call) => call.kind === 'factory');
     const hits = [];
-    for (const pattern of extra.compositionRoots) {
+    const roots = extra.kernelRoots ?? extra.compositionRoots;
+    for (const pattern of roots) {
         if (!fileMatchesCompositionRoot(pattern, file))
             continue;
         hits.push({ file, matchedRoot: pattern, hasKernelFactory: hasFactory });

package/bin/lib/config-contract.mjs

@@ -8,8 +8,9 @@
  * Pure CLI helper (bin/lib/config-contract.mjs). Zero Node I/O.
  */
 
-/** Current published ark.config.json schema version (ADR 0020: 1.2 adds optional arkRun). */
-export const ARK_CONFIG_SCHEMA_VERSION = '1.2';
+import { ARK_ORDER_SCHEMA_DEF, ARK_RUN_SCHEMA_DEF, defaultedArkOrder, defaultedArkRun, validateArkOrderExtra, validateArkRunExtra, } from './config-extras.mjs';
+/** Current published ark.config.json schema version (ADR 0027: 1.3 adds optional arkOrder). */
+export const ARK_CONFIG_SCHEMA_VERSION = '1.3';
 export const ARK_CONFIG_SCHEMA_URL = 'https://unpkg.com/arkgate@2/schemas/ark.config.schema.json';
 const DEFAULT_LAYER_NAMES = [
     'DomainModel',
@@ -51,6 +52,7 @@ export const ARK_CONFIG_MIGRATIONS = [
     { from: 'unversioned', to: '1.0' },
     { from: '1.0', to: '1.1' },
     { from: '1.1', to: '1.2' },
+    { from: '1.2', to: '1.3' },
 ];
 const stringArraySchema = {
     type: 'array',
@@ -82,11 +84,7 @@ export const ARK_CONFIG_SCHEMA = {
         exclude: { ...stringArraySchema, default: [] },
         excludeGenerated: { type: 'boolean', default: true },
         frameworkOverlay: { type: 'string', minLength: 1 },
-        layers: {
-            type: 'array',
-            default: [],
-            items: { $ref: '#/$defs/layer' },
-        },
+        layers: { type: 'array', default: [], items: { $ref: '#/$defs/layer' } },
         rules: {
             type: 'array',
             default: DEFAULT_ARK_CONFIG_RULES,
@@ -115,6 +113,8 @@ export const ARK_CONFIG_SCHEMA = {
         },
         /** ADR 0020 — optional ArkRun extra. Absence is silent; unknown keys fail closed. */
         arkRun: { $ref: '#/$defs/arkRun' },
+        /** ADR 0027 — optional ArkOrder extra. Absence is silent; unknown keys fail closed. */
+        arkOrder: { $ref: '#/$defs/arkOrder' },
         /** Team parliament — GitHub handles or emails who may loosen the law (not part of policy hash). */
         stewards: { ...stringArraySchema, default: [] },
     },
@@ -184,20 +184,8 @@ export const ARK_CONFIG_SCHEMA = {
                 allowDisabledPeerIsolation: { type: 'boolean', default: false },
             },
         },
-        arkRun: {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-                mode: {
-                    type: 'string',
-                    enum: ['advisory', 'enforced'],
-                    default: 'advisory',
-                },
-                compositionRoots: { ...stringArraySchema, default: [] },
-                managedLayers: { ...stringArraySchema, default: [] },
-                requireDeclarations: { type: 'boolean', default: true },
-            },
-        },
+        arkRun: ARK_RUN_SCHEMA_DEF,
+        arkOrder: ARK_ORDER_SCHEMA_DEF,
     },
 };
 export class ArkConfigValidationError extends Error {
@@ -331,17 +319,6 @@ function validateNode(value, schema, path, root, issues) {
         }
     }
 }
-function defaultedArkRun(value) {
-    if (!isObject(value))
-        return value;
-    return {
-        ...value,
-        mode: value.mode === undefined ? 'advisory' : value.mode,
-        compositionRoots: value.compositionRoots === undefined ? [] : value.compositionRoots,
-        managedLayers: value.managedLayers === undefined ? [] : value.managedLayers,
-        requireDeclarations: value.requireDeclarations === undefined ? true : value.requireDeclarations,
-    };
-}
 function defaultedConfig(input) {
     const result = {
         ...input,
@@ -355,54 +332,20 @@ function defaultedConfig(input) {
     };
     if (input.arkRun !== undefined)
         result.arkRun = defaultedArkRun(input.arkRun);
+    if (input.arkOrder !== undefined)
+        result.arkOrder = defaultedArkOrder(input.arkOrder);
     return result;
 }
-function validateArkRunExtra(config, issues) {
-    const extra = config.arkRun;
-    if (extra === undefined || !isObject(extra))
-        return;
-    const layerNames = new Set();
-    if (Array.isArray(config.layers)) {
-        for (const layer of config.layers) {
-            if (isObject(layer) && typeof layer.name === 'string' && layer.name.length > 0) {
-                layerNames.add(layer.name);
-            }
-        }
-    }
-    const managed = extra.managedLayers;
-    if (Array.isArray(managed)) {
-        managed.forEach((name, index) => {
-            if (typeof name === 'string' && name.length > 0 && !layerNames.has(name)) {
-                issues.push({
-                    path: `$.arkRun.managedLayers[${index}]`,
-                    message: `layer ${JSON.stringify(name)} is not declared in layers[]`,
-                });
-            }
-        });
-    }
-    if (extra.mode === 'enforced') {
-        const roots = extra.compositionRoots;
-        if (!Array.isArray(roots) || roots.length === 0) {
-            issues.push({
-                path: '$.arkRun.compositionRoots',
-                message: 'ARKRUN_MISSING_ROOT: enforced mode requires at least one composition root',
-            });
-        }
-        if (!Array.isArray(managed) || managed.length === 0) {
-            issues.push({
-                path: '$.arkRun.managedLayers',
-                message: 'enforced mode requires at least one managed layer',
-            });
-        }
-    }
-}
 function migratedFromOf(originalVersion) {
     if (originalVersion === ARK_CONFIG_SCHEMA_VERSION)
         return null;
     if (originalVersion === 'unversioned')
         return 'unversioned';
-    if (originalVersion === '1.0' || originalVersion === '1.1')
+    if (originalVersion === '1.0' ||
+        originalVersion === '1.1' ||
+        originalVersion === '1.2') {
         return originalVersion;
+    }
     return null;
 }
 function knownInputVersions() {
@@ -480,6 +423,7 @@ export function loadArkConfigContract(input, source = 'ark.config.json') {
     const issues = [];
     validateNode(candidate, ARK_CONFIG_SCHEMA, '$', ARK_CONFIG_SCHEMA, issues);
     validateArkRunExtra(candidate, issues);
+    validateArkOrderExtra(candidate, issues);
     if (issues.length > 0)
         throw new ArkConfigValidationError(source, issues);
     return { config: candidate, migratedFrom };