@astrale-os/kernel-dsl 0.2.0-beta.37 → 0.2.0-beta.39

package/dist/v1/language/value/evaluate/preparation.js

@@ -6,7 +6,7 @@ import { loadPattern } from '../regexp/matcher.js';
 import { appendPointer } from '../syntax/pointer.js';
 import { walkSchema } from '../syntax/walk.js';
 /** Prepare reference and linear-regexp state without generating executable source. */
-export function prepareValueSchema(schema, registry, pointer) {
+export function prepareValueSchema(schema, registry, pointer, pool = new Map()) {
     const indexed = indexRegistry(registry, pointer);
     if (indexed.diagnostics.length > 0)
         return failed(indexed.diagnostics);
@@ -26,11 +26,11 @@ export function prepareValueSchema(schema, registry, pointer) {
             });
             if (!isJsonObject(location.schema))
                 return;
-            rememberMatcher(matchers, location.schema.pattern);
-            rememberMatcher(matchers, location.schema.fullMatch);
+            rememberMatcher(matchers, pool, location.schema.pattern);
+            rememberMatcher(matchers, pool, location.schema.fullMatch);
             if (isJsonObject(location.schema.patternProperties)) {
                 for (const pattern of Object.keys(location.schema.patternProperties)) {
-                    rememberMatcher(matchers, pattern);
+                    rememberMatcher(matchers, pool, pattern);
                 }
             }
         });
