@astrale-os/kernel-dsl 1.0.0-beta.11 → 1.0.0-beta.13

package/dist/v1/language/value/profile/rules.js

@@ -4,6 +4,7 @@ import { blob, BLOB_VALUE_KIND } from '../model/blob.js';
 import { isValueObject as isJsonObject } from '../model/object.js';
 import { VALUE_SCHEMA_DIALECT } from '../model/schema.js';
 import { refuseIRegexp, stateBudgetMessage } from '../regexp/syntax.js';
+import { escapePointerToken } from '../syntax/pointer.js';
 import { walkSchema } from '../syntax/walk.js';
 import { FORBIDDEN_DYNAMIC_KEYWORDS, STANDARD_SCHEMA_KEYWORDS } from './vocabulary.js';
 export function validateSchemaProfile(schema, context, pointer) {
@@ -14,10 +15,10 @@ export function validateSchemaProfile(schema, context, pointer) {
         const currentPointer = `${pointer}${location.pointer}`;
         for (const keyword of Object.keys(location.schema)) {
             if (!STANDARD_SCHEMA_KEYWORDS.has(keyword)) {
-                diagnostics.push(diagnostic('VS_KEYWORD_CLOSED', `${currentPointer}/${escapeToken(keyword)}`, `Keyword ${keyword} is outside the closed V1 Draft 2020-12 vocabulary.`));
+                diagnostics.push(diagnostic('VS_KEYWORD_CLOSED', `${currentPointer}/${escapePointerToken(keyword)}`, `Keyword ${keyword} is outside the closed V1 Draft 2020-12 vocabulary.`));
             }
             if (FORBIDDEN_DYNAMIC_KEYWORDS.has(keyword)) {
-                diagnostics.push(diagnostic('VS_DYNAMIC_FORBIDDEN', `${currentPointer}/${escapeToken(keyword)}`, `Keyword ${keyword} is forbidden by V1.`));
+                diagnostics.push(diagnostic('VS_DYNAMIC_FORBIDDEN', `${currentPointer}/${escapePointerToken(keyword)}`, `Keyword ${keyword} is forbidden by V1.`));
             }
         }
         if (Object.hasOwn(location.schema, '$schema')) {
@@ -86,7 +87,7 @@ function validateSemanticSets(schema, pointer, diagnostics) {
     if (isJsonObject(schema.dependentRequired)) {
         for (const [name, dependencies] of Object.entries(schema.dependentRequired)) {
             if (Array.isArray(dependencies)) {
-                rejectPrimitiveDuplicates(dependencies, `${pointer}/dependentRequired/${escapeToken(name)}`, 'dependentRequired', diagnostics);
+                rejectPrimitiveDuplicates(dependencies, `${pointer}/dependentRequired/${escapePointerToken(name)}`, 'dependentRequired', diagnostics);
             }
         }
     }
@@ -103,7 +104,7 @@ function validateRegexes(schema, pointer, diagnostics) {
     }
     if (isJsonObject(schema.patternProperties)) {
         for (const pattern of Object.keys(schema.patternProperties)) {
-            portableRegex(pattern, `${pointer}/patternProperties/${escapeToken(pattern)}`, 'A patternProperties key', 'patternProperties keys must satisfy RFC 9485 I-Regexp syntax.', diagnostics);
+            portableRegex(pattern, `${pointer}/patternProperties/${escapePointerToken(pattern)}`, 'A patternProperties key', 'patternProperties keys must satisfy RFC 9485 I-Regexp syntax.', diagnostics);
         }
     }
 }
@@ -140,6 +141,3 @@ function rejectCanonicalDuplicates(values, pointer, name, diagnostics) {
         seen.add(key);
     }
 }
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/language/value/profile/validate.js

@@ -1,4 +1,4 @@
-import { compareUnicode } from '../../../addressing/ordering.js';
+import { orderAndDeduplicate } from '../../validation/diagnostic.js';
 import { collectResourceClosure } from '../reference/closure.js';
 import { validateProductiveRecursion } from '../reference/recursion.js';
 import { hasNodeDefinition, indexRegistry } from '../reference/registry.index.js';
@@ -28,12 +28,3 @@ export function validateValueSchema(schema, context, registry, pointer = '') {
     diagnostics.push(...validateProductiveRecursion(closure.resources, closure.resolutions));
     return orderAndDeduplicate(diagnostics);
 }
-function orderAndDeduplicate(diagnostics) {
-    const unique = new Map();
-    for (const value of diagnostics) {
-        unique.set(`${value.pointer}\u0000${value.code}\u0000${value.ref ?? ''}\u0000${value.message}`, value);
-    }
-    return [...unique.values()].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
-        compareUnicode(left.code, right.code) ||
-        compareUnicode(left.message, right.message));
-}

package/dist/v1/language/value/reference/recursion.js

@@ -1,8 +1,7 @@
 import { diagnostic } from '../../validation/diagnostic.js';
 import { isValueObject as isJsonObject } from '../model/object.js';
-import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../syntax/keywords.js';
 import { appendPointer } from '../syntax/pointer.js';
-import { isJsonSchema, walkSchema } from '../syntax/walk.js';
+import { forEachSubschema, walkSchema } from '../syntax/walk.js';
 import { locationKey } from './closure.js';
 export const CONSUMING_SCHEMA_KEYWORDS = new Set([
     'additionalProperties',
@@ -43,26 +42,7 @@ export function validateProductiveRecursion(resources, resolutions) {
             for (const [keyword, value] of Object.entries(location.schema)) {
                 if (!NON_CONSUMING_SCHEMA_KEYWORDS.has(keyword))
                     continue;
-                const keywordPointer = appendPointer(location.pointer, keyword);
-                if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
-                    outgoing.add(locationKey(resource.key, keywordPointer));
-                    continue;
-                }
-                if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
-                    value.forEach((entry, index) => {
-                        if (isJsonSchema(entry)) {
-                            outgoing.add(locationKey(resource.key, appendPointer(keywordPointer, index)));
-                        }
-                    });
-                    continue;
-                }
-                if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
-                    for (const [name, entry] of Object.entries(value)) {
-                        if (isJsonSchema(entry)) {
-                            outgoing.add(locationKey(resource.key, appendPointer(keywordPointer, name)));
-                        }
-                    }
-                }
+                forEachSubschema(keyword, value, appendPointer(location.pointer, keyword), (_, at) => outgoing.add(locationKey(resource.key, at)));
             }
         });
     }

