arkgate 4.8.2 → 4.8.3

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

@@ -10,6 +10,11 @@
 
 export const ARKORDER_PLANE_FACTORY = 'createOrderPlane';
 export const ARKORDER_FORBIDDEN_METHODS = ['update', 'patch', 'set', 'mutate'];
+const IO_IMPORT_HINT_RE = /\bfrom\s+['"](?:@?prisma\/client|@supabase\/|drizzle-orm|typeorm|knex|mongodb|pg|mysql2|mongoose|better-sqlite3|ioredis|redis|kysely|sequelize)['"]|require\(\s*['"](?:@?prisma\/client|pg|knex|typeorm|mongoose)/;
+const PERSISTENCE_WRITE_HINT_RE = /\.(?:insert(?:One|Many)?|update(?:One|Many)?|upsert|delete(?:One|Many)?|createMany|create|replaceOne|findOneAnd(?:Update|Delete|Replace))\s*\(|\bINSERT\s+INTO\b|\bUPDATE\s+[A-Za-z_][\w.]*\s+SET\b|\bDELETE\s+FROM\b/i;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 export function isArkOrderModuleSpecifier(specifier) {
     return specifier === 'arkgate/order' || specifier.startsWith('arkgate/order/');
 }
@@ -51,3 +56,57 @@ export function extractArkOrderGenericUpdatesFromSource(file, content) {
     }
     return facts;
 }
+/**
+ * Direct evidence: persistence driver import + write token + a declared slow key
+ * written as a property. Absence of xiKeys is the caller's problem (sensor stays silent).
+ */
+export function extractArkOrderXiFieldWritesFromSource(file, content, xiKeys) {
+    if (xiKeys.length === 0)
+        return [];
+    const source = stripCommentsPreservingLines(content);
+    if (!IO_IMPORT_HINT_RE.test(source) || !PERSISTENCE_WRITE_HINT_RE.test(source))
+        return [];
+    const facts = [];
+    const seen = new Set();
+    for (const key of xiKeys) {
+        if (!key)
+            continue;
+        const re = new RegExp(`(?:\\b${escapeRegExp(key)}\\s*:\\s*(?!string\\b|number\\b|boolean\\b|null\\b|[A-Z])|['"]${escapeRegExp(key)}['"]\\s*:|[{\\,]\\s*${escapeRegExp(key)}\\s*[\\,}]|\\.${escapeRegExp(key)}\\s*=)`, 'g');
+        let match;
+        while ((match = re.exec(source)) !== null) {
+            const stamp = `${key}:${match.index}`;
+            if (seen.has(stamp))
+                continue;
+            seen.add(stamp);
+            facts.push({ file, line: lineAt(content, match.index), key });
+            break;
+        }
+    }
+    return facts;
+}
+/** ingest() assigned into a release / ξ / current / pattern store. */
+export function extractArkOrderIngestWritesXiFromSource(file, content) {
+    const source = stripCommentsPreservingLines(content);
+    const facts = [];
+    const re = /(?:\b(?:xi|release|current|pattern|house)\w*|\.xi)\s*=\s*[^\n;]{0,160}?\bingest\s*\(/gi;
+    let match;
+    while ((match = re.exec(source)) !== null) {
+        facts.push({ file, line: lineAt(content, match.index) });
+    }
+    return facts;
+}
+/** Count primitive keys in `.release({ ... })` object literals (no nested ξ). */
+export function extractArkOrderReleaseKeyCountsFromSource(file, content) {
+    const source = stripCommentsPreservingLines(content);
+    const facts = [];
+    const re = /\.release\s*\(\s*\{([^}]*)\}/g;
+    let match;
+    while ((match = re.exec(source)) !== null) {
+        const body = match[1] ?? '';
+        const keys = body.match(/\b[A-Za-z_][\w]*\s*:/g) ?? [];
+        if (keys.length === 0)
+            continue;
+        facts.push({ file, line: lineAt(content, match.index), keyCount: keys.length });
+    }
+    return facts;
+}

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

@@ -8,7 +8,7 @@
  * Pure CLI helper (bin/lib/ark-order-sensors.mjs). Zero Node I/O.
  */
 
-import { extractArkOrderGenericUpdatesFromSource, extractArkOrderPlaneCallsFromSource, isArkOrderModuleSpecifier, } from './ark-order-facts.mjs';
+import { extractArkOrderGenericUpdatesFromSource, extractArkOrderIngestWritesXiFromSource, extractArkOrderPlaneCallsFromSource, extractArkOrderReleaseKeyCountsFromSource, extractArkOrderXiFieldWritesFromSource, isArkOrderModuleSpecifier, } from './ark-order-facts.mjs';
 import { extraMergeTeethAllowed, } from './extra-merge-teeth.mjs';
 import { deterministicNextAction } from './remediation.mjs';
 export const ARKORDER_TIER1_SENSOR_IDS = [
@@ -17,6 +17,7 @@ export const ARKORDER_TIER1_SENSOR_IDS = [
     'arkorder-generic-update',
     'arkorder-too-many-params',
     'arkorder-ingest-writes-xi',
+    'arkorder-xi-field-write',
 ];
 export const ARKORDER_RULE_IDS = {
     'arkorder-missing-plane': 'ARKORDER_MISSING_PLANE',
@@ -24,6 +25,7 @@ export const ARKORDER_RULE_IDS = {
     'arkorder-generic-update': 'ARKORDER_GENERIC_UPDATE',
     'arkorder-too-many-params': 'ARKORDER_TOO_MANY_PARAMS',
     'arkorder-ingest-writes-xi': 'ARKORDER_INGEST_WRITES_XI',
+    'arkorder-xi-field-write': 'ARKORDER_XI_FIELD_WRITE',
 };
 function isDomainRoleLayer(layer, intentPrefixes = []) {
     const name = layer.trim();
@@ -96,6 +98,25 @@ export function evaluateArkOrderSensors(input) {
     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));
     }
+    const xiKeys = extra.xiKeys ?? [];
+    if (xiKeys.length > extra.maxXiKeys) {
+        findings.push(finding(extra, 'arkorder-too-many-params', 'ark.config.json', 1, `arkOrder.xiKeys has ${xiKeys.length} keys; maxXiKeys is ${extra.maxXiKeys} (few slow modes).`, { target: String(xiKeys.length) }, teethAllowed));
+    }
+    for (const release of input.releaseKeyCounts ?? []) {
+        if (release.keyCount <= extra.maxXiKeys)
+            continue;
+        findings.push(finding(extra, 'arkorder-too-many-params', release.file, release.line, `release() freezes ${release.keyCount} keys; maxXiKeys is ${extra.maxXiKeys} (few slow modes).`, { target: String(release.keyCount) }, teethAllowed));
+    }
+    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));
+    }
+    const managed = new Set(extra.managedLayers);
+    for (const write of xiKeys.length === 0 ? [] : input.xiFieldWrites ?? []) {
+        const fromLayer = input.layerForFile(write.file);
+        if (!fromLayer || !managed.has(fromLayer))
+            continue;
+        findings.push(finding(extra, 'arkorder-xi-field-write', write.file, write.line, `File writes slow key ${JSON.stringify(write.key)} through a persistence driver; route the field through ingest or a pattern change through proposeRelease.`, { fromLayer, target: write.key }, teethAllowed));
+    }
     findings.sort((left, right) => left.file.localeCompare(right.file) ||
         left.ruleId.localeCompare(right.ruleId) ||
         left.line - right.line);
