@navecss/tokens 0.1.0 → 0.1.1

package/dist/core-contract.json

@@ -2,7 +2,7 @@
   "formatVersion": 1,
   "producer": {
     "name": "@navecss/core",
-    "version": "0.1.0"
+    "version": "0.1.1"
   },
   "tokens": [
     "--nave-border-width-focus",

package/dist/lib/bin.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { parseArgs } from 'node:util';
-import { build, DuplicateTokenNameRefusal, MissingContractTokensError, SeedIngestRefusal, TokenCollisionRefusal, UsageError, validate, } from "./facade.js";
+import { build, DuplicateTokenNameRefusal, formatVersionSkewFact, MissingContractTokensError, SeedIngestRefusal, TokenCollisionRefusal, UsageError, validate, } from "./facade.js";
 function normalizationQualifier(seedNormalization) {
     switch (seedNormalization) {
         case 'chroma-reduced': {
@@ -78,6 +78,12 @@ async function main() {
         }
         const result = await build(parseBuildArgs(rest));
         console.log(`Built from seed ${result.resolvedSeed}${normalizationQualifier(result.seedNormalization)}: ${result.files.join(', ')}`);
+        if (result.versionSkew) {
+            const { producerName, ...skew } = result.versionSkew;
+            console.error(`Version skew: ${formatVersionSkewFact(producerName, skew)}. The generated file may ` +
+                `not carry every custom-property name the installed ${producerName} reads. Reinstall ` +
+                `matching versions, then build again.`);
+        }
         return 0;
     }
     if (subcommand === 'validate') {

package/dist/lib/core-version.d.ts

@@ -1,3 +1,4 @@
+import type { CoreContractManifest, ManifestVersionSkew } from './theming/core-contract.ts';
 export type CoreVersionProbe = {
     status: 'resolved';
     version: string;
@@ -9,4 +10,7 @@ export type CoreVersionProbe = {
     message: string;
     status: 'unreadable';
 };
-export declare function resolveInstalledCoreVersion(): Promise<CoreVersionProbe>;
+export declare function detectVersionSkew(manifest: CoreContractManifest): Promise<{
+    probe: CoreVersionProbe;
+    skew: ManifestVersionSkew | undefined;
+}>;

package/dist/lib/core-version.js

@@ -1,5 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
+import { checkManifestVersionSkew } from "./theming/core-contract.js";
 function canResolveCoreDefaultEntry() {
     try {
         import.meta.resolve('@navecss/core');
@@ -9,7 +10,7 @@ function canResolveCoreDefaultEntry() {
         return false;
     }
 }
-export async function resolveInstalledCoreVersion() {
+async function resolveInstalledCoreVersion() {
     let resolved;
     try {
         resolved = import.meta.resolve('@navecss/core/package.json');
@@ -38,3 +39,8 @@ export async function resolveInstalledCoreVersion() {
         return { message: error.message, status: 'unreadable' };
     }
 }
+export async function detectVersionSkew(manifest) {
+    const probe = await resolveInstalledCoreVersion();
+    const skew = probe.status === 'resolved' ? checkManifestVersionSkew(manifest, probe.version) : undefined;
+    return { probe, skew };
+}

package/dist/lib/facade.d.ts

@@ -1,8 +1,10 @@
 import type { SeedNormalization } from './theming/color-math.ts';
+import type { ManifestVersionSkew } from './theming/core-contract.ts';
 export { DuplicateTokenNameRefusal, MissingContractTokensError, TokenCollisionRefusal, UsageError, } from './errors.ts';
 export type { SeedNormalization } from './theming/color-math.ts';
 export type { PerStepOverrides } from './theming/pipeline.ts';
 export { SeedIngestRefusal } from './theming/seed-ingest.ts';
+export { formatVersionSkewFact } from './validate-report.ts';
 export interface TokensBuildOptions {
     seed: string;
     source?: string;
@@ -14,6 +16,9 @@ export interface TokensBuildResult {
     seedNormalization: SeedNormalization;
     files: string[];
     collidingNames: string[];
+    versionSkew?: (ManifestVersionSkew & {
+        producerName: string;
+    }) | undefined;
 }
 export declare function build(options: TokensBuildOptions): Promise<TokensBuildResult>;
 export interface TokensValidateOptions {

package/dist/lib/facade.js

@@ -3,14 +3,14 @@ import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { writeOutputs } from "./builder.js";
 import { detectCollidingNames, refuseOnCollision } from "./collision.js";
-import { resolveInstalledCoreVersion } from "./core-version.js";
+import { detectVersionSkew } from "./core-version.js";
 import { composeDtcgOutputs } from "./dtcg-outputs.js";
 import { MissingContractTokensError, UsageError } from "./errors.js";
 import { readOverrides } from "./overrides.js";
 import { findPackageRoot } from "./package-root.js";
 import { formatOklch } from "./theming/color-math.js";
 import { composeConsumerBuild } from "./theming/consumer-build.js";
-import { checkManifestVersionSkew, validateAgainstManifest } from "./theming/core-contract.js";
+import { validateAgainstManifest } from "./theming/core-contract.js";
 import { shippedThemingPropertyNames } from "./theming/emit.js";
 import { parseSeed } from "./theming/seed-ingest.js";
 import { SHIPPED_SEEDS } from "./theming/shipped-seeds.js";
@@ -18,6 +18,7 @@ import { checkManifestFormatSupport, formatValidateReport } from "./validate-rep
 import { computeMissing, detectSourceKind, namesFromSource, splitMissingBySupply, } from "./validate.js";
 export { DuplicateTokenNameRefusal, MissingContractTokensError, TokenCollisionRefusal, UsageError, } from "./errors.js";
 export { SeedIngestRefusal } from "./theming/seed-ingest.js";
+export { formatVersionSkewFact } from "./validate-report.js";
 const PACKAGE_ROOT = findPackageRoot(import.meta.url);
 async function readManifest() {
     const raw = await readFile(path.join(PACKAGE_ROOT, 'dist', 'core-contract.json'), 'utf8');
@@ -37,6 +38,7 @@ export async function build(options) {
     const missing = validateAgainstManifest(manifest, emittedNames);
     if (missing.length > 0)
         throw new MissingContractTokensError(missing);
+    const { skew } = await detectVersionSkew(manifest);
     const theming = composeConsumerBuild({
         seedInputs: { primary },
         seeds: {
@@ -63,6 +65,7 @@ export async function build(options) {
             .map((file) => path.relative(options.outDir, file.destination))
             .toSorted((a, b) => a.localeCompare(b)),
         collidingNames,
+        versionSkew: skew === undefined ? undefined : { ...skew, producerName: manifest.producer.name },
     };
 }
 export async function validate(options) {
@@ -77,10 +80,7 @@ export async function validate(options) {
     const content = await readFile(options.source, 'utf8');
     const notDeclared = computeMissing(manifest, kind, content, { path: options.source });
     const { missing, supplied } = splitMissingBySupply(kind, notDeclared);
-    const coreProbe = await resolveInstalledCoreVersion();
-    const versionSkew = coreProbe.status === 'resolved'
-        ? checkManifestVersionSkew(manifest, coreProbe.version)
-        : undefined;
+    const { probe: coreProbe, skew: versionSkew } = await detectVersionSkew(manifest);
     const formatRefusal = checkManifestFormatSupport(manifest);
     const output = formatValidateReport(manifest, missing, versionSkew, { ...coreProbe, supplied });
     let exitCode;

package/dist/lib/theming/comment-open-tracker.js

@@ -1,15 +1,35 @@
 export function linesThatBeginInsideAnUnclosedComment(lines) {
     const beginningsInsideAnUnclosedComment = new Set();
-    let isInsideAnOpenComment = false;
-    for (const [index, line] of lines.entries()) {
-        if (isInsideAnOpenComment)
-            beginningsInsideAnUnclosedComment.add(index);
-        isInsideAnOpenComment = isLineStillInsideAnOpenCommentAfterScanning(line, isInsideAnOpenComment);
+    const readings = [
+        AS_THE_TOKENIZER_READS_IT,
+        RESUMING_PAST_AN_UNCLOSED_QUOTE,
+        RESUMING_WITH_NO_FURTHER_STRINGS,
+    ];
+    for (const reading of readings) {
+        let isInsideAnOpenComment = false;
+        for (const [index, line] of lines.entries()) {
+            if (isInsideAnOpenComment)
+                beginningsInsideAnUnclosedComment.add(index);
+            isInsideAnOpenComment = isLineStillInsideAnOpenComment(line, isInsideAnOpenComment, reading);
+        }
     }
     return beginningsInsideAnUnclosedComment;
 }
-function isLineStillInsideAnOpenCommentAfterScanning(line, wasInsideAnOpenComment) {
+const AS_THE_TOKENIZER_READS_IT = {
+    resumesAtEndOfLineAfterAnUnclosedQuote: true,
+    aLaterQuoteCanStillOpenAString: false,
+};
+const RESUMING_PAST_AN_UNCLOSED_QUOTE = {
+    resumesAtEndOfLineAfterAnUnclosedQuote: false,
+    aLaterQuoteCanStillOpenAString: true,
+};
+const RESUMING_WITH_NO_FURTHER_STRINGS = {
+    resumesAtEndOfLineAfterAnUnclosedQuote: false,
+    aLaterQuoteCanStillOpenAString: false,
+};
+function isLineStillInsideAnOpenComment(line, wasInsideAnOpenComment, reading) {
     let isInsideAnOpenComment = wasInsideAnOpenComment;
+    let hasPassedAnUnclosedQuoteOnThisLine = false;
     let cursor = 0;
     while (cursor < line.length) {
         if (isInsideAnOpenComment) {
@@ -21,8 +41,17 @@ function isLineStillInsideAnOpenCommentAfterScanning(line, wasInsideAnOpenCommen
             continue;
         }
         const character = line[cursor];
-        if (character === '"' || character === "'") {
-            cursor = indexAfterAStringLiteral(line, cursor, character);
+        const canThisQuoteOpenAString = isAQuoteCharacter(character) &&
+            (reading.aLaterQuoteCanStillOpenAString || !hasPassedAnUnclosedQuoteOnThisLine);
+        if (canThisQuoteOpenAString) {
+            const afterTheString = indexAfterAStringLiteral(line, cursor, character);
+            if (afterTheString === -1) {
+                hasPassedAnUnclosedQuoteOnThisLine = true;
+                cursor = reading.resumesAtEndOfLineAfterAnUnclosedQuote ? line.length : cursor + 1;
+            }
+            else {
+                cursor = afterTheString;
+            }
             continue;
         }
         if (line.startsWith('/*', cursor)) {
@@ -34,6 +63,9 @@ function isLineStillInsideAnOpenCommentAfterScanning(line, wasInsideAnOpenCommen
     }
     return isInsideAnOpenComment;
 }
+function isAQuoteCharacter(character) {
+    return character === '"' || character === "'";
+}
 function indexAfterAStringLiteral(line, quoteIndex, quote) {
     let cursor = quoteIndex + 1;
     while (cursor < line.length) {
@@ -45,5 +77,5 @@ function indexAfterAStringLiteral(line, quoteIndex, quote) {
             return cursor + 1;
         cursor += 1;
     }
-    return line.length;
+    return -1;
 }

package/dist/lib/theming/core-contract.js

@@ -1,13 +1,136 @@
 import { readdirSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 const NAVE_VAR_PATTERN = /var\((--nave-[a-z0-9-]+)/g;
-const BLOCK_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
+function isIdentifierChar(ch) {
+    return ch !== undefined && /[A-Za-z0-9_$-]/.test(ch);
+}
+function findSpanEnd(content, found, offset) {
+    return found === -1 ? content.length : found + offset;
+}
+function findUrlTokenEnd(content, start) {
+    let end = start;
+    while (end < content.length) {
+        const ch = content[end];
+        if (ch === '\\' && end + 1 < content.length && content[end + 1] !== '\n') {
+            end += 2;
+        }
+        else if (ch === ')') {
+            return end + 1;
+        }
+        else if (['\n', '"', "'"].includes(ch)) {
+            return end;
+        }
+        else {
+            end++;
+        }
+    }
+    return end;
+}
+function matchUrlToken(content, index) {
+    if (!/^url\(/i.test(content.slice(index, index + 4)))
+        return undefined;
+    if (isIdentifierChar(content[index - 1]))
+        return undefined;
+    let i = index + 4;
+    while (i < content.length && /\s/.test(content[i]))
+        i++;
+    if (content[i] === "'" || content[i] === '"')
+        return undefined;
+    return findUrlTokenEnd(content, index + 4);
+}
+function stepInString(content, index, stack) {
+    const frame = stack.at(-1);
+    const ch = content[index];
+    if (ch === '\\' && index + 1 < content.length) {
+        return { index: index + 2, out: ch + content[index + 1] };
+    }
+    if (ch === '\n' || ch === frame.quote)
+        stack.pop();
+    return { index: index + 1, out: ch };
+}
+function stepInTemplateText(content, index, stack) {
+    const ch = content[index];
+    if (ch === '\\' && index + 1 < content.length) {
+        return { index: index + 2, out: ch + content[index + 1] };
+    }
+    if (ch === '`') {
+        stack.pop();
+        return { index: index + 1, out: ch };
+    }
+    if (ch === '$' && content[index + 1] === '{') {
+        stack.push({ kind: 'interp', depth: 0 });
+        return { index: index + 2, out: '${' };
+    }
+    return { index: index + 1, out: ch };
+}
+function stepBraceInCode(ch, frame, stack) {
+    if (frame.kind !== 'interp')
+        return;
+    if (ch === '{')
+        frame.depth++;
+    else if (ch === '}' && frame.depth === 0)
+        stack.pop();
+    else if (ch === '}')
+        frame.depth--;
+}
+function didOpenQuoteOrTemplate(ch, stack) {
+    if (ch === '`') {
+        stack.push({ kind: 'template' });
+        return true;
+    }
+    if (ch === "'" || ch === '"') {
+        stack.push({ kind: 'string', quote: ch });
+        return true;
+    }
+    return false;
+}
+function trySkipCommentOrUrl(content, index) {
+    const ch = content[index];
+    if (ch === '/' && content[index + 1] === '*') {
+        return { index: findSpanEnd(content, content.indexOf('*/', index + 2), 2), out: '' };
+    }
+    if (ch === '/' && content[index + 1] === '/') {
+        return { index: findSpanEnd(content, content.indexOf('\n', index), 0), out: '' };
+    }
+    const urlEnd = matchUrlToken(content, index);
+    if (urlEnd !== undefined)
+        return { index: urlEnd, out: content.slice(index, urlEnd) };
+    return undefined;
+}
+function stepInCode(content, index, stack) {
+    const ch = content[index];
+    if (didOpenQuoteOrTemplate(ch, stack))
+        return { index: index + 1, out: ch };
+    const skipped = trySkipCommentOrUrl(content, index);
+    if (skipped)
+        return skipped;
+    stepBraceInCode(ch, stack.at(-1), stack);
+    return { index: index + 1, out: ch };
+}
+function step(content, index, stack) {
+    const frame = stack.at(-1);
+    if (frame.kind === 'string')
+        return stepInString(content, index, stack);
+    if (frame.kind === 'template')
+        return stepInTemplateText(content, index, stack);
+    return stepInCode(content, index, stack);
+}
+function stripComments(content) {
+    const stack = [{ kind: 'code' }];
+    let out = '';
+    let i = 0;
+    while (i < content.length) {
+        const result = step(content, i, stack);
+        out += result.out;
+        i = result.index;
+    }
+    return out;
+}
 const CONTRACT_AUDIT_PATTERN = /var\((--nave-[a-z0-9-]+)/g;
-const CONTRACT_AUDIT_BLOCK_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
 export function scanCoreContract(fileContents) {
     const found = new Set();
     for (const content of fileContents) {
-        const stripped = content.replaceAll(BLOCK_COMMENT_RE, '');
+        const stripped = stripComments(content);
         for (const match of stripped.matchAll(NAVE_VAR_PATTERN)) {
             found.add(match[1]);
         }
@@ -50,7 +173,7 @@ export function assertContractPreconditions(names, rawSourceText) {
     if (unprefixed.length > 0) {
         throw new StaleContractPreconditionError(`these scanned names are not yet prefixed --nave-: ${unprefixed.join(', ')}`);
     }
-    const stripped = rawSourceText.replaceAll(CONTRACT_AUDIT_BLOCK_COMMENT_RE, '');
+    const stripped = stripComments(rawSourceText);
     const referenced = new Set(stripped.matchAll(CONTRACT_AUDIT_PATTERN).map((match) => match[1]));
     const scanned = new Set(names);
     const unscanned = referenced.difference(scanned);

package/dist/lib/theming/guard-message-probes.js

@@ -1,4 +1,4 @@
-import { ADJACENCY, assertNoOrphanedSemanticSlot } from "./adjacency.js";
+import { ADJACENCY, assertCoverageFloor, assertNoFocusableAdjacentToActionFill, assertNoForbiddenAdjacency, assertNoOrphanedSemanticSlot, } from "./adjacency.js";
 import { assertContrastFloors, assertFloorProvenance, assertNoSameStepViolations, checkSameStepLint, runContrastHarness, } from "./contrast.js";
 import { assertNoticeIsEmitted, RETHEMING_NOTICE } from "./copy-lint.js";
 import { TINT_SEED_COMMENT_STEM } from "./emit.js";
@@ -59,6 +59,23 @@ export const ACCESSIBILITY_GUARD_MESSAGE_PROBES = [
         label: 'the orphaned-semantic-slot output',
         capture: () => capturedFailureMessage(() => assertNoOrphanedSemanticSlot(['content.brandNew'])),
     },
+    {
+        label: 'the adjacency coverage-floor output',
+        capture: () => capturedFailureMessage(() => assertCoverageFloor(ADJACENCY.filter((a) => a.subject !== 'border.control'))),
+    },
+    {
+        label: 'the forbidden-adjacency output',
+        capture: () => capturedFailureMessage(() => assertNoForbiddenAdjacency([
+            { subject: 'content.secondary', against: 'surface.inverse', class: 'text' },
+        ])),
+    },
+    {
+        label: 'the focusable-adjacent-to-action-fill output',
+        capture: () => capturedFailureMessage(() => assertNoFocusableAdjacentToActionFill([
+            ...ADJACENCY,
+            { subject: 'border.focus', against: 'action.primary', class: 'non-text' },
+        ])),
+    },
     {
         label: "the same-step lint's real violation output (build-step.ts's runResultGuards)",
         capture: () => {

package/dist/lib/validate-report.d.ts

@@ -14,6 +14,7 @@ export type CoreVersionReportStatus = {
     message: string;
     status: 'unreadable';
 };
+export declare function formatVersionSkewFact(producerName: string, versionSkew: ManifestVersionSkew): string;
 export declare function formatValidateReport(manifest: CoreContractManifest, missing: readonly string[], versionSkew: ManifestVersionSkew | undefined, coreVersionStatus?: CoreVersionReportStatus & {
     supplied?: readonly string[];
 }): string[];

package/dist/lib/validate-report.js

@@ -7,6 +7,11 @@ export function checkManifestFormatSupport(manifest) {
 const NAMESPACE_PREAMBLE = 'Contract names below are the emitted CSS custom-property spelling (for example ' +
     '--nave-color-surface-base). Your DTCG 2025.10 source names the same node with the "--nave-" ' +
     'prefix dropped and hyphens read as a dotted path (color.surface.base).';
+export function formatVersionSkewFact(producerName, versionSkew) {
+    return (`the core contract this @navecss/tokens ships was recorded against ` +
+        `${producerName}@${versionSkew.recorded}, but the installed ${producerName} is ` +
+        `@${versionSkew.installed}`);
+}
 const SCOPE_STATEMENT = 'This check is one-directional: it reports every core contract name missing from your ' +
     'source. A token in your source beyond the contract is never an error.';
 const NO_INSTALLED_CORE_DISCLAIMER = 'No installed @navecss/core was found, so no version-skew check ran.';
@@ -79,9 +84,8 @@ export function formatValidateReport(manifest, missing, versionSkew, coreVersion
     }
     if (versionSkew) {
         return [
-            `Version skew: this manifest was recorded against ${manifest.producer.name}@` +
-                `${versionSkew.recorded}, but the installed ${manifest.producer.name} is @` +
-                `${versionSkew.installed}. Reinstall matching versions before trusting this result.`,
+            `Version skew: ${formatVersionSkewFact(manifest.producer.name, versionSkew)}. Reinstall ` +
+                `matching versions before trusting this result.`,
         ];
     }
     return [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navecss/tokens",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "DTCG 2025.10 design tokens for Nave: seed-derived semantic colours, typography, spacing, and the rest of the token layer, built by a first-party DTCG 2025.10 reader.",
   "keywords": [
     "css",