package/dist/v1/language/value/syntax/pointer.d.ts

@@ -1,3 +1,5 @@
+/** Escape one JSON Pointer reference token: `~` as `~0`, then `/` as `~1`. */
+export declare function escapePointerToken(token: string): string;
 export declare function appendPointer(pointer: string, token: string | number): string;
 export declare function parseJsonPointerFragment(fragment: string): readonly string[] | undefined;
 export declare function tokensToPointer(tokens: readonly string[]): string;

package/dist/v1/language/value/syntax/pointer.js

@@ -1,6 +1,9 @@
+/** Escape one JSON Pointer reference token: `~` as `~0`, then `/` as `~1`. */
+export function escapePointerToken(token) {
+    return token.replaceAll('~', '~0').replaceAll('/', '~1');
+}
 export function appendPointer(pointer, token) {
-    const encoded = String(token).replaceAll('~', '~0').replaceAll('/', '~1');
-    return `${pointer}/${encoded}`;
+    return `${pointer}/${escapePointerToken(String(token))}`;
 }
 export function parseJsonPointerFragment(fragment) {
     if (!fragment.startsWith('#'))

package/dist/v1/language/value/syntax/walk.d.ts

@@ -6,5 +6,7 @@ export interface SchemaLocation {
     readonly parentKeyword?: string;
 }
 export declare function walkSchema(schema: JsonSchema, visit: (location: SchemaLocation) => void, pointer?: string): void;
+/** Visit each subschema `keyword` holds directly, with its pointer under `pointer`. */
+export declare function forEachSubschema(keyword: string, value: unknown, pointer: string, visit: (schema: JsonSchema, pointer: string) => void): void;
 export declare function collectSchemaPointers(schema: JsonSchema): ReadonlySet<string>;
 export declare function isJsonSchema(value: unknown): value is JsonSchema;

package/dist/v1/language/value/syntax/walk.js

@@ -14,26 +14,7 @@ export function walkSchema(schema, visit, pointer = '') {
             if (!isJsonObject(current))
                 return;
             for (const [keyword, value] of Object.entries(current)) {
-                const keywordPointer = appendPointer(currentPointer, keyword);
-                if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
-                    walk(value, keywordPointer, depth + 1, keyword);
-                    continue;
-                }
-                if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
-                    value.forEach((entry, index) => {
-                        if (isJsonSchema(entry)) {
-                            walk(entry, appendPointer(keywordPointer, index), depth + 1, keyword);
-                        }
-                    });
-                    continue;
-                }
-                if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
-                    for (const [name, entry] of Object.entries(value)) {
-                        if (isJsonSchema(entry)) {
-                            walk(entry, appendPointer(keywordPointer, name), depth + 1, keyword);
-                        }
-                    }
-                }
+                forEachSubschema(keyword, value, appendPointer(currentPointer, keyword), (entry, at) => walk(entry, at, depth + 1, keyword));
             }
         }
         finally {
@@ -43,6 +24,24 @@ export function walkSchema(schema, visit, pointer = '') {
     }
     walk(schema, pointer, 0);
 }
