arkgate 4.8.24 → 4.8.26

package/bin/lib/arkrules-contract.mjs

@@ -8,8 +8,9 @@
  * Pure CLI helper (bin/lib/arkrules-contract.mjs). Zero Node I/O.
  */
 
+import { isObject, validateSchemaNode, valueType } from './schema-validation.mjs';
 export const ARK_RULES_SCHEMA_VERSION = '1.0';
-export const ARK_RULES_SCHEMA_URL = 'https://unpkg.com/arkgate/schemas/ark.arkrules.schema.json';
+const ARK_RULES_SCHEMA_URL = 'https://unpkg.com/arkgate/schemas/ark.arkrules.schema.json';
 /** Closed sensor vocabulary — keep in lockstep with arkRulesTypes.ARK_RULE_SENSOR_IDS. */
 export const ARK_RULE_SENSORS = [
     'aggregate-private-state',
@@ -105,113 +106,6 @@ export class ArkRulesValidationError extends Error {
         this.issues = issues;
     }
 }
-function isObject(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-function propertyPath(parent, key) {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
-        ? `${parent}.${key}`
-        : `${parent}[${JSON.stringify(key)}]`;
-}
-function valueType(value) {
-    if (value === null)
-        return 'null';
-    if (Array.isArray(value))
-        return 'array';
-    return typeof value;
-}
-function resolveSchemaRef(ref, root) {
-    const prefix = '#/$defs/';
-    if (!ref.startsWith(prefix))
-        return undefined;
-    return root.$defs[ref.slice(prefix.length)];
-}
-function validateNode(value, schema, path, root, issues) {
-    if (schema.$ref) {
-        const referenced = resolveSchemaRef(schema.$ref, root);
-        if (!referenced) {
-            issues.push({ path, message: `schema reference ${schema.$ref} cannot be resolved` });
-            return;
-        }
-        validateNode(value, referenced, path, root, issues);
-        return;
-    }
-    if (schema.const !== undefined && !Object.is(value, schema.const)) {
-        issues.push({ path, message: `must equal ${JSON.stringify(schema.const)}` });
-        return;
-    }
-    if (schema.enum && !schema.enum.some((candidate) => Object.is(candidate, value))) {
-        issues.push({ path, message: `must be one of ${schema.enum.map(String).join(', ')}` });
-        return;
-    }
-    if (schema.type === 'object') {
-        if (!isObject(value)) {
-            issues.push({ path, message: `must be an object; received ${valueType(value)}` });
-            return;
-        }
-        const properties = schema.properties ?? {};
-        for (const key of schema.required ?? []) {
-            if (value[key] === undefined) {
-                issues.push({ path: propertyPath(path, key), message: 'is required' });
-            }
-        }
-        if (schema.additionalProperties === false) {
-            for (const key of Object.keys(value)) {
-                if (!(key in properties)) {
-                    issues.push({ path: propertyPath(path, key), message: 'unknown field' });
-                }
-            }
-        }
-        else if (isObject(schema.additionalProperties)) {
-            const additional = schema.additionalProperties;
-            for (const key of Object.keys(value)) {
-                if (!(key in properties)) {
-                    validateNode(value[key], additional, propertyPath(path, key), root, issues);
-                }
-            }
-        }
-        for (const [key, childSchema] of Object.entries(properties)) {
-            if (value[key] !== undefined) {
-                validateNode(value[key], childSchema, propertyPath(path, key), root, issues);
-            }
-        }
-        return;
-    }
-    if (schema.type === 'array') {
-        if (!Array.isArray(value)) {
-            issues.push({ path, message: `must be an array; received ${valueType(value)}` });
-            return;
-        }
-        if (schema.minItems !== undefined && value.length < schema.minItems) {
-            issues.push({ path, message: `must contain at least ${schema.minItems} item(s)` });
-        }
-        if (schema.uniqueItems) {
-            const serialized = value.map((entry) => JSON.stringify(entry));
-            if (new Set(serialized).size !== serialized.length) {
-                issues.push({ path, message: 'must not contain duplicate items' });
-            }
-        }
-        if (schema.items) {
-            value.forEach((entry, index) => validateNode(entry, schema.items, `${path}[${index}]`, root, issues));
-        }
-        return;
-    }
-    if (schema.type === 'string') {
-        if (typeof value !== 'string') {
-            issues.push({ path, message: `must be a string; received ${valueType(value)}` });
-            return;
-        }
-        if (schema.minLength !== undefined && value.length < schema.minLength) {
-            issues.push({ path, message: `must contain at least ${schema.minLength} character(s)` });
-        }
-        return;
-    }
-    if (schema.type === 'boolean') {
-        if (typeof value !== 'boolean') {
-            issues.push({ path, message: `must be a boolean; received ${valueType(value)}` });
-        }
-    }
-}
 function defaultedArkRules(input) {
     return {
         ...input,
@@ -299,7 +193,7 @@ export function loadArkRulesContract(input, source = 'arkrules.json', expectedLa
     }
     const candidate = defaultedArkRules(input);
     const issues = [];
-    validateNode(candidate, ARK_RULES_SCHEMA, '$', ARK_RULES_SCHEMA, issues);
+    validateSchemaNode(candidate, ARK_RULES_SCHEMA, '$', ARK_RULES_SCHEMA, issues);
     validateSemantics(candidate, issues);
     if (expectedLayer !== undefined &&
         typeof candidate.layer === 'string' &&
@@ -328,39 +222,136 @@ export function parseArkRulesJson(json, source = 'arkrules.json', expectedLayer)
     }
     return loadArkRulesContract(input, source, expectedLayer);
 }
+function effectiveRuleId(part, localId) {
+    return part.childId ? `${part.childId}#${localId}` : localId;
+}
+function effectiveAppliesTo(part, appliesTo) {
+    if (appliesTo && appliesTo.length > 0)
+        return [...appliesTo];
+    if (part.childId && part.defaultAppliesTo && part.defaultAppliesTo.length > 0) {
+        return [...part.defaultAppliesTo];
+    }
+    return undefined;
+}
+function provenanceFor(part, localId) {
+    return {
+        sourceFile: part.sourceFile,
+        ruleId: effectiveRuleId(part, localId),
+        layer: part.layer,
+        ...(part.childId ? { childId: part.childId } : {}),
+    };
+}
+/**
+ * True when every path the glob can match stays under the slice root.
+ * A wider prefix, a `**` that is not the last segment, or `..` escapes.
+ */
+function appliesToPatternInsideSlice(pattern, sliceRoot) {
+    const root = sliceRoot.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+    const value = pattern.trim().replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase();
+    if (!value || !root || value.includes('..'))
+        return false;
+    if (value === root || value === `${root}/**` || value === `${root}/*`)
+        return true;
+    if (value.startsWith(`${root}/`)) {
+        const parts = value.slice(root.length + 1).split('/');
+        const globStar = parts.indexOf('**');
+        if (globStar !== -1 && globStar !== parts.length - 1)
+            return false;
+        return parts.every((part) => part.length > 0);
+    }
+    const bareRoot = root.replace(/^(?:src|app)\//, '');
+    const bareValue = value.replace(/^(?:src|app)\//, '');
+    if (bareRoot !== root || bareValue !== value)
+        return appliesToPatternInsideSlice(bareValue, bareRoot);
+    return false;
+}
+/** Explicit appliesTo on a discovered file that can match outside its slice. */
+export function sliceScopeEscapes(part) {
+    if (!part.childId || !part.defaultAppliesTo?.length)
+        return [];
+    const sliceRoot = String(part.defaultAppliesTo[0]).replace(/\/\*\*$/, '');
+    const escapes = [];
+    const entries = [...(part.file.structure ?? []), ...(part.file.invariants ?? [])];
+    for (const entry of entries) {
+        for (const pattern of entry.appliesTo ?? []) {
+            if (!appliesToPatternInsideSlice(pattern, sliceRoot))
+                escapes.push({ id: entry.id, pattern });
+        }
+    }
+    return escapes;
+}
+/** Effective ids declared by more than one part. Central ids stay bare; slice ids are namespaced. */
+export function duplicateArkRuleIds(parts) {
+    const seen = new Map();
+    const dupes = new Map();
+    for (const part of parts) {
+        const localIds = [
+            ...(part.file.structure ?? []).map((entry) => entry.id),
+            ...(part.file.invariants ?? []).map((entry) => entry.id),
+        ];
+        for (const localId of localIds) {
+            const id = effectiveRuleId(part, localId);
+            const key = `${part.layer}\0${id}`;
+            const existing = seen.get(key);
+            if (!existing) {
+                seen.set(key, { id, layer: part.layer, sourceFiles: [part.sourceFile] });
+                continue;
+            }
+            const row = dupes.get(key) ?? { id, layer: part.layer, sourceFiles: [...existing.sourceFiles] };
+            if (!row.sourceFiles.includes(part.sourceFile))
+                row.sourceFiles.push(part.sourceFile);
+            dupes.set(key, row);
+        }
+    }
+    return [...dupes.values()];
+}
 /**
  * Build the Effective Contract from already-validated ArkRules files.
- * Callers supply `{ layer → { sourceFile, file } }` after resolving references.
+ * Same-layer parts merge. A child id namespaces the effective id and does not rewrite the file.
  */
 export function buildEffectiveArkRules(parts) {
     const byLayer = {};
     const structure = [];
     const invariants = [];
-    const ordered = [...parts].sort((a, b) => a.layer.localeCompare(b.layer));
+    const ordered = [...parts].sort((a, b) => a.layer.localeCompare(b.layer) || a.sourceFile.localeCompare(b.sourceFile));
     for (const part of ordered) {
-        const structureRules = (part.file.structure ?? []).map((entry) => ({
-            ...entry,
-            mode: normalizeMode(entry.mode),
-            provenance: {
-                sourceFile: part.sourceFile,
-                ruleId: entry.id,
-                layer: part.layer,
-            },
-        }));
-        const invariantRules = (part.file.invariants ?? []).map((entry) => ({
-            ...entry,
-            mode: normalizeMode(entry.mode),
-            provenance: {
+        const structureRules = (part.file.structure ?? []).map((entry) => {
+            const appliesTo = effectiveAppliesTo(part, entry.appliesTo);
+            return {
+                ...entry,
+                id: effectiveRuleId(part, entry.id),
+                ...(appliesTo ? { appliesTo } : { appliesTo: undefined }),
+                mode: normalizeMode(entry.mode),
+                provenance: provenanceFor(part, entry.id),
+            };
+        });
+        const invariantRules = (part.file.invariants ?? []).map((entry) => {
+            const appliesTo = effectiveAppliesTo(part, entry.appliesTo);
+            return {
+                ...entry,
+                id: effectiveRuleId(part, entry.id),
+                ...(appliesTo ? { appliesTo } : { appliesTo: undefined }),
+                mode: normalizeMode(entry.mode),
+                provenance: provenanceFor(part, entry.id),
+            };
+        });
+        const bucket = byLayer[part.layer];
+        if (!bucket) {
+            byLayer[part.layer] = {
                 sourceFile: part.sourceFile,
-                ruleId: entry.id,
-                layer: part.layer,
-            },
-        }));
-        byLayer[part.layer] = {
-            sourceFile: part.sourceFile,
-            structure: structureRules,
-            invariants: invariantRules,
-        };
+                sourceFiles: [part.sourceFile],
+                structure: structureRules,
+                invariants: invariantRules,
+            };
+        }
+        else {
+            if (!bucket.sourceFiles)
+                bucket.sourceFiles = [bucket.sourceFile];
+            if (!bucket.sourceFiles.includes(part.sourceFile))
+                bucket.sourceFiles.push(part.sourceFile);
+            bucket.structure.push(...structureRules);
+            bucket.invariants.push(...invariantRules);
+        }
         structure.push(...structureRules);
         invariants.push(...invariantRules);
     }

package/bin/lib/arkrules-sensors.mjs

@@ -9,7 +9,7 @@
  */
 
 import { findClassDeclarations, scanClassMembers } from './class-source-scan.mjs';
-import { sourceHasPersistenceWrite, sourceImportsPersistenceDriverText } from './persistence-write-hint.mjs';
+import { sourceHasPersistenceWrite, sourceHasTaggedSqlWrite, sourceImportsPersistenceDriverText, } from './persistence-write-hint.mjs';
 /** Keep in lockstep with arkRulesTypes.ARK_RULE_TIER2_SENSOR_IDS (self-contained for CLI gen). */
 const ARK_RULE_TIER2_SENSOR_IDS = ['no-anemic-model'];
 /**
@@ -35,7 +35,7 @@ const THIS_FIELD_ASSIGNMENT_RE = /\bthis\.[A-Za-z_][A-Za-z0-9_]*\s*=(?!=)/g;
 export function expectedDomainInvariantWordsPhrase() {
     return `${DOMAIN_INVARIANT_WORDS.join(', ')}, or events-array .push(`;
 }
-export function referencesGuardOrPublish(source) {
+function referencesGuardOrPublish(source) {
     return DOMAIN_INVARIANT_WORD_RE.test(source) || DOMAIN_EVENTS_PUSH_RE.test(source);
 }
 export function isIdiomaticEventsReset(source, assignIndex, methodName) {
@@ -468,10 +468,10 @@ export function collectEmptyInvariantCatalogFindings(input) {
         },
     ];
 }
-export function isPersistenceDriverLayer(layer) {
+function isPersistenceDriverLayer(layer) {
     return layer === 'PersistenceAdapters';
 }
-export function sourceImportsPersistenceDriver(content, resolvedImports) {
+function sourceImportsPersistenceDriver(content, resolvedImports) {
     if (sourceImportsPersistenceDriverText(content))
         return true;
     if (!resolvedImports)
@@ -502,7 +502,9 @@ export function deriveArkRuleFileHints(_file, content, resolvedImports) {
     if (!content)
         return null;
     const hasIo = sourceImportsPersistenceDriver(content, resolvedImports);
-    const persistenceWrite = hasIo && sourceHasPersistenceWrite(content);
+    // A tagged-template SQL write head is evidence on its own (the use case composed
+    // the statement). ORM verbs and untagged SQL still need a driver import.
+    const persistenceWrite = (hasIo && sourceHasPersistenceWrite(content)) || sourceHasTaggedSqlWrite(content);
     // Orchestration/adapter heuristics need a longer window; writes still fire on short probes.
     if (content.length < 40) {
         return persistenceWrite ? { persistenceWrite: true } : null;

package/bin/lib/check-args.mjs

@@ -24,7 +24,9 @@ export const LOCAL_STRICT_MERGE_MESSAGE =
   '--local cannot be combined with --strict-merge: CI stays the full fail-closed check. Use --local (or ARK_CHECK_LOCAL=1) only on the local / pre-push path.';
 
 export const LOCAL_TREE_MODE_MESSAGE =
-  '--local cannot be combined with report modes that need the whole tree (--doctor, --coverage, --plan, --report, --promote) or with --update-baseline. Use --local --base <ref> for the cheap local check.';
+  '--local cannot be combined with report modes that need the whole tree (--doctor, --coverage, --plan, --report, --promote, --probe-invariants) or with --update-baseline. Use --local --base <ref> for the cheap local check.';
+
+const PROBE_RUNNERS = ['vitest', 'jest', 'node'];
 
 export const UPDATE_BASELINE_SCOPE_MESSAGE =
   '--update-baseline cannot be combined with a changed-files scope (--changed, --local, or a --persona that implies --changed): the baseline is a whole-tree record, and a changed-files scan would overwrite it with only that subset and delete every other frozen key. Drop the scope flag (ARK_CHECK_LOCAL=1 is ignored for a baseline update) and re-run.';
@@ -66,6 +68,7 @@ export function applyLocalCheckMode(args, env = process.env) {
     args.plan && '--plan',
     args.report && '--report',
     args.promote && '--promote',
+    args.probeInvariants && '--probe-invariants',
     args.updateBaseline && '--update-baseline',
   ].filter(Boolean);
   if (args.strictMerge) {
@@ -201,6 +204,24 @@ export function parseArgs(argv, env = process.env) {
         args.promote = next && !next.startsWith('-') ? argv[++i] : true;
       }
     }
+    else if (arg === '--probe-invariants' || arg.startsWith('--probe-invariants=')) {
+      // Same shape as --promote: bare probes every declared invariant; a value
+      // narrows to one id (`=<id>` also carries an id that begins with '-').
+      const eq = arg.indexOf('=');
+      if (eq > 0) {
+        args.probeInvariants = arg.slice(eq + 1) || true;
+      } else {
+        const next = argv[i + 1];
+        args.probeInvariants = next && !next.startsWith('-') ? argv[++i] : true;
+      }
+    }
+    else if (arg === '--runner') {
+      const value = requireValue(arg, i++).trim().toLowerCase();
+      if (!PROBE_RUNNERS.includes(value)) {
+        throw new Error(`--runner must be one of ${PROBE_RUNNERS.join(', ')} (got ${JSON.stringify(value)}).`);
+      }
+      args.runner = value;
+    }
     else if (arg === '--apply') args.apply = true;
     else if (arg === '--recommend') args.recommend = true;
     else if (arg === '--write-plan') args.writePlan = true;
@@ -307,8 +328,49 @@ export function parseArgs(argv, env = process.env) {
       );
     }
   }
+  assertProbeInvariantsAlone(args);
   if (args.updateBaseline && (args.changed || args.local)) {
     throw new Error(UPDATE_BASELINE_SCOPE_MESSAGE);
   }
   return applyLocalCheckMode(args, env);
 }
+
+/**
+ * ADR 0039 D1: the probe runs the project's own tests in a temporary copy, so
+ * it is never part of a check, the merge gate, status, or a changed-files scope.
+ * Every pairing that would put it on one of those paths is refused, and a
+ * report mode that answers first would make it silently do nothing.
+ */
+function assertProbeInvariantsAlone(args) {
+  if (args.runner && !args.probeInvariants) {
+    throw new Error('--runner applies to --probe-invariants. Run `arkgate-check --probe-invariants --runner <id>`.');
+  }
+  if (!args.probeInvariants) return;
+  const gatePaths = [
+    args.local && '--local',
+    args.changed && '--changed',
+    args.strictMerge && '--strict-merge',
+    args.updateBaseline && '--update-baseline',
+    args.doctor && '--doctor',
+  ].filter(Boolean);
+  if (gatePaths.length > 0) {
+    throw new Error(
+      `--probe-invariants cannot be combined with ${gatePaths.join(', ')}: the probe runs your tests in a temporary copy and is never part of a check, the merge gate, or status. Run it on its own.`
+    );
+  }
+  const shadowing = [
+    args.promote && '--promote',
+    args.sensors && '--sensors',
+    args.pathDrift && '--path-drift',
+    args.coverage && '--coverage',
+    args.plan && '--plan',
+    args.report && '--report',
+    args.rulesInventory && '--rules-inventory',
+    args.recommend && '--recommend',
+  ].filter(Boolean);
+  if (shadowing.length > 0) {
+    throw new Error(
+      `--probe-invariants cannot be combined with ${shadowing.join(', ')}: one of them would answer first and the other would silently do nothing. Run them separately.`
+    );
+  }
+}

package/bin/lib/ci-and-commands.mjs

@@ -16,24 +16,13 @@ import {
   buildAgentProjectionBlock,
 } from './agent-projection.mjs';
 import { getDiagnosticCatalogEntry } from './diagnostic-catalog.mjs';
-import { falseGreenAdoptionGap } from './field-install.mjs';
+import { addPackageJsonPropertyPreservingFormat } from './field-install.mjs';
 import { renderHostSupportMatrixMarkdown } from './host-support-matrix.mjs';
 import { PREFERRED_MCP_BIN } from './hook-templates.mjs';
 import { hasCheckArchitectureScript, readPackageJson } from './gate-files.mjs';
 import { arkPackageVersion } from './skill-install.mjs';
 import { arkgateIsProjectDependency, pinnedArkgateRunner } from './package-manager.mjs';
 
-// Field-install helpers re-exported for callers that import from this module.
-export {
-  ensureBaselineFlagInCheckCommand,
-  syncBaselineIntoCheckSurfaces,
-  pinArkgateDevDependency,
-  IO_DIR_SEGMENTS,
-  detectContractFalseGreenRisk,
-  FALSE_GREEN_GAP_ID,
-  falseGreenAdoptionGap,
-} from './field-install.mjs';
-
 export function checkArgsForRoot(root, { requireGates = false } = {}) {
   const baselineFlag = fs.existsSync(path.join(root, '.ark-baseline.json'))
     ? ' --baseline .ark-baseline.json'
@@ -42,7 +31,6 @@ export function checkArgsForRoot(root, { requireGates = false } = {}) {
   return `--root . --config ark.config.json ${profile}${baselineFlag}`;
 }
 
-
 export function packageManager(root) {
   const pm = localPackageManager(root);
   if (arkgateIsProjectDependency(root)) return pm;
@@ -114,65 +102,13 @@ export function checkArchitectureScriptSnippet(root) {
  * @param {string} scriptValue
  */
 function addPackageScriptPreservingFormat(source, scriptName, scriptValue) {
-  const multiline = /\r?\n/.test(source);
-  const eol = source.includes('\r\n') ? '\r\n' : '\n';
-  const rootPropertyIndent = source.match(/\r?\n([ \t]+)"[^"\n]+"\s*:/)?.[1] ?? '  ';
-  const indentUnit = rootPropertyIndent;
-  const encoded = JSON.stringify(scriptValue);
-  const key = JSON.stringify(scriptName);
-  const scriptsMatch = /"scripts"\s*:\s*\{/.exec(source);
-
-  if (scriptsMatch) {
-    const open = source.indexOf('{', scriptsMatch.index);
-    let depth = 0;
-    let quoted = false;
-    let escaped = false;
-    let close = -1;
-    for (let index = open; index < source.length; index += 1) {
-      const char = source[index];
-      if (quoted) {
-        if (escaped) escaped = false;
-        else if (char === '\\') escaped = true;
-        else if (char === '"') quoted = false;
-        continue;
-      }
-      if (char === '"') quoted = true;
-      else if (char === '{') depth += 1;
-      else if (char === '}' && --depth === 0) {
-        close = index;
-        break;
-      }
-    }
-    if (close === -1) throw new Error('Unbalanced package.json scripts object');
-    const body = source.slice(open + 1, close);
-    if (!multiline) {
-      const addition = body.trim() ? `,${key}:${encoded}` : `${key}:${encoded}`;
-      return `${source.slice(0, close)}${addition}${source.slice(close)}`;
-    }
-    const beforeClose = source.slice(0, close);
-    const trailing = beforeClose.match(/\s*$/)?.[0] ?? '';
-    const contentEnd = close - trailing.length;
-    const closingIndent = trailing.slice(trailing.lastIndexOf('\n') + 1);
-    const propertyIndent = `${closingIndent}${indentUnit}`;
-    const addition = body.trim()
-      ? `,${eol}${propertyIndent}${key}: ${encoded}`
-      : `${propertyIndent}${key}: ${encoded}`;
-    return `${source.slice(0, contentEnd)}${addition}${eol}${closingIndent}${source.slice(close)}`;
-  }
-
-  const rootClose = source.lastIndexOf('}');
-  if (rootClose === -1) throw new Error('Unbalanced package.json object');
-  const rootBody = source.slice(0, rootClose);
-  if (!multiline) {
-    const separator = rootBody.trim().endsWith('{') ? '' : ',';
-    return `${rootBody}${separator}"scripts":{${key}:${encoded}}${source.slice(rootClose)}`;
-  }
-  const trailing = rootBody.match(/\s*$/)?.[0] ?? '';
-  const contentEnd = rootClose - trailing.length;
-  const rootClosingIndent = trailing.slice(trailing.lastIndexOf('\n') + 1);
-  const separator = source.slice(0, contentEnd).trimEnd().endsWith('{') ? '' : ',';
-  const addition = `${separator}${eol}${rootPropertyIndent}"scripts": {${eol}${rootPropertyIndent}${indentUnit}${key}: ${encoded}${eol}${rootPropertyIndent}}`;
-  return `${source.slice(0, contentEnd)}${addition}${eol}${rootClosingIndent}${source.slice(rootClose)}`;
+  return addPackageJsonPropertyPreservingFormat(
+    source,
+    'scripts',
+    scriptName,
+    scriptValue,
+    'package.json scripts'
+  );
 }
 
 /**

package/bin/lib/ci-merge-boundary.mjs

@@ -6,7 +6,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 export const CI_MERGE_BOUNDARY_REL = '.ark/ci-merge-boundary.json';
-export const CI_MERGE_BOUNDARY_SCHEMA = '1.0';
+const CI_MERGE_BOUNDARY_SCHEMA = '1.0';
 
 /**
  * @param {{

package/bin/lib/class-source-scan.mjs

@@ -8,7 +8,7 @@
  * Pure CLI helper (bin/lib/class-source-scan.mjs). Zero Node I/O.
  */
 
-export const MEMBER_MODIFIERS = new Set([
+const MEMBER_MODIFIERS = new Set([
     'public',
     'private',
     'protected',
@@ -92,7 +92,7 @@ function skipRegexLiteral(src, index) {
  * Index after a string / comment / regex literal starting at `index`, or `index`
  * when none starts there.
  */
-export function skipStringOrComment(src, index) {
+function skipStringOrComment(src, index) {
     const ch = src[index];
     if (ch === '/' && src[index + 1] === '/') {
         const nl = src.indexOf('\n', index);
@@ -119,7 +119,7 @@ export function skipStringOrComment(src, index) {
     }
     return index;
 }
-export function skipWsAndComments(src, index) {
+function skipWsAndComments(src, index) {
     let i = index;
     while (i < src.length) {
         if (/\s/.test(src[i])) {
@@ -134,7 +134,7 @@ export function skipWsAndComments(src, index) {
     }
     return i;
 }
-export function readIdent(src, index) {
+function readIdent(src, index) {
     const ch = src[index];
     if (!ch || !/[A-Za-z_$]/.test(ch))
         return null;
@@ -148,7 +148,7 @@ export function readIdent(src, index) {
  * never closes. Strings and comments are skipped. For `<`/`>`, an arrow `=>` is not
  * a closing angle.
  */
-export function skipBalanced(src, openIndex, openCh, closeCh) {
+function skipBalanced(src, openIndex, openCh, closeCh) {
     if (src[openIndex] !== openCh)
         return null;
     let depth = 1;