@@ -106,13 +127,21 @@ export function evaluateArkOrderEditorSensors(input) {
         return [];
     const planeCalls = extractArkOrderPlaneCallsFromSource(input.file, input.source);
     const genericUpdates = extractArkOrderGenericUpdatesFromSource(input.file, input.source);
+    const xiKeys = input.arkOrder.xiKeys ?? [];
     return evaluateArkOrderSensors({
         arkOrder: input.arkOrder,
         layers: [],
         planeCalls,
         genericUpdates,
         planeRootHits: [],
+        xiFieldWrites: extractArkOrderXiFieldWritesFromSource(input.file, input.source, xiKeys),
+        ingestWritesXi: extractArkOrderIngestWritesXiFromSource(input.file, input.source),
+        releaseKeyCounts: extractArkOrderReleaseKeyCountsFromSource(input.file, input.source),
         dependencies: [],
         layerForFile: () => input.fromLayer,
-    }).findings.filter((item) => item.sensor === 'arkorder-generic-update' || item.sensor === 'arkorder-kernel-in-domain');
+    }).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');
 }

package/bin/lib/arkrule-file-hints.mjs

@@ -10,7 +10,11 @@ import { buildArkRuleFileHints } from './arkrules-sensors.mjs';
 const MAX_HINT_FILES = 400;
 const MAX_FILE_BYTES = 256 * 1024;
 
-const HINT_SENSORS = new Set(['orchestration-only', 'thin-adapter']);
+const HINT_SENSORS = new Set([
+  'orchestration-only',
+  'thin-adapter',
+  'writes-via-aggregate',
+]);
 
 /**
  * @param {{ structure?: Array<{ sensor?: string }> } | null | undefined} arkRules
@@ -26,7 +30,7 @@ export function needsArkRuleFileHints(arkRules) {
  * @param {{ files?: Array<{ path: string }> }} facts
  * @param {{ structure?: Array<{ sensor?: string }> } | null | undefined} arkRules
  * @param {Readonly<Record<string, string>>} [preloadedContents] optional reuse from coverage I/O
- * @returns {Record<string, { orchestrationHeavy?: boolean, adapterThick?: boolean }> | undefined}
+ * @returns {Record<string, { orchestrationHeavy?: boolean, adapterThick?: boolean, persistenceWrite?: boolean }> | undefined}
  */
 export function loadArkRuleFileHints(root, facts, arkRules, preloadedContents) {
   if (!needsArkRuleFileHints(arkRules)) return undefined;

package/bin/lib/arkrules-contract.mjs

@@ -17,6 +17,7 @@ export const ARK_RULE_SENSORS = [
     'domain-event-on-mutation',
     'orchestration-only',
     'thin-adapter',
+    'writes-via-aggregate',
     'no-anemic-model',
     'invariant-coverage',
 ];

package/bin/lib/arkrules-sensors.mjs

@@ -187,6 +187,19 @@ function evaluateThinAdapter(rule, input) {
     }
     return out;
 }