+/** Visit each subschema `keyword` holds directly, with its pointer under `pointer`. */
+export function forEachSubschema(keyword, value, pointer, visit) {
+    if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
+        visit(value, pointer);
+    }
+    else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+        value.forEach((entry, index) => {
+            if (isJsonSchema(entry))
+                visit(entry, appendPointer(pointer, index));
+        });
+    }
+    else if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
+        for (const [name, entry] of Object.entries(value)) {
+            if (isJsonSchema(entry))
+                visit(entry, appendPointer(pointer, name));
+        }
+    }
+}
 export function collectSchemaPointers(schema) {
     const pointers = new Set();
     walkSchema(schema, ({ pointer }) => pointers.add(pointer));

package/dist/v1/schema/compatibility/diff.js

@@ -1,5 +1,6 @@
 import { compareUnicode } from '../../addressing/ordering.js';
 import { isValueObject as isJsonObject } from '../../language/value/model/object.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 /** Structural differences between two portable values, leaf by leaf, in JSON Pointer order. */
 export function differences(before, after) {
     const found = [];
@@ -17,7 +18,7 @@ function collect(before, after, path, found) {
     if (isJsonObject(before) && isJsonObject(after)) {
         const keys = [...new Set([...Object.keys(before), ...Object.keys(after)])].sort(compareUnicode);
         for (const key of keys) {
-            collect(before[key], after[key], `${path}/${escape(key)}`, found);
+            collect(before[key], after[key], `${path}/${escapePointerToken(key)}`, found);
         }
         return;
     }
@@ -34,6 +35,3 @@ function collect(before, after, path, found) {
         ...(after === undefined ? {} : { after }),
     }));
 }
