arkgate 4.8.11 → 4.8.14

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

@@ -211,32 +211,67 @@ function canonicalOverlayPath(
   return [...candidates].sort()[0] ?? requested;
 }
 
-function collectCandidateFiles(root, config, changes, observeInput) {
+function discoverScopedFiles(root, config, scopeRelatives, observeInput) {
+  const discovered = [];
+  const seen = new Set();
+  for (const raw of scopeRelatives ?? []) {
+    let relative;
+    try {
+      relative = canonicalProjectPath(
+        String(raw || '')
+          .replace(/\\/g, '/')
+          .replace(/^\.\//, '')
+      );
+    } catch {
+      continue;
+    }
+    if (seen.has(relative) || !isGovernableSourceFile(path.basename(relative))) continue;
+    if (!isIncluded(relative, config.include) || isScanExcludedRelative(relative, config)) {
+      continue;
+    }
+    const absolute = path.join(root, ...relative.split('/'));
+    if (!fs.existsSync(absolute)) continue;
+    seen.add(relative);
+    observeResolvedInput(observeInput, absolute, 'realpath');
+    discovered.push({
+      absolute,
+      real: fs.realpathSync(absolute),
+      relative,
+    });
+  }
+  return discovered.sort((left, right) =>
+    left.relative < right.relative ? -1 : left.relative > right.relative ? 1 : 0
+  );
+}
+
+function collectCandidateFiles(root, config, changes, observeInput, scopeRelatives) {
   const files = new Map();
   const directoryAliases = new Map();
   const expandedAliasDirectories = new Set();
-  const discovered = (config.include ?? [])
-    .flatMap((entry) =>
-      collectGovernedFiles(root, { ...config, include: [entry] }, {
-        observeInput,
-        onDirectory(absolute, real) {
-          let relative = normalize(path.relative(root, absolute));
-          if (relative === '.') relative = '';
-          rememberDirectoryAlias(directoryAliases, real, relative, absolute);
-        },
-      })
-    )
-    .map((absolute) => {
-      observeResolvedInput(observeInput, absolute, 'realpath');
-      return {
-        absolute,
-        real: fs.realpathSync(absolute),
-        relative: canonicalProjectPath(normalize(path.relative(root, absolute))),
-      };
-    })
-    .sort((left, right) =>
-      left.relative < right.relative ? -1 : left.relative > right.relative ? 1 : 0
-    );
+  const discovered = Array.isArray(scopeRelatives)
+    ? discoverScopedFiles(root, config, scopeRelatives, observeInput)
+    : (config.include ?? [])
+        .flatMap((entry) =>
+          collectGovernedFiles(root, { ...config, include: [entry] }, {
+            observeInput,
+            onDirectory(absolute, real) {
+              let relative = normalize(path.relative(root, absolute));
+              if (relative === '.') relative = '';
+              rememberDirectoryAlias(directoryAliases, real, relative, absolute);
+            },
+          })
+        )
+        .map((absolute) => {
+          observeResolvedInput(observeInput, absolute, 'realpath');
+          return {
+            absolute,
+            real: fs.realpathSync(absolute),
+            relative: canonicalProjectPath(normalize(path.relative(root, absolute))),
+          };
+        })
+        .sort((left, right) =>
+          left.relative < right.relative ? -1 : left.relative > right.relative ? 1 : 0
+        );
   const canonicalByRealpath = new Map();
   for (const candidate of discovered) {
     if (!canonicalByRealpath.has(candidate.real)) canonicalByRealpath.set(candidate.real, candidate);
@@ -582,7 +617,8 @@ function compilerContext(ts, root, tsconfig, candidateFiles, observeInput) {
   const optionsByPath = new Map();
   const configInputsByPath = new Map();
   const reasons = [];
-  for (const configPath of configPaths) {
+  const loadConfigOptions = (configPath) => {
+    if (optionsByPath.has(configPath)) return optionsByPath.get(configPath);
     const configContents = new Map();
     const readConfig = (fileName) => {
       observeResolvedInput(observeInput, fileName, 'tsconfig');
@@ -605,15 +641,16 @@ function compilerContext(ts, root, tsconfig, candidateFiles, observeInput) {
       });
       optionsByPath.set(configPath, {});
       configInputsByPath.set(configPath, configContents);
-      continue;
+      return {};
     }
     const parsed = ts.parseJsonConfigFileContent(
       read.config,
       {
         useCaseSensitiveFileNames: ts.sys?.useCaseSensitiveFileNames ?? true,
-        readDirectory(...args) {
-          observeResolvedInput(observeInput, args[0], 'tsconfig-directory');
-          return ts.sys?.readDirectory ? ts.sys.readDirectory(...args) : [];
+        readDirectory(dir) {
+          observeResolvedInput(observeInput, dir, 'tsconfig-directory');
+          // Options-only parse: `fileNames` are unused. Skip the include walk (#205).
+          return [];
         },
         fileExists(fileName) {
           observeResolvedInput(observeInput, fileName, 'tsconfig-exists');
@@ -637,11 +674,19 @@ function compilerContext(ts, root, tsconfig, candidateFiles, observeInput) {
     }
     optionsByPath.set(configPath, parsed.options ?? {});
     configInputsByPath.set(configPath, configContents);
-  }
+    return parsed.options ?? {};
+  };
+  for (const configPath of configPaths) loadConfigOptions(configPath);
 
   const optionsFor = (fileName) => {
-    const configPath = configByFile.get(path.resolve(fileName));
-    return configPath ? optionsByPath.get(configPath) ?? {} : {};
+    const resolved = path.resolve(fileName);
+    let configPath = configByFile.get(resolved);
+    if (!configPath) {
+      configPath = explicitPath
+        ?? nearestTsconfig(root, resolved, nearestConfigByDirectory, observeInput);
+      if (configPath) configByFile.set(resolved, configPath);
+    }
+    return configPath ? loadConfigOptions(configPath) ?? {} : {};
   };
   const configs = configPaths.map((configPath) => ({
     path: configLabel(root, configPath, externalAnchor),
@@ -1036,6 +1081,19 @@ function unavailableFacts(config, ts, reason) {
   });
 }
 
+function loadOneCandidateFile(root, config, relative, observeInput) {
+  const discovered = discoverScopedFiles(root, config, [relative], observeInput);
+  const found = discovered[0];
+  if (!found) return null;
+  observeResolvedInput(observeInput, found.absolute, 'source');
+  return {
+    path: found.relative,
+    absolute: path.resolve(found.absolute),
+    real: path.resolve(found.real),
+    content: fs.readFileSync(found.absolute, 'utf8'),
+  };
+}
+
 /** Resolve one complete candidate tree (base or virtual overlay) into versioned neutral facts. */
 export function resolveCandidateFacts({
   root,
@@ -1044,6 +1102,7 @@ export function resolveCandidateFacts({
   tsconfig,
   changes = [],
   observeInput,
+  scopeFiles,
 }) {
   if (!ts?.createSourceFile || !ts?.resolveModuleName) {
     return unavailableFacts(config, ts, 'No API-compatible TypeScript resolver is available.');
@@ -1053,10 +1112,17 @@ export function resolveCandidateFacts({
   let candidateFiles;
   let canonicalChanges;
   let compiler;
+  const scoped = Array.isArray(scopeFiles);
   try {
     observeResolvedInput(observeInput, root, 'realpath');
     canonicalRoot = fs.realpathSync(root);
-    const candidate = collectCandidateFiles(canonicalRoot, config, changes, observeInput);
+    const candidate = collectCandidateFiles(
+      canonicalRoot,
+      config,
+      changes,
+      observeInput,
+      scoped ? scopeFiles : undefined
+    );
     candidateFiles = candidate.files;
     canonicalChanges = candidate.changes;
     compiler = compilerContext(ts, canonicalRoot, tsconfig, candidateFiles, observeInput);
@@ -1106,7 +1172,8 @@ export function resolveCandidateFacts({
   const compositionRootPatterns = [...(config.arkRun?.compositionRoots ?? [])];
   const planeRootPatterns = [...(config.arkOrder?.planeRoots ?? [])];
 
-  for (const candidate of candidateFiles) {
+  const seedPathSet = new Set(candidateFiles.map((file) => file.path));
+  const ingest = (candidate, fullExtract) => {
     const sourceFile = ts.createSourceFile(
       candidate.absolute,
       candidate.content,
@@ -1158,6 +1225,7 @@ export function resolveCandidateFacts({
         message: `${candidate.path} has ${parseDiagnosticCount} TypeScript parse diagnostic(s).`,
       });
     }
+    if (!fullExtract) return;
     const forbiddenUses = mayContainForbiddenCapability(ts, sourceFile, forbiddenGlobals)
       ? collectForbiddenCapabilityUses(ts, sourceFile, forbiddenGlobals)
       : [];
@@ -1244,10 +1312,50 @@ export function resolveCandidateFacts({
         // Never fail the resolver for ArkOrder release key-count extraction.
       }
     }
+  };
+
+  for (const candidate of candidateFiles) ingest(candidate, true);
+
+  if (scoped) {
+    const loaded = new Set(candidateFiles.map((file) => file.path));
+    let pending = [...candidateFiles];
+    while (pending.length > 0) {
+      const discovered = [];
+      for (const source of pending) {
+        const parsedFile = parsed.get(source.path);
+        if (!parsedFile) continue;
+        for (const dependency of parsedFile.dependencies) {
+          const resolved = resolveDependency(
+            ts,
+            dependency,
+            parsedFile.candidate.absolute,
+            compiler.optionsFor(parsedFile.candidate.absolute),
+            host
+          );
+          if (resolved.resolution !== 'resolved-project' || !resolved.target) continue;
+          if (loaded.has(resolved.target)) continue;
+          const extra = loadOneCandidateFile(
+            canonicalRoot,
+            config,
+            resolved.target,
+            observeInput
+          );
+          if (!extra) continue;
+          loaded.add(extra.path);
+          candidateFiles.push(extra);
+          ingest(extra, false);
+          discovered.push(extra);
+        }
+      }
+      pending = discovered;
+    }
   }
 
+  const extractCandidates = scoped
+    ? candidateFiles.filter((file) => seedPathSet.has(file.path))
+    : candidateFiles;
   const admittedTypeNames = new Set(classShapes.map((shape) => shape.className));
-  for (const candidate of candidateFiles) {
+  for (const candidate of extractCandidates) {
     if (!/\.(tsx?|mts|cts)$/i.test(candidate.path)) continue;
     try {
       arkRunManagedNews.push(
@@ -1264,7 +1372,7 @@ export function resolveCandidateFacts({
 
   if (planeRootPatterns.length > 0) {
     const factoryFiles = new Set(arkOrderPlaneCalls.map((call) => call.file));
-    for (const candidate of candidateFiles) {
+    for (const candidate of extractCandidates) {
       for (const pattern of planeRootPatterns) {
         try {
           if (!globToRegExp(pattern).test(candidate.path)) continue;
@@ -1284,7 +1392,7 @@ export function resolveCandidateFacts({
     const factoryFiles = new Set(
       arkRunKernelCalls.filter((call) => call.kind === 'factory').map((call) => call.file)
     );
-    for (const candidate of candidateFiles) {
+    for (const candidate of extractCandidates) {
       for (const pattern of compositionRootPatterns) {
         try {
           if (!globToRegExp(pattern).test(candidate.path)) continue;

package/bin/lib/rules-under-contract.mjs

@@ -62,6 +62,18 @@ function arkRunMergeInput(config, residualCount = 0) {
   };
 }
 
+function arkOrderMergeInput(config, residualCount = 0) {
+  const extra = config?.arkOrder;
+  if (!extra || typeof extra !== 'object') {
+    return { present: false, mode: null, residualCount: 0 };
+  }
+  return {
+    present: true,
+    mode: extra.mode === 'enforced' || extra.mode === 'advisory' ? extra.mode : null,
+    residualCount: Number(residualCount) || 0,
+  };
+}
+
 export function summarizeRulesUnderContract(root, config, facts, classification) {
   if (!config?.arkRules || Object.keys(config.arkRules).length === 0) {
     return {
@@ -74,6 +86,7 @@ export function summarizeRulesUnderContract(root, config, facts, classification)
         classification,
         arkRules: { active: false },
         arkRun: arkRunMergeInput(config),
+        arkOrder: arkOrderMergeInput(config),
       }),
       notAScore: true,
       note: 'No arkRules map — intra-layer ArkRules are opt-in.',
@@ -187,6 +200,7 @@ export function summarizeRulesUnderContract(root, config, facts, classification)
         uncovered: uncoveredInvariants,
       },
       arkRun: arkRunMergeInput(config),
+      arkOrder: arkOrderMergeInput(config),
     });
 
     return {

package/bin/lib/scan-files.mjs

@@ -115,6 +115,45 @@ export function walk(dir, files = [], options = {}) {
 }
 
 /** Walk include roots then drop codegen / config.exclude (universal scan filter). */
+export function isIncludeMatch(relativePath, include) {
+  return (include ?? []).some((entry) => {
+    const includeRoot = String(entry)
+      .replace(/\\/g, '/')
+      .replace(/^\.\//, '')
+      .replace(/\/$/, '');
+    return (
+      includeRoot === '.' ||
+      relativePath === includeRoot ||
+      relativePath.startsWith(`${includeRoot}/`)
+    );
+  });
+}
+
+/** Path-only governed check — no tree walk. Matches `collectGovernedFiles` membership. */
+export function isGovernedSourcePath(root, relativePath, config) {
+  const rel = normalize(String(relativePath || ''))
+    .replace(/^\.\//, '')
+    .replace(/\\/g, '/');
+  if (!rel || !isGovernableSourceFile(path.basename(rel))) return false;
+  if (!isIncludeMatch(rel, config?.include) || isScanExcludedRelative(rel, config)) return false;
+  return fs.existsSync(path.join(root, ...rel.split('/')));
+}
+
+/** Map diff paths to absolute governed files without walking the include tree. */
+export function governedFilesFromRelativePaths(root, relativePaths, config) {
+  const out = [];
+  const seen = new Set();
+  for (const raw of relativePaths ?? []) {
+    const rel = normalize(String(raw || ''))
+      .replace(/^\.\//, '')
+      .replace(/\\/g, '/');
+    if (!rel || seen.has(rel) || !isGovernedSourcePath(root, rel, config)) continue;
+    seen.add(rel);
+    out.push(path.resolve(root, ...rel.split('/')));
+  }
+  return out;
+}
+
 export function collectGovernedFiles(root, config, options = {}) {
   options.observeInput?.(path.resolve(root), 'realpath');
   const state = {

package/bin/lib/start-preview.mjs

@@ -4,6 +4,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { arkCommand, buildArchitectureRecommendation } from '../ark-shared.mjs';
+import { ARKORDER_FIRST_CONTACT_NEXT, ARKORDER_ONE_BREATH } from './ark-order-doctor.mjs';
 import { compactAgentInstructions, instructionRule, mcpJson } from './ci-and-commands.mjs';
 import {
   antigravityHooks,
@@ -162,6 +163,9 @@ export function renderStartPreview(preview, options = {}) {
   if (!applying) {
     console.log('Setup: install package + host gates (see --json).');
     console.log('Preview does not write. Apply installs CI.');
+    console.log('Optional extras stay off. This start is layers only — they stop bad imports.');
+    console.log(ARKORDER_ONE_BREATH);
+    console.log(ARKORDER_FIRST_CONTACT_NEXT);
   }
   if (preview.runtimeActivation) {
     console.log('Host: Codex is configured but not verified yet. Restart the host, then confirm this project.');

package/bin/lib/status-command.mjs

@@ -26,6 +26,7 @@ import { readBaseline } from './violations.mjs';
 import { reportsDir, readJsonSafe } from './html-report.mjs';
 import { summarizeRulesUnderContract } from './rules-under-contract.mjs';
 import { projectStatusArkRun } from './ark-run-doctor.mjs';
+import { projectStatusArkOrder } from './ark-order-doctor.mjs';
 import { collectVsBaseFacts, discoverTeamBaseRef } from './team-parliament-io.mjs';
 import { classifyAdopted, readAdoptionStance } from './adoption-stance.mjs';
 
@@ -354,6 +355,19 @@ export function collectStatusFacts(options = {}) {
     return projectStatusArkRun({ present: true, mode, extraMergeTeeth, residual });
   })();
 
+  const arkOrder = (() => {
+    const extra = config?.arkOrder;
+    if (!extra || typeof extra !== 'object') {
+      return projectStatusArkOrder({ present: false, residual: 0 });
+    }
+    const snap = latest?.arkOrder && typeof latest.arkOrder === 'object' ? latest.arkOrder : null;
+    const mode = extra.mode === 'enforced' || extra.mode === 'advisory' ? extra.mode : null;
+    const extraMergeTeeth =
+      snap && typeof snap.extraMergeTeeth === 'boolean' ? snap.extraMergeTeeth === true : false;
+    const residual = typeof snap?.residual === 'number' ? snap.residual : null;
+    return projectStatusArkOrder({ present: true, mode, extraMergeTeeth, residual });
+  })();
+
   // DF02 — always project compass with honesty mode (never invent green residual).
   // Prefer explicit override (tests/MCP inject doctor-facts); else report snapshot.
   let improvementCompass = null;
@@ -403,6 +417,7 @@ export function collectStatusFacts(options = {}) {
       latest?.designFitness?.designWeak === true ||
       latest?.doctor?.designFitness?.designWeak === true,
     arkRun: options.arkRun ?? arkRun,
+    arkOrder: options.arkOrder ?? arkOrder,
     adopted:
       options.adopted ??
       classifyAdopted({
@@ -534,6 +549,19 @@ export function runStatusCommand(args = {}) {
             ' · not a score'
         );
       }
+      const arkOrderLine = manifest.arkOrder;
+      if (arkOrderLine && arkOrderLine.notAScore === true) {
+        const residual =
+          arkOrderLine.residual == null ? 'unknown' : String(arkOrderLine.residual);
+        write(
+          `  arkOrder: ${arkOrderLine.present ? arkOrderLine.mode || 'on' : 'absent'}` +
+            ` · residual=${residual}` +
+            (arkOrderLine.present
+              ? ` · extraMergeTeeth=${arkOrderLine.extraMergeTeeth === true}`
+              : '') +
+            ' · not a score'
+        );
+      }
       write(`  next: [${manifest.nextAction.id}] ${manifest.nextAction.summary}`);
     }
 

package/bin/lib/status-manifest.mjs

@@ -9,6 +9,7 @@
  */
 
 import { projectStatusArkRun } from './ark-run-doctor.mjs';
+import { projectStatusArkOrder } from './ark-order-doctor.mjs';
 export const ARK_STATUS_MANIFEST_SCHEMA_VERSION = '1.0';
 export const ARK_STATUS_MANIFEST_SCHEMA_URL = 'https://unpkg.com/arkgate@4/schemas/ark.status-manifest.schema.json';
 /**
@@ -249,6 +250,12 @@ export function resolveStatusNextAction(facts, binding, activation, lastCheck, r
             summary: 'ArkRun residual remains — wire kernel usage or declarations through arkgate/runtime. Not a score.',
         };
     }
+    if (facts.arkOrder?.present === true && (facts.arkOrder.residual ?? 0) > 0) {
+        return {
+            id: 'review-arkorder-residual',
+            summary: 'ArkOrder leftover remains — change that product choice through the valve (proposeRelease then apply), not a generic update. Not a score.',
+        };
+    }
     if (facts.adopted === 'required-merge' || facts.adopted === 'advisory-only-acked') {
         return {
             id: 'stay-enforced',
@@ -336,6 +343,9 @@ export function buildStatusManifest(facts) {
     if (facts.arkRun && typeof facts.arkRun === 'object') {
         status.arkRun = projectStatusArkRun(facts.arkRun);
     }
+    if (facts.arkOrder && typeof facts.arkOrder === 'object') {
+        status.arkOrder = projectStatusArkOrder(facts.arkOrder);
+    }
     return status;
 }
 const STATUS_COMPASS_MODE_SET = new Set(STATUS_COMPASS_MODES);
@@ -628,5 +638,18 @@ export const ARK_STATUS_MANIFEST_SCHEMA = {
                 residual: { anyOf: [{ type: 'integer', minimum: 0 }, { type: 'null' }] },
             },
         },
+        arkOrder: {
+            type: 'object',
+            description: 'ArkOrder extra residual (notAScore). present/mode from config; residual is a finding-id count (null = unknown, not green). extraMergeTeeth is honesty, never a score.',
+            additionalProperties: false,
+            required: ['notAScore', 'present', 'mode', 'extraMergeTeeth', 'residual'],
+            properties: {
+                notAScore: { const: true },
+                present: { type: 'boolean' },
+                mode: { anyOf: [{ enum: ['advisory', 'enforced'] }, { type: 'null' }] },
+                extraMergeTeeth: { type: 'boolean' },
+                residual: { anyOf: [{ type: 'integer', minimum: 0 }, { type: 'null' }] },
+            },
+        },
     },
 };

package/bin/lib/upgrade-whats-new.mjs

@@ -36,10 +36,10 @@ export function buildUpgradeWhatsNewSuggestions() {
       {
         id: 'five-door-autonomy',
         title: 'Five doors (invoke = write or map)',
-        try: '/ark-adopt · /ark-place · /ark-autopilot · /ark-explore · /ark-upgrade',
-        inspect: 'Skill bodies + doctor next action (other /ark-* names are shortcuts)',
+        try: '/ark-adopt · /ark-place · /ark-autopilot · /ark-explore · /ark-upgrade · /ark-runtime · /ark-order',
+        inspect: 'Skill bodies + doctor next action (other /ark-* names are one-release shortcuts)',
         why:
-          'Invoking a door is the approval. The CLI is sensor + gate — it does not apply the change. Explore maps only. Same 13 skill names.',
+          'Invoking a door is the approval. The CLI is sensor + gate — it does not apply the change. Explore maps only. Closed catalog: first-class doors plus stubs. Contener · Guiar · Ordenar.',
       },
       {
         id: 'team-parliament',

package/bin/lib/violations.mjs

@@ -59,9 +59,48 @@ export const FIX_HINTS = {
     'Break the cycle: extract the shared code into a module both sides import, invert one edge behind a port/interface, or merge the files if they are really one unit.',
 };
 
+/** Extra-plane label so a slow-key deny reads as clearly as a bad import. */
+export function violationPlaneLabel(ruleId) {
+  if (typeof ruleId !== 'string') return '';
+  if (ruleId.startsWith('ARKORDER_')) return '[ArkOrder] ';
+  if (ruleId.startsWith('ARKRUN_')) return '[ArkRun] ';
+  return '';
+}
+
+/**
+ * Where a warning came from, in the same `path:line` shape as a deny.
+ * Sensors already carry `file` / `line`; the human printer used to drop them.
+ * No file means the finding is about the project rules, not a line you edited.
+ */
+export const WARNING_UNATTRIBUTED =
+  'not a file — this is about the project rules, not a line you just edited';
+
+export function formatWarningAttribution(warning) {
+  const file = typeof warning?.file === 'string' ? warning.file.trim() : '';
+  if (!file) return WARNING_UNATTRIBUTED;
+  const line =
+    Number.isInteger(warning.line) && warning.line > 0 ? warning.line : 1;
+  return `${file}:${line}`;
+}
+
+export function formatWarningLine(warning) {
+  const ruleId = typeof warning?.ruleId === 'string' ? warning.ruleId : 'WARNING';
+  const message = typeof warning?.message === 'string' ? warning.message : '';
+  return `warning ${ruleId} ${formatWarningAttribution(warning)} ${message}`.trimEnd();
+}
+
+export function printWarning(warning) {
+  const ruleId = typeof warning?.ruleId === 'string' ? warning.ruleId : 'WARNING';
+  const message = typeof warning?.message === 'string' ? warning.message : '';
+  console.error(
+    `${color.yellow('warning')} ${ruleId} ${formatWarningAttribution(warning)} ${message}`.trimEnd()
+  );
+}
+
 export function printViolation(violation) {
   const location = `${violation.file}:${violation.line}`;
-  console.error(`${color.red('✖')} ${color.bold(violation.ruleId)}  ${location}`);
+  const plane = violationPlaneLabel(violation.ruleId);
+  console.error(`${color.red('✖')} ${color.bold(`${plane}${violation.ruleId}`)}  ${location}`);
   if (violation.fromLayer && violation.toLayer) {
     const target = violation.target ? `  ${color.dim(`(${violation.target})`)}` : '';
     console.error(`  ${violation.fromLayer} → ${violation.toLayer}${target}`);

package/dist/{diagnosticCatalog-DiflIock.d.ts → diagnosticCatalog-DVx_2RmF.d.ts}

@@ -392,7 +392,7 @@ declare function createAdapterResult(input: {
 }): CurrentAdapterResult;
 
 /** ArkGate library version — single source of truth. */
-declare const version = "4.8.11";
+declare const version = "4.8.14";
 
 /**
  * AI Code Gate (basic).