+function evaluateWritesViaAggregate(rule, input) {
+    const out = [];
+    for (const file of input.files) {
+        if (!matchesAppliesTo(file, rule.appliesTo))
+            continue;
+        if (!isInRuleLayer(file, rule, input.layerForFile))
+            continue;
+        if (input.fileHints?.[file]?.persistenceWrite) {
+            out.push(baseViolation(rule, file, `File imports a persistence driver and issues a write; route the write through a Domain aggregate and a persistence adapter (sensor writes-via-aggregate).`));
+        }
+    }
+    return out;
+}
 function evaluateNoAnemicModel(rule, shapes, layerForFile) {
     // Tier-2: always advisory.
     const out = [];
@@ -223,6 +236,9 @@ export function evaluateArkRuleSensors(input) {
             case 'thin-adapter':
                 violations.push(...evaluateThinAdapter(rule, input));
                 break;
+            case 'writes-via-aggregate':
+                violations.push(...evaluateWritesViaAggregate(rule, input));
+                break;
             case 'no-anemic-model':
                 violations.push(...evaluateNoAnemicModel(rule, input.classShapes, input.layerForFile));
                 break;
@@ -292,7 +308,9 @@ export function collectEmptyAppliesToFindings(arkRules, files) {
         a.message.localeCompare(b.message));
 }
 /** IO / ORM import evidence (mirrors design-smells; kept local for Domain purity). */
-const IO_IMPORT_HINT_RE = /\bfrom\s+['"](?:@?prisma\/client|@supabase\/|drizzle-orm|typeorm|knex|mongodb|pg|mysql2|better-sqlite3|ioredis|redis)['"]|require\(\s*['"](?:@?prisma\/client|pg|knex|typeorm)/;
+const IO_IMPORT_HINT_RE = /\bfrom\s+['"](?:@?prisma\/client|@supabase\/|drizzle-orm|typeorm|knex|mongodb|pg|mysql2|mongoose|better-sqlite3|ioredis|redis|kysely|sequelize)['"]|require\(\s*['"](?:@?prisma\/client|pg|knex|typeorm|mongoose)/;
+/** Write tokens that skip the aggregate when paired with a persistence driver import. */
+const PERSISTENCE_WRITE_HINT_RE = /\.(?:insert(?:One|Many)?|update(?:One|Many)?|upsert|delete(?:One|Many)?|createMany|create|replaceOne|findOneAnd(?:Update|Delete|Replace))\s*\(|\bINSERT\s+INTO\b|\bUPDATE\s+[A-Za-z_][\w.]*\s+SET\b|\bDELETE\s+FROM\b/i;
 const HANDLER_SHAPE_HINT_RE = /\b(?:@Controller|@Get|@Post|@Put|@Delete|Router\(\)|createRouter|express\.Router|fastify\.(?:get|post)|export\s+(?:async\s+)?function\s+(?:GET|POST|PUT|DELETE|PATCH)\b|export\s+const\s+(?:GET|POST|PUT|DELETE|PATCH)\s*=)/;
 const FRAMEWORK_HTTP_HINT_RE = /(?:^|[;\n])\s*(?:import\s+(?:type\s+)?(?:[^;]{0,512}?\s+from\s+)?|export\s+(?:type\s+)?[^;]{0,512}?\s+from\s+)['"]next\/server(?:\.js)?['"]/;
 /** Business-predicate / domain branching signals (conservative). */
@@ -324,11 +342,13 @@ export function deriveArkRuleFileHints(_file, content) {
         (hasHandler && hasDomainSignal) ||
         (hasIo && hasMapping && (ifCount >= 4 || domainPredicates.length >= 1)) ||
         (hasHandler && hasIo); // hollow-persistence style: HTTP + persistence together
-    if (!orchestrationHeavy && !adapterThick)
+    const persistenceWrite = hasIo && PERSISTENCE_WRITE_HINT_RE.test(content);
+    if (!orchestrationHeavy && !adapterThick && !persistenceWrite)
         return null;
     return {
         ...(orchestrationHeavy ? { orchestrationHeavy: true } : {}),
         ...(adapterThick ? { adapterThick: true } : {}),
+        ...(persistenceWrite ? { persistenceWrite: true } : {}),
     };
 }
 /**

package/bin/lib/config-extras.mjs

@@ -41,6 +41,7 @@ export const ARK_ORDER_SCHEMA_DEF = {
         planeRoots: { ...stringArraySchema, default: [] },
         managedLayers: { ...stringArraySchema, default: [] },
         maxXiKeys: { type: 'integer', minimum: 1, default: 7 },
+        xiKeys: { ...stringArraySchema, default: [] },
     },
 };
 function isObject(value) {
@@ -83,6 +84,7 @@ export function defaultedArkOrder(value) {
         planeRoots: value.planeRoots === undefined ? [] : value.planeRoots,
         managedLayers: value.managedLayers === undefined ? [] : value.managedLayers,
         maxXiKeys: max,
+        xiKeys: value.xiKeys === undefined ? [] : value.xiKeys,
     };
 }
 export function validateArkRunExtra(config, issues) {

package/bin/lib/diagnostic-catalog.mjs

@@ -52,7 +52,7 @@ export const DIAGNOSTIC_CATALOG = Object.freeze([
     entry('IN_MEMORY_STORE_IN_PRODUCTION_SOURCE', 'safety', 'In-memory store in production source', 'Governed production source references an Ark InMemory* store without safety.allowInMemory — durable systems should not ship ephemeral stores by accident.', 'Provide a durable store implementation, or set safety.allowInMemory only for an explicitly ephemeral service.'),
     entry('PEER_ISOLATION_DISABLED', 'safety', 'peerIsolation disabled on a rule', 'A same-layer or peer rule disables peerIsolation (or omits it where required), which allows cross-slice coupling the contract otherwise blocks.', 'Restore peerIsolation: true, or set safety.allowDisabledPeerIsolation only with a documented production exception.'),
     // ── ArkRules ─────────────────────────────────────────────────────────────
-    entry('ARKRULE_STRUCTURE', 'arkrules', 'ArkRule structure sensor failed', 'An opt-in ArkRules structure sensor (private state, factory shape, event publish, …) failed on a governed file for a declared arkruleId.', 'Restore the declared structure for the ArkRule (see arkruleSource), then preflight again. Do not demote the rule without a hash-bound policy acknowledgement.'),
+    entry('ARKRULE_STRUCTURE', 'arkrules', 'ArkRule structure sensor failed', 'An opt-in ArkRules structure sensor (private state, factory shape, event publish, persistence write outside an aggregate, …) failed on a governed file for a declared arkruleId.', 'Restore the declared structure for the ArkRule (see arkruleSource), then preflight again. Do not demote the rule without a hash-bound policy acknowledgement.'),
     entry('ARKRULE_INVARIANT', 'arkrules', 'ArkRule invariant failed', 'Reserved / remediation-recognized code for invariant-plane failures bound to an ArkRule id (coverage path also emits INVARIANT_UNCOVERED).', 'Fix the invariant for the ArkRule declared in arkrules/<Layer>.json, then preflight again. Do not demote without acknowledgement.'),
     entry('ARKRULE_SCOPE_EMPTY', 'arkrules', 'ArkRule appliesTo matched zero files', 'An ArkRule’s appliesTo globs matched no governed files — the rule cannot observe what it claims to protect.', 'Fix appliesTo globs so they match governed files, or remove the rule. Enforced empty scope fails; advisory empty scope warns.', { oftenAdvisory: true }),
     entry('INVARIANT_UNCOVERED', 'arkrules', 'Invariant without coverage evidence', 'An ArkRules invariant is under contract but no covering test title or declared symbol evidence was found (or coverage is partial). Kind is never-had-tests (adopt residual) vs tests-disappeared (suite exists).', 'Add a test title or declared symbol covering the arkruleId, then preflight again. Treat never-had-tests as adopt residual; treat tests-disappeared as a regression. Missing test globs report partial — never fake green.'),
@@ -69,6 +69,7 @@ export const DIAGNOSTIC_CATALOG = Object.freeze([
     entry('ARKORDER_GENERIC_UPDATE', 'arkorder', 'Generic update of ξ', 'A call to update/patch/set on the order plane rewrites the slow pattern. Haken slaving forbids generic ξ mutation.', 'Use release() to freeze ξ or proposeRelease() for a pattern change with blast radius, then preflight again. Never mechanical-safe.'),
     entry('ARKORDER_TOO_MANY_PARAMS', 'arkorder', 'Too many slow keys', 'ξ has more keys than arkOrder.maxXiKeys. Haken requires a few slow modes, not a dump of microstate.', 'Cut ξ to the slow keys that actually slave the rest, then preflight again. Never mechanical-safe.'),
     entry('ARKORDER_INGEST_WRITES_XI', 'arkorder', 'ingest assigned into ξ', 'An ingest() result is written into a Release or ξ store. ingest may absorb or escalate; it never mints a pattern.', 'Keep ingest results as absorb/escalate only. Change ξ with proposeRelease + release. Never mechanical-safe.'),
+    entry('ARKORDER_XI_FIELD_WRITE', 'arkorder', 'Slow key written around the order plane', 'A managed-layer file imports a persistence driver and writes a declared arkOrder.xiKeys name. Field events absorb or escalate; they do not PATCH the slow pattern.', 'Keep invoices, seats, hours, and logs on ingest. Change the slow key with proposeRelease + release, then preflight again. Never mechanical-safe.'),
     // ── atomic preflight / change set ────────────────────────────────────────
     entry('INVALID_CHANGE_PATH', 'preflight', 'Unsafe change path', 'A change set entry is not a safe, non-empty project-relative path (absolute, escape, empty, or NUL).', 'Use canonical project-relative paths only in the atomic change set, then preflight again.'),
     entry('DUPLICATE_CHANGE_PATH', 'preflight', 'Duplicate path in change set', 'The atomic change set lists more than one operation for the same path.', 'Collapse to one create/update/delete per path, then preflight again.'),

package/bin/lib/remediation.mjs

@@ -106,6 +106,7 @@ const ARKORDER_JUDGMENT_RULE_IDS = new Set([
     'ARKORDER_GENERIC_UPDATE',
     'ARKORDER_TOO_MANY_PARAMS',
     'ARKORDER_INGEST_WRITES_XI',
+    'ARKORDER_XI_FIELD_WRITE',
 ]);
 function arkRunCallSiteName(violation) {
     return typeof violation.target === 'string' && violation.target.trim().length > 0
@@ -234,6 +235,10 @@ export function deterministicNextAction(violation) {
             return 'Cut ξ to the slow keys that actually slave the rest, then preflight again. Never mechanical-safe.';
         case 'ARKORDER_INGEST_WRITES_XI':
             return 'Keep ingest results as absorb/escalate only. Change ξ with proposeRelease + release. Never mechanical-safe.';
+        case 'ARKORDER_XI_FIELD_WRITE':
+            return typeof violation.target === 'string' && violation.target.length > 0
+                ? `Do not persist slow key ${violation.target} from a use-case. Absorb the field with ingest() or change the pattern with proposeRelease(), then preflight again.`
+                : 'Do not persist a declared slow key from a use-case. Absorb the field with ingest() or change the pattern with proposeRelease(), then preflight again. Never mechanical-safe.';
         default:
             if (typeof violation.ruleId === 'string' && violation.ruleId.startsWith('ARKRULE_')) {
                 return `Fix the ArkRule ${typeof violation.arkruleId === 'string' ? violation.arkruleId : violation.ruleId}, then preflight again.`;
@@ -496,6 +501,7 @@ export function enrichViolationWithFixClass(violation) {
         case 'ARKORDER_GENERIC_UPDATE':
         case 'ARKORDER_TOO_MANY_PARAMS':
         case 'ARKORDER_INGEST_WRITES_XI':
+        case 'ARKORDER_XI_FIELD_WRITE':
             enriched.fixClass = 'arkorder-usage';
             enriched.effort = 'medium';
             enriched.enthusiastHint =
@@ -507,7 +513,9 @@ export function enrichViolationWithFixClass(violation) {
                             ? 'Too many slow keys. Keep ξ small — the rest is derived noise.'
                             : violation.ruleId === 'ARKORDER_INGEST_WRITES_XI'
                                 ? 'ingest can absorb or escalate. It never writes a new house.'
-                                : 'Call createOrderPlane from arkgate/order in a listed plane root so the app actually freezes a pattern.';
+                                : violation.ruleId === 'ARKORDER_XI_FIELD_WRITE'
+                                    ? 'Name the slow keys in arkOrder.xiKeys. Invoices and seats still flow; changing the plan is a new release, not prisma.update.'
+                                    : 'Call createOrderPlane from arkgate/order in a listed plane root so the app actually freezes a pattern.';
             break;
         default:
             enriched.fixClass = 'review-contract';

package/bin/lib/resolved-candidate-facts.mjs

@@ -42,7 +42,10 @@ import {
 } from './ark-run-facts.mjs';
 import {
   extractArkOrderGenericUpdatesFromSource,
+  extractArkOrderIngestWritesXiFromSource,
   extractArkOrderPlaneCallsFromSource,
+  extractArkOrderReleaseKeyCountsFromSource,
+  extractArkOrderXiFieldWritesFromSource,
 } from './ark-order-facts.mjs';
 import {
   collectGovernedFiles,
@@ -1015,6 +1018,10 @@ export function resolveCandidateFacts({
   const arkOrderPlaneCalls = [];
   const arkOrderGenericUpdates = [];
   const arkOrderRootHits = [];
+  const arkOrderXiFieldWrites = [];
+  const arkOrderIngestWritesXi = [];
+  const arkOrderReleaseKeyCounts = [];
+  const xiKeys = [...(config.arkOrder?.xiKeys ?? [])];
   const compositionRootPatterns = [...(config.arkRun?.compositionRoots ?? [])];
   const planeRootPatterns = [...(config.arkOrder?.planeRoots ?? [])];
 
@@ -1134,6 +1141,27 @@ export function resolveCandidateFacts({
       } catch {
         // Never fail the resolver for ArkOrder generic-update extraction.
       }
+      try {
+        arkOrderXiFieldWrites.push(
+          ...extractArkOrderXiFieldWritesFromSource(candidate.path, candidate.content, xiKeys)
+        );
+      } catch {
+        // Never fail the resolver for ArkOrder xi-field-write extraction.
+      }
+      try {
+        arkOrderIngestWritesXi.push(
+          ...extractArkOrderIngestWritesXiFromSource(candidate.path, candidate.content)
+        );
+      } catch {
+        // Never fail the resolver for ArkOrder ingest-writes-ξ extraction.
+      }
+      try {
+        arkOrderReleaseKeyCounts.push(
+          ...extractArkOrderReleaseKeyCountsFromSource(candidate.path, candidate.content)
+        );
+      } catch {
+        // Never fail the resolver for ArkOrder release key-count extraction.
+      }
     }
   }
 
@@ -1277,5 +1305,8 @@ export function resolveCandidateFacts({
     arkOrderPlaneCalls,
     arkOrderGenericUpdates,
     arkOrderRootHits,
+    arkOrderXiFieldWrites,
+    arkOrderIngestWritesXi,
+    arkOrderReleaseKeyCounts,
   });
 }

package/dist/{configTypes-BdCe_gvv.d.ts → configTypes-dNJ2C0yx.d.ts}

@@ -76,6 +76,11 @@ type ArkConfigArkOrder = {
     planeRoots: string[];
     managedLayers: string[];
     maxXiKeys: number;
+    /**
+     * Slow product keys the team can already name (plan, cost code, protocol).
+     * Optional. Empty → `ARKORDER_XI_FIELD_WRITE` stays silent.
+     */
+    xiKeys: string[];
 };
 type ArkConfig = {
     $schema: string;

package/dist/{diagnosticCatalog-CPzH-MLN.d.ts → diagnosticCatalog-C5GgeyEE.d.ts}

@@ -1,5 +1,5 @@
-import { e as CreateArchitectureProfileOptions, b as ArchitectureProfile, d as ArkCheckConfig, C as CreateArchitectureProfileFromArkConfigOptions, f as CreateElevenLayerArkConfigOptions, i as Policy, j as IntentCreator, I as IntentName } from './types-DCSlrRnV.js';
-import { A as ArkConfig, c as ArkConfigLoadResult } from './configTypes-BdCe_gvv.js';
+import { e as CreateArchitectureProfileOptions, b as ArchitectureProfile, d as ArkCheckConfig, C as CreateArchitectureProfileFromArkConfigOptions, f as CreateElevenLayerArkConfigOptions, i as Policy, j as IntentCreator, I as IntentName } from './types-dK24fDZa.js';
+import { A as ArkConfig, c as ArkConfigLoadResult } from './configTypes-dNJ2C0yx.js';
 
 /** Versioned public result contract shared by every ArkGate enforcement adapter. */
 /**
@@ -409,7 +409,7 @@ declare const ARK_ANALYSIS_RESULT_SCHEMA: {
 };
 
 /** ArkGate library version — single source of truth. */
-declare const version = "4.8.2";
+declare const version = "4.8.3";
 
 /**
  * AI Code Gate (basic).
@@ -573,6 +573,20 @@ type ResolvedArkOrderRootHitFact = {
     matchedRoot: string;
     hasPlaneFactory: boolean;
 };
+type ResolvedArkOrderXiFieldWriteFact = {
+    file: string;
+    line: number;
+    key: string;
+};
+type ResolvedArkOrderIngestWriteFact = {
+    file: string;
+    line: number;
+};
+type ResolvedArkOrderReleaseKeyCountFact = {
+    file: string;
+    line: number;
+    keyCount: number;
+};
 
 /**
  * Versioned type vocabulary for resolved candidate facts (schema 1.0).
@@ -724,8 +738,11 @@ type ResolvedCandidateFactsInput = {
     arkOrderPlaneCalls?: readonly ResolvedArkOrderPlaneCallFact[];
     arkOrderGenericUpdates?: readonly ResolvedArkOrderGenericUpdateFact[];
     arkOrderRootHits?: readonly ResolvedArkOrderRootHitFact[];
+    arkOrderXiFieldWrites?: readonly ResolvedArkOrderXiFieldWriteFact[];
+    arkOrderIngestWritesXi?: readonly ResolvedArkOrderIngestWriteFact[];
+    arkOrderReleaseKeyCounts?: readonly ResolvedArkOrderReleaseKeyCountFact[];
 };
-type ResolvedCandidateFacts = Omit<ResolvedCandidateFactsInput, 'candidateTreeHash' | 'classShapes' | 'arkRunKernelCalls' | 'arkOrderPlaneCalls' | 'arkOrderGenericUpdates' | 'arkOrderRootHits' | 'arkRunManagedNews' | 'arkRunCompositionRootHits' | 'arkRunDeclarations'> & {
+type ResolvedCandidateFacts = Omit<ResolvedCandidateFactsInput, 'candidateTreeHash' | 'classShapes' | 'arkRunKernelCalls' | 'arkOrderPlaneCalls' | 'arkOrderGenericUpdates' | 'arkOrderXiFieldWrites' | 'arkOrderIngestWritesXi' | 'arkOrderReleaseKeyCounts' | 'arkOrderRootHits' | 'arkRunManagedNews' | 'arkRunCompositionRootHits' | 'arkRunDeclarations'> & {
     schemaVersion: typeof RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION;
     completenessReasons: ResolvedFactsReason[];
     candidateTreeHash: string;
@@ -744,6 +761,9 @@ type ResolvedCandidateFacts = Omit<ResolvedCandidateFactsInput, 'candidateTreeHa
     arkOrderPlaneCalls: ResolvedArkOrderPlaneCallFact[];
     arkOrderGenericUpdates: ResolvedArkOrderGenericUpdateFact[];
     arkOrderRootHits: ResolvedArkOrderRootHitFact[];
+    arkOrderXiFieldWrites: ResolvedArkOrderXiFieldWriteFact[];
+    arkOrderIngestWritesXi: ResolvedArkOrderIngestWriteFact[];
+    arkOrderReleaseKeyCounts: ResolvedArkOrderReleaseKeyCountFact[];
     factsHash: string;
 };
 
@@ -1388,6 +1408,71 @@ declare const RESOLVED_CANDIDATE_FACTS_SCHEMA: {
                 };
             };
         };
+        readonly arkOrderXiFieldWrites: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "key"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly key: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly arkOrderIngestWritesXi: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                };
+            };
+        };
+        readonly arkOrderReleaseKeyCounts: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "keyCount"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly keyCount: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                };
+            };
+        };
         readonly factsHash: {
             readonly type: "string";
             readonly minLength: 1;
@@ -1598,7 +1683,7 @@ declare function collectForbiddenCapabilityUses(ts: any, sourceFile: any, forbid
  * ./arkRulesContract.ts so generate:cli-pure can emit a self-contained artifact.
  */
 /** Closed sensor vocabulary (ADR 0013). Unknown sensors fail closed at load time. */
-declare const ARK_RULE_SENSOR_IDS: readonly ["aggregate-private-state", "always-valid-factory", "domain-event-on-mutation", "orchestration-only", "thin-adapter", "no-anemic-model", "invariant-coverage"];
+declare const ARK_RULE_SENSOR_IDS: readonly ["aggregate-private-state", "always-valid-factory", "domain-event-on-mutation", "orchestration-only", "thin-adapter", "writes-via-aggregate", "no-anemic-model", "invariant-coverage"];
 type ArkRuleSensorId = (typeof ARK_RULE_SENSOR_IDS)[number];
 type ArkRuleMode = 'advisory' | 'enforced';
 type ArkRuleStructureEntry = {
@@ -1762,6 +1847,7 @@ type EvaluateArkRuleSensorsInput = {
     fileHints?: Readonly<Record<string, {
         orchestrationHeavy?: boolean;
         adapterThick?: boolean;
+        persistenceWrite?: boolean;
     }>>;
 };
 /**
@@ -1782,6 +1868,7 @@ declare function collectEmptyAppliesToFindings(arkRules: EffectiveArkRules, file
 declare function deriveArkRuleFileHints(_file: string, content: string): {
     orchestrationHeavy?: boolean;
     adapterThick?: boolean;
+    persistenceWrite?: boolean;
 } | null;
 /**
  * Build fileHints map from path→content. Omits paths with no flags (sparse map).
@@ -1789,6 +1876,7 @@ declare function deriveArkRuleFileHints(_file: string, content: string): {
 declare function buildArkRuleFileHints(fileContents: Readonly<Record<string, string>>): Record<string, {
     orchestrationHeavy?: boolean;
     adapterThick?: boolean;
+    persistenceWrite?: boolean;
 }>;
 /**
  * Lightweight class-shape extraction from TypeScript source text (no compiler).
@@ -1888,11 +1976,13 @@ type AnalyzeResolvedProjectInput = {
     /**
      * AR07 — Tooling-supplied orchestration/thin-adapter heuristics per file.
      * Prefer deriveArkRuleFileHints / buildArkRuleFileHints (Domain pure).
-     * When omitted, orchestration-only and thin-adapter sensors stay silent.
+     * When omitted, orchestration-only, thin-adapter, and writes-via-aggregate
+     * sensors stay silent.
      */
     fileHints?: Readonly<Record<string, {
         orchestrationHeavy?: boolean;
         adapterThick?: boolean;
+        persistenceWrite?: boolean;
     }>>;
 };
 type PreflightResolvedChangeInput = {
@@ -2310,4 +2400,4 @@ declare function catalogFixForRuleId(ruleId: string | null | undefined): string
  */
 declare function catalogWhyForRuleId(ruleId: string | null | undefined): string | undefined;
 
-export { type ArchitectureConvergenceClassification as $, type ArkRulesFile as A, type AnalysisCapabilityUse as B, type AnalysisCompilerOptions as C, type AnalysisCompleteness as D, type EffectiveArkRules as E, type AnalysisContract as F, type AnalysisEvidence as G, type AnalysisFile as H, type AnalysisFileChange as I, type AnalysisFileInput as J, type AnalysisImportEdge as K, type AnalysisIr as L, type AnalysisMode as M, type AnalysisResult as N, type AnalysisViolation as O, type AnalyzeArchitectureConvergenceInput as P, type AnalyzeChangeInput as Q, type ResolvedArkRunKernelCallKind as R, type AnalyzePolicyDeltaInput as S, type AnalyzeProjectInput as T, type AnalyzeResolvedProjectInput as U, type ArchitectureActualChange as V, type ArchitectureChangeMap as W, type ArchitectureChangeMapContract as X, type ArchitectureChangeMapDependency as Y, type ArchitectureChangeMapFile as Z, type ArchitectureChangeOperation as _, type ResolvedArkRunDeclarationFact as a, adapterFindingOccurrenceTargetKeys as a$, type ArchitectureConvergenceFinding as a0, type ArchitectureConvergenceResult as a1, type ArchitectureDependency as a2, type ArchitectureEngineEdge as a3, type ArchitectureEngineResult as a4, type ArchitectureEngineViolation as a5, type ArkDesignDeltaResult as a6, type ArkEnforcementHost as a7, type ArkEnforcementState as a8, type ArkRuleSensorViolation as a9, type PolicyDeltaClassification as aA, type PolicyDeltaFinding as aB, type PreflightResolvedChangeInput as aC, type PreparedChangeFile as aD, RESOLVED_CANDIDATE_FACTS_SCHEMA as aE, RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION as aF, type ResolvedAmbientFact as aG, type ResolvedAnalysisFile as aH, type ResolvedAnalysisIr as aI, type ResolvedAnalysisResult as aJ, type ResolvedCandidateFacts as aK, type ResolvedCandidateFactsInput as aL, type ResolvedCapability as aM, type ResolvedCapabilityFact as aN, type ResolvedChangePreflightResult as aO, type ResolvedDependencyKind as aP, type ResolvedDependencyState as aQ, type ResolvedFactsCompleteness as aR, type ResolvedFileFact as aS, type ResolvedIntentReferenceFact as aT, type ResolvedPublishFact as aU, type ResolvedSafetyFact as aV, type ResolvedSafetyKind as aW, type ResolvedSafetyReport as aX, type SemanticDependency as aY, type SemanticDependencyKind as aZ, adapterDocsCodePath as a_, type ChangePreflightResult as aa, type ClassShapeFact as ab, type CollectAnalysisConfigWarningsInput as ac, DIAGNOSTIC_CATALOG as ad, DIAGNOSTIC_CATALOG_SCHEMA_VERSION as ae, DIAGNOSTIC_DOCS_RELATIVE_PATH as af, DIAGNOSTIC_RULE_IDS as ag, type DesignDeltaChange as ah, type DesignDeltaEnforcementScope as ai, type DesignDeltaIdentity as aj, type DesignSmellEvidence as ak, type DesignSmellFinding as al, type DesignSmellId as am, type DiagnosticCatalogEntry as an, type DiagnosticCategory as ao, type EnforcementBoundaryState as ap, type EnforcementEvidence as aq, type EnforcementEvidenceField as ar, type EnforcementVerification as as, type EvaluateArchitectureGraphInput as at, type ForbiddenCapabilityUse as au, type InvariantCoverageEvidence as av, POLICY_DELTA_SCHEMA_VERSION as aw, type PolicyDelta as ax, type PolicyDeltaAcknowledgement as ay, type PolicyDeltaAnalysis as az, type ResolvedArkRunKernelCallFact as b, adapterFindingRefFromTargetKey as b0, adapterFindingTargetKey as b1, analyzeArchitectureConvergence as b2, analyzeChange as b3, analyzePolicyDelta as b4, analyzeProject as b5, analyzeResolvedProject as b6, buildArkRuleFileHints as b7, canPromoteInvariant as b8, catalogFixForRuleId as b9, loadContract as bA, loadResolvedCandidateFacts as bB, policyDeltaAcknowledgementMatches as bC, preflightChange as bD, preflightResolvedChange as bE, resolvedFactsEvidenceRequirementsHash as bF, serializeDiagnosticCatalog as bG, stableSerialize as bH, toAdapterDiagnostic as bI, version as bJ, catalogWhyForRuleId as ba, classifyArkPolicyDelta as bb, collectAnalysisConfigWarnings as bc, collectEmptyAppliesToFindings as bd, collectForbiddenCapabilityUses as be, createAICodeGate as bf, createAdapterResult as bg, createArchitectureProfile as bh, createArchitectureProfileFromArkConfig as bi, createElevenLayerArkConfig as bj, createResolvedCandidateFacts as bk, deriveArkRuleFileHints as bl, detectArchitectureCycles as bm, deterministicHash as bn, diagnosticDocsFragment as bo, diagnosticDocsPath as bp, elevenLayerProfile as bq, evaluateArchitectureGraph as br, evaluateArkRuleSensors as bs, evaluateInvariantCoverage as bt, explainViolation as bu, extractClassShapesFromSource as bv, extractSemanticDependencies as bw, getDiagnosticCatalogEntry as bx, isCataloguedOrArkRuleFamily as by, isKnownDiagnosticCode as bz, type ResolvedArkRunManagedNewFact as c, type ResolvedDependencyFact as d, type ResolvedArkRunCompositionRootHitFact as e, type ResolvedFactsReason as f, type ResolvedArkOrderPlaneCallFact as g, type ResolvedArkOrderGenericUpdateFact as h, type ResolvedArkOrderRootHitFact as i, ADAPTER_DIAGNOSTIC_DOCS_RELATIVE_PATH as j, type AICodeGate as k, type AICodeGateContext as l, type AICodeGateOptions as m, type AICodeGateResult as n, type AICodeGateViolation as o, type AIGateExtension as p, ANALYSIS_IR_SCHEMA_VERSION as q, ARK_ANALYSIS_RESULT_SCHEMA as r, ARK_ANALYSIS_RESULT_SCHEMA_VERSION as s, ARK_DESIGN_DELTA_SCHEMA_VERSION as t, ARK_ENFORCEMENT_STATE_SCHEMA_VERSION as u, type AdapterCompletenessReason as v, type AdapterDiagnostic as w, type AdapterResult as x, type AdapterSeverity as y, type AdapterViolationInput as z };
+export { type ArchitectureChangeMapFile as $, type ArkRulesFile as A, type AdapterSeverity as B, type AdapterViolationInput as C, type AnalysisCapabilityUse as D, type EffectiveArkRules as E, type AnalysisCompilerOptions as F, type AnalysisCompleteness as G, type AnalysisContract as H, type AnalysisEvidence as I, type AnalysisFile as J, type AnalysisFileChange as K, type AnalysisFileInput as L, type AnalysisImportEdge as M, type AnalysisIr as N, type AnalysisMode as O, type AnalysisResult as P, type AnalysisViolation as Q, type ResolvedArkRunKernelCallKind as R, type AnalyzeArchitectureConvergenceInput as S, type AnalyzeChangeInput as T, type AnalyzePolicyDeltaInput as U, type AnalyzeProjectInput as V, type AnalyzeResolvedProjectInput as W, type ArchitectureActualChange as X, type ArchitectureChangeMap as Y, type ArchitectureChangeMapContract as Z, type ArchitectureChangeMapDependency as _, type ResolvedArkRunDeclarationFact as a, type SemanticDependencyKind as a$, type ArchitectureChangeOperation as a0, type ArchitectureConvergenceClassification as a1, type ArchitectureConvergenceFinding as a2, type ArchitectureConvergenceResult as a3, type ArchitectureDependency as a4, type ArchitectureEngineEdge as a5, type ArchitectureEngineResult as a6, type ArchitectureEngineViolation as a7, type ArkDesignDeltaResult as a8, type ArkEnforcementHost as a9, type PolicyDeltaAcknowledgement as aA, type PolicyDeltaAnalysis as aB, type PolicyDeltaClassification as aC, type PolicyDeltaFinding as aD, type PreflightResolvedChangeInput as aE, type PreparedChangeFile as aF, RESOLVED_CANDIDATE_FACTS_SCHEMA as aG, RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION as aH, type ResolvedAmbientFact as aI, type ResolvedAnalysisFile as aJ, type ResolvedAnalysisIr as aK, type ResolvedAnalysisResult as aL, type ResolvedCandidateFacts as aM, type ResolvedCandidateFactsInput as aN, type ResolvedCapability as aO, type ResolvedCapabilityFact as aP, type ResolvedChangePreflightResult as aQ, type ResolvedDependencyKind as aR, type ResolvedDependencyState as aS, type ResolvedFactsCompleteness as aT, type ResolvedFileFact as aU, type ResolvedIntentReferenceFact as aV, type ResolvedPublishFact as aW, type ResolvedSafetyFact as aX, type ResolvedSafetyKind as aY, type ResolvedSafetyReport as aZ, type SemanticDependency as a_, type ArkEnforcementState as aa, type ArkRuleSensorViolation as ab, type ChangePreflightResult as ac, type ClassShapeFact as ad, type CollectAnalysisConfigWarningsInput as ae, DIAGNOSTIC_CATALOG as af, DIAGNOSTIC_CATALOG_SCHEMA_VERSION as ag, DIAGNOSTIC_DOCS_RELATIVE_PATH as ah, DIAGNOSTIC_RULE_IDS as ai, type DesignDeltaChange as aj, type DesignDeltaEnforcementScope as ak, type DesignDeltaIdentity as al, type DesignSmellEvidence as am, type DesignSmellFinding as an, type DesignSmellId as ao, type DiagnosticCatalogEntry as ap, type DiagnosticCategory as aq, type EnforcementBoundaryState as ar, type EnforcementEvidence as as, type EnforcementEvidenceField as at, type EnforcementVerification as au, type EvaluateArchitectureGraphInput as av, type ForbiddenCapabilityUse as aw, type InvariantCoverageEvidence as ax, POLICY_DELTA_SCHEMA_VERSION as ay, type PolicyDelta as az, type ResolvedArkRunKernelCallFact as b, adapterDocsCodePath as b0, adapterFindingOccurrenceTargetKeys as b1, adapterFindingRefFromTargetKey as b2, adapterFindingTargetKey as b3, analyzeArchitectureConvergence as b4, analyzeChange as b5, analyzePolicyDelta as b6, analyzeProject as b7, analyzeResolvedProject as b8, buildArkRuleFileHints as b9, isCataloguedOrArkRuleFamily as bA, isKnownDiagnosticCode as bB, loadContract as bC, loadResolvedCandidateFacts as bD, policyDeltaAcknowledgementMatches as bE, preflightChange as bF, preflightResolvedChange as bG, resolvedFactsEvidenceRequirementsHash as bH, serializeDiagnosticCatalog as bI, stableSerialize as bJ, toAdapterDiagnostic as bK, version as bL, canPromoteInvariant as ba, catalogFixForRuleId as bb, catalogWhyForRuleId as bc, classifyArkPolicyDelta as bd, collectAnalysisConfigWarnings as be, collectEmptyAppliesToFindings as bf, collectForbiddenCapabilityUses as bg, createAICodeGate as bh, createAdapterResult as bi, createArchitectureProfile as bj, createArchitectureProfileFromArkConfig as bk, createElevenLayerArkConfig as bl, createResolvedCandidateFacts as bm, deriveArkRuleFileHints as bn, detectArchitectureCycles as bo, deterministicHash as bp, diagnosticDocsFragment as bq, diagnosticDocsPath as br, elevenLayerProfile as bs, evaluateArchitectureGraph as bt, evaluateArkRuleSensors as bu, evaluateInvariantCoverage as bv, explainViolation as bw, extractClassShapesFromSource as bx, extractSemanticDependencies as by, getDiagnosticCatalogEntry as bz, type ResolvedArkRunManagedNewFact as c, type ResolvedDependencyFact as d, type ResolvedArkRunCompositionRootHitFact as e, type ResolvedFactsReason as f, type ResolvedArkOrderPlaneCallFact as g, type ResolvedArkOrderGenericUpdateFact as h, type ResolvedArkOrderRootHitFact as i, type ResolvedArkOrderXiFieldWriteFact as j, type ResolvedArkOrderIngestWriteFact as k, ADAPTER_DIAGNOSTIC_DOCS_RELATIVE_PATH as l, type AICodeGate as m, type AICodeGateContext as n, type AICodeGateOptions as o, type AICodeGateResult as p, type AICodeGateViolation as q, type AIGateExtension as r, ANALYSIS_IR_SCHEMA_VERSION as s, ARK_ANALYSIS_RESULT_SCHEMA as t, ARK_ANALYSIS_RESULT_SCHEMA_VERSION as u, ARK_DESIGN_DELTA_SCHEMA_VERSION as v, ARK_ENFORCEMENT_STATE_SCHEMA_VERSION as w, type AdapterCompletenessReason as x, type AdapterDiagnostic as y, type AdapterResult as z };