-function escape(segment) {
-    return segment.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/schema/compatibility/meaning/footprint.js

@@ -1,59 +1,25 @@
-import { Key } from '../../../addressing/index.js';
-import { compareAddedProperties, compareLostProperties } from '../comparators/classes.js';
-import { compareFacet } from '../comparators/index.js';
-import { contextInvalid } from '../context.js';
 import { callableReferences, classReferences, inherits, memberReferences, valueReferences, } from '../references.js';
+import { walkReferences } from '../walk.js';
 /** Meaning follows complete callable contracts through the exact authored reference closure. */
 export function compareFootprint({ context, report, }) {
-    const queue = [...context.roots];
-    const visited = new Set();
-    for (const reference of queue) {
-        report.note(reference);
-        const { coordinate, usage } = reference;
-        const visit = `${coordinate.key}:${usage.relation}`;
-        if (visited.has(visit))
-            continue;
-        visited.add(visit);
-        const pair = context.pair(coordinate);
-        const subject = pair.source;
-        if (subject === undefined)
-            throw contextInvalid(`Retained acceptance context has no meaning for ${coordinate.key}.`, coordinate.key);
-        let facet;
+    walkReferences({ context, report }, (subject, { usage }, reach) => {
         switch (subject.kind) {
-            case 'class': {
-                facet = inherits(usage) ? 'class.inherit' : 'class.reference';
-                queue.push(...classReferences(subject, false));
+            case 'class':
+                reach(...classReferences(subject, false));
                 if (inherits(usage))
-                    queue.push(...classReferences(subject, true));
-                break;
-            }
+                    reach(...classReferences(subject, true));
+                return inherits(usage) ? 'class.inherit' : 'class.reference';
             case 'property':
-                facet = 'property';
-                queue.push(...valueReferences(subject));
-                break;
+                reach(...valueReferences(subject));
+                return 'property';
             case 'method':
-                facet = 'method.signature';
-                queue.push(...callableReferences(subject));
-                break;
-            case 'member': {
-                facet =
-                    subject.coordinate.ref.kind === 'function'
-                        ? 'function.signature'
-                        : subject.coordinate.ref.kind;
-                queue.push(...memberReferences(subject));
-            }
+                reach(...callableReferences(subject));
+                return 'method.signature';
+            case 'member':
+                reach(...memberReferences(subject));
+                return subject.coordinate.ref.kind === 'function'
+                    ? 'function.signature'
+                    : subject.coordinate.ref.kind;
         }
-        if (Key.origin(coordinate.key) !== context.source.origin)
-            continue;
-        report.record({
-            pair,
-            facet,
-            ...compareFacet({ context, pair, facet }),
-            requirement: { kind: facet },
-        });
-        if (facet === 'class.inherit')
-            compareAddedProperties({ context, pair, report });
-        if (subject.kind === 'class')
-            compareLostProperties({ pair, report });
-    }
+    });
 }

package/dist/v1/schema/compatibility/structure/requirements.js

@@ -1,79 +1,47 @@
-import { Key } from '../../../addressing/index.js';
 import { inheritanceOf } from '../../../language/class/inheritance.js';
-import { compareAddedProperties, compareLostProperties, inheritanceMeaning, } from '../comparators/classes.js';
+import { inheritanceMeaning } from '../comparators/classes.js';
 import { compareFacet } from '../comparators/index.js';
 import { fingerprintMeaning } from '../comparators/values.js';
 import { contextInvalid } from '../context.js';
 import { methodCoordinate } from '../coordinate.js';
 import { closedParents } from '../extension.js';
 import { callableReferences, classReferences, inherits, memberReferences, usageOf, valueReferences, } from '../references.js';
+import { walkReferences } from '../walk.js';
 /** Structure follows data and abstract obligations; concrete IO never expands its requirements. */
 export function compareRequirements({ context, report, }) {
-    const queue = [...context.roots];
-    const visited = new Set();
-    for (const reference of queue) {
-        report.note(reference);
-        const { coordinate, usage } = reference;
-        const visit = `${coordinate.key}:${usage.relation}`;
-        if (visited.has(visit))
-            continue;
-        visited.add(visit);
-        const pair = context.pair(coordinate);
-        const subject = pair.source;
-        if (subject === undefined)
-            throw contextInvalid(`Retained acceptance context has no meaning for ${coordinate.key}.`, coordinate.key);
-        let facet;
+    walkReferences({ context, report }, (subject, { coordinate, usage }, reach) => {
         switch (subject.kind) {
-            case 'class': {
-                facet = inherits(usage) ? 'class.inherit' : 'class.reference';
-                queue.push(...classReferences(subject, false));
+            case 'class':
+                reach(...classReferences(subject, false));
                 if (inherits(usage)) {
-                    queue.push(...classReferences(subject, true));
+                    reach(...classReferences(subject, true));
                     for (const method of subject.analysis.requirements.values())
-                        queue.push({
+                        reach({
                             coordinate: methodCoordinate(method.owner, method.name),
                             usage: usageOf(subject.schema, 'abstract', coordinate.key),
                         });
                 }
-                break;
-            }
+                return inherits(usage) ? 'class.inherit' : 'class.reference';
             case 'property':
-                facet = 'property';
-                queue.push(...valueReferences(subject));
-                break;
-            case 'method': {
-                facet = usage.relation === 'abstract' ? 'method.inheritance' : 'method.existence';
-                if (facet === 'method.inheritance')
-                    queue.push(...callableReferences(subject));
-                break;
-            }
-            case 'member': {
-                facet =
-                    subject.coordinate.ref.kind === 'function'
-                        ? 'function.existence'
-                        : subject.coordinate.ref.kind;
-                if (facet !== 'function.existence')
-                    queue.push(...memberReferences(subject));
-            }
+                reach(...valueReferences(subject));
+                return 'property';
+            case 'method':
+                if (usage.relation !== 'abstract')
+                    return 'method.existence';
+                reach(...callableReferences(subject));
+                return 'method.inheritance';
+            case 'member':
+                if (subject.coordinate.ref.kind === 'function')
+                    return 'function.existence';
+                reach(...memberReferences(subject));
+                return subject.coordinate.ref.kind;
         }
-        if (Key.origin(coordinate.key) !== context.source.origin)
-            continue;
-        // Class membership does not establish an invocation dependency. Explicit member selection,
-        // a Method the dependent declares as a capability, and inherited abstract obligations do.
-        const required = facet !== 'method.existence' ||
-            usage.relation === 'selection' ||
-            usage.relation === 'capability';
-        report.record({
-            pair,
-            facet,
-            ...compareFacet({ context, pair, facet }),
-            ...(required ? { requirement: { kind: facet } } : {}),
-        });
-        if (facet === 'class.inherit')
-            compareAddedProperties({ context, pair, report });
-        if (subject.kind === 'class')
-            compareLostProperties({ pair, report });
-    }
+    }, 
+    // Class membership does not establish an invocation dependency. Explicit member selection,
+    // a Method the dependent declares as a capability, and inherited abstract obligations do.
+    (facet, usage) => facet !== 'method.existence' ||
+        usage.relation === 'selection' ||
+        usage.relation === 'capability');
     compareReliance({ context, report });
     compareExtension({ context, report });
 }

package/dist/v1/schema/compatibility/walk.d.ts

@@ -0,0 +1,17 @@
+import type { Usage } from './model.js';
+import type { Reference } from './references.js';
+import type { Report } from './report.js';
+import type { ComparisonContext } from './scope.js';
+import type { ResolvedSubject } from './subjects.js';
+import { compareFacet } from './comparators/index.js';
+type WalkedFacet = Parameters<typeof compareFacet>[0]['facet'];
+/**
+ * Follow the reference closure from the roots once per coordinate and usage relation. `expand`
+ * names the facet a reached subject is compared under and `reach`es what it references; a subject
+ * of the compared origin is then recorded, as a requirement when `required` says so.
+ */
+export declare function walkReferences({ context, report }: {
+    readonly context: ComparisonContext;
+    readonly report: Report;
+}, expand: (subject: ResolvedSubject, reference: Reference, reach: (...references: readonly Reference[]) => void) => WalkedFacet, required?: (facet: WalkedFacet, usage: Usage) => boolean): void;
+export {};

package/dist/v1/schema/compatibility/walk.js

@@ -0,0 +1,41 @@
+import { Key } from '../../addressing/index.js';
+import { compareAddedProperties, compareLostProperties } from './comparators/classes.js';
+import { compareFacet } from './comparators/index.js';
+import { contextInvalid } from './context.js';
+/**
+ * Follow the reference closure from the roots once per coordinate and usage relation. `expand`
+ * names the facet a reached subject is compared under and `reach`es what it references; a subject
+ * of the compared origin is then recorded, as a requirement when `required` says so.
+ */
+export function walkReferences({ context, report }, expand, required = () => true) {
+    const queue = [...context.roots];
+    const reach = (...references) => {
+        queue.push(...references);
+    };
+    const visited = new Set();
+    for (const reference of queue) {
+        report.note(reference);
+        const { coordinate, usage } = reference;
+        const visit = `${coordinate.key}:${usage.relation}`;
+        if (visited.has(visit))
+            continue;
+        visited.add(visit);
+        const pair = context.pair(coordinate);
+        const subject = pair.source;
+        if (subject === undefined)
+            throw contextInvalid(`Retained acceptance context has no meaning for ${coordinate.key}.`, coordinate.key);
+        const facet = expand(subject, reference, reach);
+        if (Key.origin(coordinate.key) !== context.source.origin)
+            continue;
+        report.record({
+            pair,
+            facet,
+            ...compareFacet({ context, pair, facet }),
+            ...(required(facet, usage) ? { requirement: { kind: facet } } : {}),
+        });
+        if (facet === 'class.inherit')
+            compareAddedProperties({ context, pair, report });
+        if (subject.kind === 'class')
+            compareLostProperties({ pair, report });
+    }
+}

package/dist/v1/schema/diagnostic.js

@@ -1,21 +1,13 @@
-import { compareUnicode } from '../addressing/ordering.js';
+import { formatDiagnostics, orderDiagnostics } from '../language/validation/diagnostic.js';
 export function diagnostic(code, pointer, message, ref) {
     return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
 }
 export class SchemaError extends Error {
     diagnostics;
     constructor(diagnostics) {
-        const ordered = [...diagnostics].sort(compareDiagnostic);
-        super(ordered.map(formatDiagnostic).join('\n'));
+        const ordered = orderDiagnostics(diagnostics);
+        super(formatDiagnostics(ordered));
         this.name = 'SchemaError';
         this.diagnostics = Object.freeze(ordered);
     }
 }
-function compareDiagnostic(left, right) {
-    return (compareUnicode(left.pointer, right.pointer) ||
-        compareUnicode(left.code, right.code) ||
-        compareUnicode(left.message, right.message));
-}
-function formatDiagnostic(value) {
-    return `${value.pointer || '/'} [${value.code}] ${value.message}`;
-}

package/dist/v1/schema/resolution/context.js

@@ -1,6 +1,7 @@
 import { dependencyLimits } from '../../addressing/domain-dependency.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { DOMAIN_REVISION_PATTERN } from '../../addressing/patterns.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { revisionOfDomainSchema } from '../canonical/revision.js';
 import { diagnostic } from '../diagnostic.js';
 import { indexSchemaDefinitions } from './definition.index.js';
@@ -14,7 +15,7 @@ export function buildDomainResolutionContext(candidate, lookup) {
         diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/dependencies', `A Domain may declare at most ${dependencyLimits.direct} direct dependency aliases.`));
     }
     for (const [alias, dependency] of Object.entries(candidate.dependencies)) {
-        const pointer = `/dependencies/${escapeToken(alias)}`;
+        const pointer = `/dependencies/${escapePointerToken(alias)}`;
         if (!DOMAIN_REVISION_PATTERN.test(dependency.revision))
             continue;
         if (dependency.origin === candidate.origin) {
@@ -94,7 +95,7 @@ function loadDependencyClosure(candidate, dependencies, lookup, diagnostics) {
             continue;
         }
         const [alias, dependency] = edge;
-        const pointer = frames.length === 1 ? `/dependencies/${escapeToken(alias)}` : '/dependencies';
+        const pointer = frames.length === 1 ? `/dependencies/${escapePointerToken(alias)}` : '/dependencies';
         if (activeOrigins.has(dependency.origin)) {
             diagnostics.push(diagnostic('DV_DEPENDENCY_ACYCLIC', pointer, `Dependency cycle reaches ${dependency.origin}.`));
             continue;
@@ -153,6 +154,3 @@ function validateDependencyUse(candidate, directOrigins, diagnostics) {
         }
     }
 }
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/schema/validation/callable.js

@@ -1,11 +1,12 @@
 import { isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS, } from '../../language/callable/admission.js';
 import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { diagnostic } from '../diagnostic.js';
 /** Validate the execution modifier and admission age of every local Function and Node Method. */
 export function validateCallables(schema) {
     const diagnostics = [];
     for (const [name, declaration] of Object.entries(schema.functions)) {
-        const pointer = `/functions/${escapePointer(name)}`;
+        const pointer = `/functions/${escapePointerToken(name)}`;
         validateExecution(declaration, pointer, diagnostics);
         validateAdmission(declaration, pointer, diagnostics);
     }
@@ -13,7 +14,7 @@ export function validateCallables(schema) {
         if (declaration.kind !== 'node')
             continue;
         for (const [method, value] of Object.entries(declaration.methods)) {
-            const pointer = `/classes/${escapePointer(name)}/methods/${escapePointer(method)}`;
+            const pointer = `/classes/${escapePointerToken(name)}/methods/${escapePointerToken(method)}`;
             validateExecution(value, pointer, diagnostics);
             validateAdmission(value, pointer, diagnostics);
         }
@@ -49,6 +50,3 @@ function validateExecution(declaration, pointer, diagnostics) {
         diagnostics.push(diagnostic('DV_CALLABLE_IO', `${pointer}/output/mode`, 'A durable callable requires a value output.'));
     }
 }
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}