@@ -40,13 +40,14 @@ export function prepareValueSchema(schema, registry, pointer) {
     if (root === undefined) {
         return { compiled: false, message: 'The root value schema is absent from its closure.' };
     }
+    let program;
     return {
         compiled: true,
         value: {
             root,
             locations,
             resolutions: closure.resolutions,
-            program: () => portableProgram(root, locations, closure.resolutions),
+            program: () => (program ??= portableProgram(root, locations, closure.resolutions, matchers)),
             child(location, keyword, member) {
                 const keywordPointer = appendPointer(location.pointer, keyword);
                 const pointer = member === undefined ? keywordPointer : appendPointer(keywordPointer, member);
@@ -67,15 +68,14 @@ export function prepareValueSchema(schema, registry, pointer) {
                 if (matcher === undefined) {
                     throw new TypeError('Value schema uses an unprepared I-Regexp source.');
                 }
-                return matcher;
+                return matcher.matcher;
             },
         },
     };
 }
-function portableProgram(root, locations, resolutions) {
+function portableProgram(root, locations, resolutions, patterns) {
     const ordered = [...locations.values()];
     const indices = new Map(ordered.map((location, index) => [location.key, index]));
-    const patterns = new Map();
     const nodes = ordered.map((location) => {
         const children = {};
         walkSchema(location.schema, (child) => {
@@ -85,7 +85,6 @@ function portableProgram(root, locations, resolutions) {
             if (target !== undefined)
                 children[childKey(child.pointer)] = target;
         });
-        rememberPattern(patterns, location.schema);
         const resolved = resolutions.get(location.key);
         const reference = resolved === undefined
             ? undefined
@@ -102,29 +101,21 @@ function portableProgram(root, locations, resolutions) {
     return Object.freeze({
         root: indices.get(root.key),
         nodes: Object.freeze(nodes),
-        patterns: Object.freeze([...patterns.values()]),
+        patterns: Object.freeze([...patterns.values()].map(({ pattern }) => pattern)),
     });
 }
-function rememberPattern(patterns, schema) {
-    if (!isJsonObject(schema))
-        return;
-    for (const source of [schema.pattern, schema.fullMatch]) {
-        if (typeof source === 'string' && !patterns.has(source))
-            patterns.set(source, compilePattern(source));
-    }
-    if (isJsonObject(schema.patternProperties)) {
-        for (const source of Object.keys(schema.patternProperties)) {
-            if (!patterns.has(source))
-                patterns.set(source, compilePattern(source));
-        }
-    }
-}
 export function childKey(pointer) {
     return pointer.slice(1);
 }
-function rememberMatcher(matchers, input) {
+function rememberMatcher(matchers, pool, input) {
     if (typeof input === 'string' && !matchers.has(input)) {
-        matchers.set(input, loadPattern(compilePattern(input)));
+        let prepared = pool.get(input);
+        if (prepared === undefined) {
+            const pattern = compilePattern(input);
+            prepared = { pattern, matcher: loadPattern(pattern) };
+            pool.set(input, prepared);
+        }
+        matchers.set(input, prepared);
     }
 }
 function failed(diagnostics) {

package/dist/v1/language/value/evaluate/program.js

@@ -6,7 +6,7 @@ export function validateValueProgram(program, input, roots = [program.root]) {
     if (canonical.length > 0)
         return canonical;
     return roots.flatMap((root) => {
-        const result = evaluateInstance(loadValueProgram({ ...program, root }), input);
+        const result = evaluateInstance(loadValueProgram(program, root), input);
         return result.failures.map((failure) => ({
             code: 'VALUE_SCHEMA_INSTANCE_INVALID',
             pointer: failure.instancePointer,

package/dist/v1/language/value/evaluate/validate.d.ts

@@ -2,11 +2,15 @@ import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
 import type { Diagnostic } from '../../validation/diagnostic.js';
 import type { JsonSchema } from '../model/schema.js';
 import type { ValueSchemaRegistry } from '../reference/registry.js';
+import type { CompiledInstanceSchema } from './types.js';
+import { type PatternPool } from './preparation.js';
 /**
  * Validate one complete portable value with the admitted V1 Draft 2020-12 profile.
  *
  * Evaluation is an interpreter over the exact local resource closure. It never performs network
- * resolution or dynamic source generation, and every admitted I-Regexp executes through RE2JS.
+ * resolution or dynamic source generation; patterns use the portable executor.
  * `format` remains annotation-only; the graph NodePath codec performs its separate locator check.
  */
-export declare function validateJsonInstance(schema: JsonSchema, value: JsonValue, registry: ValueSchemaRegistry, pointer?: string): Diagnostic[];
+export declare function validateJsonInstance(schema: JsonSchema, value: JsonValue, registry: ValueSchemaRegistry, pointer?: string, patterns?: PatternPool): Diagnostic[];
+/** Validate with the exact preparation already retained by a source-resolved Property or Callable. */
+export declare function validatePreparedInstance(compiled: CompiledInstanceSchema, value: unknown): Diagnostic[];

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

@@ -1,31 +1,41 @@
 import { diagnostic } from '../../validation/diagnostic.js';
 import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
 import { evaluateInstance } from './evaluator.js';
-import { prepareValueSchema } from './preparation.js';
+import { prepareValueSchema, } from './preparation.js';
 const validatorCache = new WeakMap();
 /**
  * Validate one complete portable value with the admitted V1 Draft 2020-12 profile.
  *
  * Evaluation is an interpreter over the exact local resource closure. It never performs network
- * resolution or dynamic source generation, and every admitted I-Regexp executes through RE2JS.
+ * resolution or dynamic source generation; patterns use the portable executor.
  * `format` remains annotation-only; the graph NodePath codec performs its separate locator check.
  */
-export function validateJsonInstance(schema, value, registry, pointer = '') {
+export function validateJsonInstance(schema, value, registry, pointer = '', patterns) {
     const diagnostics = [...validateCanonicalJsonDomain(value, pointer)];
     if (diagnostics.length > 0)
         return diagnostics;
-    const prepared = preparedInstanceValidator(schema, registry, pointer);
-    if (prepared.kind === 'error') {
+    const prepared = preparedInstanceValidator(schema, registry, pointer, patterns);
+    if (!prepared.compiled) {
         return [
             diagnostic('VS_REFERENCE_RESOLUTION', pointer, `Value validation failed closed while preparing exact schema resources: ${prepared.message}.`),
         ];
     }
-    const result = evaluateInstance(prepared.compiled, value);
+    return instanceDiagnostics(prepared.value, value, pointer);
+}
+/** Validate with the exact preparation already retained by a source-resolved Property or Callable. */
+export function validatePreparedInstance(compiled, value) {
+    const diagnostics = [...validateCanonicalJsonDomain(value, '')];
+    return diagnostics.length > 0
+        ? diagnostics
+        : instanceDiagnostics(compiled, value, '');
+}
+function instanceDiagnostics(compiled, value, pointer) {
+    const result = evaluateInstance(compiled, value);
     if (result.valid)
         return [];
     return result.failures.map((failure) => diagnostic('VALUE_SCHEMA_INSTANCE_INVALID', `${pointer}${failure.instancePointer}`, `Value does not satisfy its complete V1 schema at ${failure.keyword}: ${failure.message}`));
 }
-function preparedInstanceValidator(schema, registry, pointer) {
+function preparedInstanceValidator(schema, registry, pointer, patterns) {
     let bySchema = validatorCache.get(registry);
     if (bySchema === undefined) {
         bySchema = new Map();
@@ -34,10 +44,7 @@ function preparedInstanceValidator(schema, registry, pointer) {
     const cached = bySchema.get(schema);
     if (cached !== undefined)
         return cached;
-    const compilation = prepareValueSchema(schema, registry, pointer);
-    const prepared = compilation.compiled
-        ? { kind: 'validator', compiled: compilation.value }
-        : { kind: 'error', message: compilation.message };
+    const prepared = prepareValueSchema(schema, registry, pointer, patterns);
     bySchema.set(schema, prepared);
     return prepared;
 }

package/dist/v1/language/value/ordering.d.ts

@@ -1,4 +1,5 @@
 import type { ValueProgram } from './compile/model.js';
+import type { CompiledInstanceSchema } from './evaluate/types.js';
 import type { JsonSchema } from './model/schema.js';
 import type { ValueSchemaRegistry } from './reference/registry.js';
 export type OrderingKind = 'boolean' | 'number' | 'string' | 'instant';
@@ -11,3 +12,4 @@ export type OrderingKind = 'boolean' | 'number' | 'string' | 'instant';
 export declare function classifyOrdering(contract: JsonSchema, registry: ValueSchemaRegistry): OrderingKind | undefined;
 /** Recompute the scalar ordering classification from one admitted portable value program. */
 export declare function classifyValueProgramOrdering(program: ValueProgram): OrderingKind | undefined;
+export declare function classifyPreparedOrdering(compiled: CompiledInstanceSchema): OrderingKind | undefined;

package/dist/v1/language/value/ordering.js

@@ -18,17 +18,13 @@ export function classifyOrdering(contract, registry) {
     const prepared = prepareValueSchema(contract, registry, '');
     if (!prepared.compiled)
         return undefined;
-    const candidates = new OrderingClassifier(prepared.value).classify(prepared.value.root);
-    if (candidates.size !== 1)
-        return undefined;
-    const [kind] = candidates;
-    return kind === 'boolean' || kind === 'number' || kind === 'string' || kind === 'instant'
-        ? kind
-        : undefined;
+    return classifyPreparedOrdering(prepared.value);
 }
 /** Recompute the scalar ordering classification from one admitted portable value program. */
 export function classifyValueProgramOrdering(program) {
-    const compiled = loadValueProgram(program);
+    return classifyPreparedOrdering(loadValueProgram(program));
+}
+export function classifyPreparedOrdering(compiled) {
     const candidates = new OrderingClassifier(compiled).classify(compiled.root);
     if (candidates.size !== 1)
         return undefined;

package/dist/v1/language/value/regexp/compile.d.ts

@@ -1,3 +1,3 @@
-import type { Pattern } from '../compile/model.js';
-/** Compile one admitted I-Regexp AST to portable Thompson-NFA data. */
-export declare function compilePattern(source: string): Pattern;
+import type { Pattern, RunPattern } from '../compile/model.js';
+/** Compile scalar sequences as counted runs; preserve the NFA for branching expressions. */
+export declare function compilePattern(source: string): Pattern | RunPattern;

package/dist/v1/language/value/regexp/compile.js

@@ -1,9 +1,12 @@
 import { parseIRegexp } from './ast.js';
-/** Compile one admitted I-Regexp AST to portable Thompson-NFA data. */
+/** Compile scalar sequences as counted runs; preserve the NFA for branching expressions. */
 export function compilePattern(source) {
     const expression = parseIRegexp(source);
     if (expression === undefined)
         throw new TypeError('Cannot compile an invalid I-Regexp source.');
+    const runs = scalarRuns(expression);
+    if (runs !== undefined)
+        return Object.freeze({ source, runs });
     const builder = new Builder();
     const fragment = builder.expression(expression);
     builder.states[fragment.end].accepting = true;
@@ -13,9 +16,45 @@ export function compilePattern(source) {
         states: Object.freeze(builder.states.map(freezeState)),
     });
 }
+function scalarRuns(expression) {
+    if (expression.alternatives.length !== 1)
+        return undefined;
+    const pieces = expression.alternatives[0].pieces;
+    let counted = false;
+    for (let index = 0; index < pieces.length; index++) {
+        const piece = pieces[index];
+        if (piece.atom.kind !== 'ranges' ||
+            (index !== pieces.length - 1 && piece.minimum !== piece.maximum))
+            return undefined;
+        if (piece.maximum !== undefined && piece.maximum > 1)
+            counted = true;
+    }
+    if (!counted)
+        return undefined;
+    const runs = [];
+    for (const piece of pieces) {
+        if (piece.atom.kind !== 'ranges')
+            return undefined;
+        runs.push(Object.freeze({
+            ranges: freezeRanges(piece.atom.ranges),
+            minimum: piece.minimum,
+            ...(piece.maximum === undefined ? {} : { maximum: piece.maximum }),
+        }));
+    }
+    return Object.freeze(runs);
+}
+function freezeRanges(ranges) {
+    if (Object.isFrozen(ranges))
+        return ranges;
+    for (const range of ranges)
+        Object.freeze(range);
+    return Object.freeze(ranges);
+}
 class Builder {
     states = [];
     expression(expression) {
+        if (expression.alternatives.length === 1)
+            return this.sequence(expression.alternatives[0]);
         const start = this.state();
         const end = this.state();
         for (const alternative of expression.alternatives) {
@@ -26,20 +65,26 @@ class Builder {
         return { start, end };
     }
     sequence(sequence) {
-        let output = this.empty();
-        for (const piece of sequence.pieces)
-            output = this.concat(output, this.piece(piece));
-        return output;
+        let output;
+        for (const piece of sequence.pieces) {
+            const fragment = this.piece(piece);
+            output = output === undefined ? fragment : this.concat(output, fragment);
+        }
+        return output ?? this.empty();
     }
     piece(piece) {
-        let output = this.empty();
+        let output;
         for (let index = 0; index < piece.minimum; index++) {
-            output = this.concat(output, this.atom(piece.atom));
+            const fragment = this.atom(piece.atom);
+            output = output === undefined ? fragment : this.concat(output, fragment);
+        }
+        if (piece.maximum === undefined) {
+            const repeated = this.star(piece.atom);
+            return output === undefined ? repeated : this.concat(output, repeated);
         }
-        if (piece.maximum === undefined)
-            return this.concat(output, this.star(piece.atom));
         if (piece.maximum === piece.minimum)
-            return output;
+            return output ?? this.empty();
+        output ??= this.empty();
         const end = this.state();
         for (let index = piece.minimum; index < piece.maximum; index++) {
             // A shorter repetition exits the whole suffix, rather than skipping arbitrary copies.
@@ -87,7 +132,7 @@ class Builder {
 function freezeState(state) {
     return Object.freeze({
         epsilon: Object.freeze(state.epsilon),
-        transitions: Object.freeze(state.transitions.map((transition) => Object.freeze({ to: transition.to, ranges: Object.freeze(transition.ranges) }))),
+        transitions: Object.freeze(state.transitions.map((transition) => Object.freeze({ to: transition.to, ranges: freezeRanges(transition.ranges) }))),
         ...(state.accepting === true ? { accepting: true } : {}),
     });
 }

package/dist/v1/language/value/regexp/matcher.d.ts

@@ -1,10 +1,10 @@
-import type { Pattern } from '../compile/model.js';
+import type { Pattern, RunPattern } from '../compile/model.js';
 export interface IRegexpMatcher {
     test(value: string): boolean;
     matches(value: string): boolean;
 }
 /**
- * Load the portable Thompson NFA executor shared by search and whole-string matching.
+ * Load the portable counted-run or Thompson NFA executor for search and whole-string matching.
  * Scratch belongs to one invocation: no match-result cache, shared mutable cursor or DFA expansion.
  */
-export declare function loadPattern(pattern: Pattern): IRegexpMatcher;
+export declare function loadPattern(pattern: Pattern | RunPattern): IRegexpMatcher;

package/dist/v1/language/value/regexp/matcher.js

@@ -1,8 +1,10 @@
 /**
- * Load the portable Thompson NFA executor shared by search and whole-string matching.
+ * Load the portable counted-run or Thompson NFA executor for search and whole-string matching.
  * Scratch belongs to one invocation: no match-result cache, shared mutable cursor or DFA expansion.
  */
 export function loadPattern(pattern) {
+    if ('runs' in pattern)
+        return loadRuns(pattern);
     const states = pattern.states;
     const start = initialFrontier(pattern);
     const run = (input, search) => {
@@ -52,8 +54,8 @@ export function loadPattern(pattern) {
             const scalar = character.codePointAt(0);
             for (let index = 0; index < activeCount; index++) {
                 for (const transition of active[index].state.transitions) {
-                    for (const [minimum, maximum] of transition.ranges) {
-                        if (scalar < minimum || scalar > maximum)
+                    for (const range of transition.ranges) {
+                        if (scalar < range[0] || scalar > range[1])
                             continue;
                         add(transition.to);
                         break;
@@ -83,6 +85,76 @@ export function loadPattern(pattern) {
         matches: (input) => run(input, false),
     });
 }
+function loadRuns(pattern) {
+    const runs = pattern.runs;
+    const run = (input, search) => {
+        if (search && runs.length === 1) {
+            const scalarRun = runs[0];
+            if (scalarRun.minimum === 0)
+                return true;
+            let count = 0;
+            for (const character of input) {
+                count = includesScalar(scalarRun.ranges, character.codePointAt(0)) ? count + 1 : 0;
+                if (count >= scalarRun.minimum)
+                    return true;
+            }
+            return false;
+        }
+        let start = 0;
+        do {
+            let offset = start;
+            let accepted = true;
+            for (let index = 0; index < runs.length; index++) {
+                const scalarRun = runs[index];
+                const maximum = search && index === runs.length - 1 ? scalarRun.minimum : (scalarRun.maximum ?? Infinity);
+                let count = 0;
+                while (count < maximum && offset < input.length) {
+                    const scalar = input.codePointAt(offset);
+                    if (!includesScalar(scalarRun.ranges, scalar))
+                        break;
+                    offset += scalar > 0xffff ? 2 : 1;
+                    count++;
+                }
+                if (count < scalarRun.minimum) {
+                    accepted = false;
+                    break;
+                }
+            }
+            if (accepted && (search || offset === input.length))
+                return true;
+            if (!search || start === input.length)
+                return false;
+            start += input.codePointAt(start) > 0xffff ? 2 : 1;
+        } while (start <= input.length);
+        return false;
+    };
+    return Object.freeze({
+        test: (input) => run(input, true),
+        matches: (input) => run(input, false),
+    });
+}
+function includesScalar(ranges, scalar) {
+    if (ranges.length < 8) {
+        for (const range of ranges) {
+            if (scalar >= range[0] && scalar <= range[1])
+                return true;
+        }
+        return false;
+    }
+    let low = 0;
+    let high = ranges.length - 1;
+    while (low <= high) {
+        const middle = (low + high) >>> 1;
+        const range = ranges[middle];
+        if (scalar < range[0])
+            high = middle - 1;
+        else if (scalar > range[1])
+            low = middle + 1;
+        else
+            return true;
+    }
+    return false;
+}
 function initialFrontier(pattern) {
     const start = pattern.start;
     const seen = new Set([start]);

package/dist/v1/schema/analysis/class.d.ts

@@ -40,3 +40,24 @@ export interface DefinitionAnalysisResult {
     readonly diagnostics: readonly SchemaDiagnostic[];
 }
 export declare function analyzeDefinitions(environment: DomainResolutionContext): DefinitionAnalysisResult;
+/** The exact signature required by abstract Method composition. */
+export declare function sameMethodSignature(left: MethodDefinition, right: MethodDefinition): boolean;
+/** Shared canonical signature used by admission and compatibility explanations. */
+export declare function methodSignature(value: MethodDefinition): {
+    input: JsonSchema;
+    output: {
+        mode: string;
+        schema: JsonSchema;
+        item?: undefined;
+    } | {
+        schema?: undefined;
+        mode: string;
+        item: JsonSchema;
+    } | {
+        schema?: undefined;
+        item?: undefined;
+        mode: string;
+    };
+    auth: "anonymous" | "authenticated" | "authorized";
+    static: boolean;
+};

package/dist/v1/schema/analysis/class.js

@@ -113,20 +113,29 @@ function mergeMethods(owner, declaration, parents, diagnostics) {
     ]));
     return composeMethods(parents, own, declaration.abstract, (left, right) => sameMethodSignature(left.declaration, right.declaration), (message) => diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', message, Key.of(owner))));
 }
-function sameMethodSignature(left, right) {
-    return (json.serialize(canonicalizeValueSchema(left.input, 'callable-input')) ===
-        json.serialize(canonicalizeValueSchema(right.input, 'callable-input')) &&
-        canonicalMethodOutput(left) === canonicalMethodOutput(right) &&
-        left.auth === right.auth &&
-        left.static === right.static);
+/** The exact signature required by abstract Method composition. */
+export function sameMethodSignature(left, right) {
+    return json.serialize(methodSignature(left)) === json.serialize(methodSignature(right));
+}
+/** Shared canonical signature used by admission and compatibility explanations. */
+export function methodSignature(value) {
+    return {
+        input: canonicalizeValueSchema(value.input, 'callable-input'),
+        output: canonicalMethodOutput(value),
+        auth: value.auth,
+        static: value.static,
+    };
 }
 function canonicalMethodOutput(value) {
     switch (value.output.mode) {
         case 'value':
-            return `value:${json.serialize(canonicalizeValueSchema(value.output.schema, 'callable-output'))}`;
+            return {
+                mode: 'value',
+                schema: canonicalizeValueSchema(value.output.schema, 'callable-output'),
+            };
         case 'stream':
-            return `stream:${json.serialize(canonicalizeValueSchema(value.output.item, 'callable-output'))}`;
+            return { mode: 'stream', item: canonicalizeValueSchema(value.output.item, 'callable-output') };
         case 'binary':
-            return 'binary';
+            return { mode: 'binary' };
     }
 }

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

@@ -0,0 +1,2 @@
+export { compare, compareMeaning, compareStructure } from './compare.js';
+export type { Analysis, Assessment, Comparison, ComparisonEntry, ComparisonEvidence, ComparisonRequest, ComparisonScope, Facet, Fingerprint, MeaningComparison, Observation, SchemaIdentity, StructureComparison, Subject, Usage, } from './model.js';

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

@@ -0,0 +1 @@
+export { compare, compareMeaning, compareStructure } from './compare.js';

package/dist/v1/schema/compatibility/comparators/callables.d.ts

@@ -0,0 +1,28 @@
+import type { Value } from '@astrale-os/kernel-dsl/value';
+import type { CallableOutput, FunctionDefinition, MethodDefinition } from '../../../language/callable/model/callable.js';
+import type { ResolvedFunction, ResolvedMethod } from '../../../language/callable/resolved.js';
+import type { JsonSchema } from '../../../language/value/model/schema.js';
+import type { EffectiveMethod } from '../../analysis/class.js';
+import type { Fingerprint } from '../model.js';
+export declare function methodExistence(method: EffectiveMethod): Value;
+export declare function methodSignature(method: EffectiveMethod): Value;
+export declare function methodInheritance(method: EffectiveMethod): Value;
+export declare function functionSignature(declaration: FunctionDefinition): Value;
+export declare function functionExistence(): Value;
+/**
+ * Fingerprint the contract a caller compiles against, independently of its Domain revision: the
+ * exact key, the owner, dispatch and abstractness of a Method, and the semantic input and output
+ * contracts; authorization is excluded (DM-CALLABLE-FINGERPRINT). A static consumer pins this
+ * instead of a Domain revision, so a dependency release that leaves the callable contract untouched
+ * keeps every bound invocation valid.
+ */
+export declare function callableFingerprint(callable: ResolvedFunction | ResolvedMethod): Fingerprint;
+type CallableSignature = {
+    readonly static?: boolean;
+    readonly abstract?: boolean;
+    readonly input: JsonSchema;
+    readonly output: CallableOutput;
+};
+/** The `always` fields of CALLABLE_FIELDS: dispatch shape and the semantic input and output. */
+export declare function callableSignature(declaration: Pick<FunctionDefinition, 'input' | 'output'> | Pick<MethodDefinition, 'static' | 'abstract' | 'input' | 'output'>): CallableSignature;
+export {};

package/dist/v1/schema/compatibility/comparators/callables.js

@@ -0,0 +1,77 @@
+import { methodSignature as inheritedSignature } from '../../analysis/class.js';
+import { deepFreeze } from '../../canonical/freeze.js';
+import { keyForDefinitionRef } from '../coordinate.js';
+import { CALLABLE_FIELDS, fieldsOf } from '../fields.js';
+import { fingerprintMeaning, semanticValueSchema } from './values.js';
+export function methodExistence(method) {
+    return deepFreeze({
+        coordinate: 'method',
+        owner: keyForDefinitionRef(method.owner),
+        name: method.name,
+        static: method.declaration.static,
+        abstract: method.declaration.abstract,
+    });
+}
+export function methodSignature(method) {
+    return deepFreeze({
+        coordinate: 'method',
+        owner: keyForDefinitionRef(method.owner),
+        name: method.name,
+        ...callableSignature(method.declaration),
+    });
+}
+export function methodInheritance(method) {
+    return deepFreeze({
+        coordinate: 'method',
+        owner: keyForDefinitionRef(method.owner),
+        name: method.name,
+        abstract: method.declaration.abstract,
+        ...inheritedSignature(method.declaration),
+    });
+}
+export function functionSignature(declaration) {
+    return deepFreeze({
+        coordinate: 'function',
+        ...callableSignature(declaration),
+    });
+}
+export function functionExistence() {
+    return Object.freeze({ coordinate: 'function' });
+}
+/**
+ * Fingerprint the contract a caller compiles against, independently of its Domain revision: the
+ * exact key, the owner, dispatch and abstractness of a Method, and the semantic input and output
+ * contracts; authorization is excluded (DM-CALLABLE-FINGERPRINT). A static consumer pins this
+ * instead of a Domain revision, so a dependency release that leaves the callable contract untouched
+ * keeps every bound invocation valid.
+ */
+export function callableFingerprint(callable) {
+    // This digest input travels in every bound invocation and is recomputed by the Kernel; its
+    // shape is frozen, `kind` included, so a Kernel upgrade never invalidates an unchanged pin.
+    return fingerprintMeaning('owner' in callable
+        ? {
+            kind: 'method',
+            key: callable.key,
+            owner: callable.owner.key,
+            ...callableSignature(callable),
+        }
+        : { kind: 'function', key: callable.key, ...callableSignature(callable) });
+}
+/** The `always` fields of CALLABLE_FIELDS: dispatch shape and the semantic input and output. */
+export function callableSignature(declaration) {
+    return {
+        ...fieldsOf({ declaration, roles: CALLABLE_FIELDS }),
+        input: semanticValueSchema(declaration.input),
+        output: semanticOutput(declaration.output),
+    };
+}
+function semanticOutput(output) {
+    switch (output.mode) {
+        case 'value':
+            return { mode: 'value', schema: semanticValueSchema(output.schema) };
+        case 'stream':
+            return { mode: 'stream', item: semanticValueSchema(output.item) };
+        case 'binary':
+            return { mode: 'binary' };
+    }
+}