@astrale-os/kernel-dsl 0.2.0-beta.4 → 0.2.0-beta.40

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

@@ -0,0 +1,63 @@
+import type { ClassRef } from '../../addressing/index.js';
+import type { MethodDefinition } from '../../language/callable/model/callable.js';
+import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { DataDefinition } from '../../language/class/model/data.js';
+import type { PropertyAuto } from '../../language/class/model/property.js';
+import type { StateTopology } from '../../language/state/index.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainResolutionContext } from '../resolution/context.js';
+import { PropertyKey } from '../../addressing/index.js';
+import { type MethodComposition } from '../../language/callable/composition.js';
+export interface EffectiveField {
+    readonly identity: PropertyKey;
+    readonly owner: ClassRef;
+    readonly name: string;
+    readonly schema: JsonSchema;
+    readonly required: boolean;
+    readonly auto?: PropertyAuto;
+    readonly state?: StateTopology;
+}
+export interface EffectiveMethod {
+    readonly key: string;
+    readonly owner: ClassRef;
+    readonly name: string;
+    readonly declaration: MethodDefinition;
+}
+export interface EffectiveData {
+    readonly identity: string;
+    readonly owner: ClassRef;
+    readonly declaration: DataDefinition;
+}
+export interface DefinitionAnalysis extends MethodComposition<EffectiveMethod> {
+    readonly ref: ClassRef;
+    readonly declaration: ClassDefinition;
+    readonly properties: ReadonlyMap<PropertyKey, EffectiveField>;
+    readonly data?: EffectiveData;
+}
+export interface DefinitionAnalysisResult {
+    readonly definitions: ReadonlyMap<string, DefinitionAnalysis>;
+    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

@@ -0,0 +1,141 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { Key, PropertyKey } from '../../addressing/index.js';
+import { definitionRefIndex } from '../../addressing/ordering.js';
+import { composeMethods } from '../../language/callable/composition.js';
+import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
+import { diagnostic } from '../diagnostic.js';
+const formatDefinitionRef = Key.of;
+export function analyzeDefinitions(environment) {
+    const diagnostics = [];
+    const result = new Map();
+    const visiting = new Set();
+    const analyze = (ref) => {
+        const key = definitionRefIndex(ref);
+        const cached = result.get(key);
+        if (cached !== undefined)
+            return cached;
+        if (visiting.has(key)) {
+            diagnostics.push(diagnostic('DV_CLASS_ACYCLIC', '', `Inheritance cycle reaches ${formatDefinitionRef(ref)}.`, formatDefinitionRef(ref)));
+            return undefined;
+        }
+        const resolved = environment.resolveAny(ref);
+        if (resolved === undefined)
+            return undefined;
+        visiting.add(key);
+        const declaration = resolved.declaration;
+        const parents = declaration.extends;
+        const parentAnalyses = parents.flatMap((parent) => {
+            const target = environment.resolveAny(parent);
+            if (target === undefined) {
+                diagnostics.push(diagnostic('DV_REF_RESOLVES', '', `Inheritance ref ${formatDefinitionRef(parent)} does not resolve.`, formatDefinitionRef(parent)));
+                return [];
+            }
+            const analysis = target.ref.kind === 'class' ? analyze(target.ref) : undefined;
+            return analysis === undefined ? [] : [analysis];
+        });
+        const properties = mergeFields(parentAnalyses.map((parent) => parent.properties), ownFields(ref, declaration));
+        const data = mergeData(ref, declaration, parentAnalyses, diagnostics);
+        const methods = mergeMethods(ref, declaration, parentAnalyses, diagnostics);
+        const analysis = {
+            ref,
+            declaration,
+            properties,
+            ...(data === undefined ? {} : { data }),
+            ...methods,
+        };
+        result.set(key, analysis);
+        visiting.delete(key);
+        return analysis;
+    };
+    for (const resolved of environment.definitions.values()) {
+        analyze(resolved.ref);
+    }
+    return Object.freeze({ definitions: result, diagnostics: Object.freeze(diagnostics) });
+}
+function ownFields(owner, declaration) {
+    const result = new Map();
+    for (const [name, property] of Object.entries(declaration.properties)) {
+        const key = PropertyKey.of(owner, name);
+        result.set(key, {
+            identity: key,
+            owner,
+            name,
+            schema: property.schema,
+            required: property.required,
+            ...(property.auto === undefined ? {} : { auto: property.auto }),
+            ...(property.state === undefined ? {} : { state: property.state }),
+        });
+    }
+    return result;
+}
+function mergeFields(inherited, own) {
+    const result = new Map();
+    for (const fields of inherited) {
+        for (const [key, field] of fields) {
+            if (!result.has(key))
+                result.set(key, field);
+        }
+    }
+    for (const [key, field] of own) {
+        result.set(key, field);
+    }
+    return result;
+}
+function mergeData(owner, declaration, parents, diagnostics) {
+    let effective;
+    for (const parent of parents) {
+        if (parent.data === undefined)
+            continue;
+        if (effective === undefined) {
+            effective = parent.data;
+            continue;
+        }
+        if (effective.identity !== parent.data.identity) {
+            diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data has distinct declaring owners ${formatDefinitionRef(effective.owner)} and ${formatDefinitionRef(parent.data.owner)}.`));
+        }
+    }
+    const own = 'data' in declaration ? declaration.data : undefined;
+    if (own === undefined)
+        return effective;
+    if (effective !== undefined) {
+        diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data redeclares the inherited contract from ${formatDefinitionRef(effective.owner)}.`));
+    }
+    return {
+        identity: `${definitionRefIndex(owner)}\u0000data`,
+        owner,
+        declaration: own,
+    };
+}
+function mergeMethods(owner, declaration, parents, diagnostics) {
+    const own = new Map(Object.entries('methods' in declaration ? declaration.methods : {}).map(([name, method]) => [
+        name,
+        { key: `${Key.of(owner)}.method.${name}`, owner, name, declaration: method },
+    ]));
+    return composeMethods(parents, own, declaration.abstract, (left, right) => sameMethodSignature(left.declaration, right.declaration), (message) => diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', message, Key.of(owner))));
+}
+/** 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 {
+                mode: 'value',
+                schema: canonicalizeValueSchema(value.output.schema, 'callable-output'),
+            };
+        case 'stream':
+            return { mode: 'stream', item: canonicalizeValueSchema(value.output.item, 'callable-output') };
+        case 'binary':
+            return { mode: 'binary' };
+    }
+}

package/dist/v1/schema/canonical/domain.d.ts

@@ -1,3 +1,3 @@
-import type { DomainSchemaIR } from '../domain.ir.js';
+import type { DomainSchemaIR } from '../model/schema.js';
+/** Produce the deterministic semantic document consumed by canonical JSON serialization. */
 export declare function canonicalizeDomainSchema(schema: DomainSchemaIR): DomainSchemaIR;
-//# sourceMappingURL=domain.d.ts.map

package/dist/v1/schema/canonical/domain.digest.d.ts

@@ -1,4 +1,3 @@
-import type { Revision } from '../reference.js';
+import type { Revision } from '../../addressing/index.js';
 /** Content-address canonical DomainSchema bytes with the V1 revision algorithm. */
 export declare function digestDomainSchemaBytes(bytes: Uint8Array): Revision;
-//# sourceMappingURL=domain.digest.d.ts.map

package/dist/v1/schema/canonical/domain.digest.js

@@ -1,9 +1,5 @@
-import { sha256 } from '@noble/hashes/sha2.js';
+import { digestRevisionBytes } from '../../addressing/revision.js';
 /** Content-address canonical DomainSchema bytes with the V1 revision algorithm. */
 export function digestDomainSchemaBytes(bytes) {
-    let hexadecimal = '';
-    for (const byte of sha256(bytes))
-        hexadecimal += byte.toString(16).padStart(2, '0');
-    return `sha256:${hexadecimal}`;
+    return digestRevisionBytes(bytes);
 }
-//# sourceMappingURL=domain.digest.js.map

package/dist/v1/schema/canonical/domain.js

@@ -1,226 +1,5 @@
-import { json } from '@astrale-os/kernel-dsl/value';
-import { normalizePolicyChecks, normalizePolicyDeclaration } from '../policy/normalize.js';
-import { compareSchemaRefs, compareUnicode, } from '../reference.js';
-import { canonicalizeValueSchema } from '../value/profile/canonicalize.js';
+import { normalizeDomainSchema } from '../normalization/domain.js';
+/** Produce the deterministic semantic document consumed by canonical JSON serialization. */
 export function canonicalizeDomainSchema(schema) {
-    const classes = mapRecord(schema.classes, canonicalizeClass);
-    const orientationByClass = new Map(Object.entries(classes)
-        .filter((entry) => entry[1].family === 'edge')
-        .map(([name, declaration]) => [name, declaration.orientation]));
-    const canonical = {
-        format: 'astrale.dsl',
-        version: 'v1',
-        origin: schema.origin,
-        dependencies: [...schema.dependencies].sort((left, right) => compareUnicode(left.origin, right.origin)),
-        types: mapRecord(schema.types, (value) => canonicalizeValueSchema(value, 'named-type')),
-        interfaces: mapRecord(schema.interfaces, canonicalizeInterface),
-        classes,
-        functions: mapRecord(schema.functions, canonicalizeFunction),
-        policies: mapRecord(schema.policies, normalizePolicyDeclaration),
-        views: mapRecord(schema.views, canonicalizeView),
-        core: {
-            nodes: mapRecord(schema.core.nodes, (node) => ({
-                class: node.class,
-                properties: copyJsonValue(node.properties),
-            })),
-            edges: schema.core.edges
-                .map((edge) => canonicalizeCoreEdge(edge, schema.origin, orientationByClass))
-                .sort(compareCoreEdges),
-        },
-    };
-    return copyJsonValue(canonical);
+    return normalizeDomainSchema(schema);
 }
-function canonicalizeView(value) {
-    return {
-        ...withDescription(value),
-        target: value.target.kind === 'domain'
-            ? { kind: 'domain' }
-            : {
-                kind: 'definition',
-                definitions: [...value.target.definitions].sort(compareSchemaRefs),
-            },
-        auth: value.auth,
-    };
-}
-function canonicalizeInterface(value) {
-    const base = {
-        ...withDescription(value),
-        family: value.family,
-        extends: [...value.extends].sort(compareSchemaRefs),
-        properties: canonicalizePropertyFacet(value.properties),
-        propertyMetadata: canonicalizePropertyMetadata(value.propertyMetadata),
-    };
-    if (value.family === 'both')
-        return base;
-    if (value.family === 'node') {
-        return {
-            ...base,
-            methods: mapRecord(value.methods, canonicalizeMethod),
-            ...(value.data === undefined ? {} : { data: { mediaType: value.data.mediaType } }),
-        };
-    }
-    return value.orientation === 'directed'
-        ? {
-            ...base,
-            orientation: 'directed',
-            endpoints: canonicalizeDirectedEndpoints(value.endpoints),
-            constraints: value.constraints,
-        }
-        : {
-            ...base,
-            orientation: 'undirected',
-            endpoints: canonicalizeIncidentEndpoints(value.endpoints),
-            constraints: value.constraints,
-        };
-}
-function canonicalizeClass(value) {
-    const base = {
-        ...withDescription(value),
-        family: value.family,
-        implements: [...value.implements].sort(compareSchemaRefs),
-        properties: canonicalizePropertyFacet(value.properties),
-        propertyMetadata: canonicalizePropertyMetadata(value.propertyMetadata),
-    };
-    if (value.family === 'node') {
-        return {
-            ...base,
-            methods: mapRecord(value.methods, canonicalizeMethod),
-            ...(value.data === undefined ? {} : { data: { mediaType: value.data.mediaType } }),
-            ...(value.icon === undefined ? {} : { icon: value.icon }),
-            policies: value.policies,
-        };
-    }
-    return value.orientation === 'directed'
-        ? {
-            ...base,
-            orientation: 'directed',
-            endpoints: canonicalizeDirectedEndpoints(value.endpoints),
-            policies: value.policies,
-            constraints: value.constraints,
-        }
-        : {
-            ...base,
-            orientation: 'undirected',
-            endpoints: canonicalizeIncidentEndpoints(value.endpoints),
-            policies: value.policies,
-            constraints: value.constraints,
-        };
-}
-function canonicalizeFunction(value) {
-    return {
-        ...withDescription(value),
-        input: canonicalizeValueSchema(value.input, 'callable-input'),
-        output: canonicalizeCallableOutput(value.output),
-        auth: value.auth,
-        ...(value.policy === undefined ? {} : { policy: normalizePolicyChecks(value.policy) }),
-    };
-}
-function canonicalizeMethod(value) {
-    return {
-        ...canonicalizeFunction(value),
-        static: value.static,
-        inheritance: value.inheritance,
-    };
-}
-function canonicalizeCallableOutput(value) {
-    switch (value.mode) {
-        case 'value':
-            return { mode: 'value', schema: canonicalizeValueSchema(value.schema, 'callable-output') };
-        case 'stream':
-            return { mode: 'stream', item: canonicalizeValueSchema(value.item, 'callable-output') };
-        case 'binary':
-            return { mode: 'binary' };
-    }
-}
-function canonicalizePropertyFacet(value) {
-    const canonical = canonicalizeValueSchema(value, 'property-facet');
-    return canonical;
-}
-function canonicalizePropertyMetadata(value) {
-    return Object.fromEntries(Object.entries(value)
-        .filter(([, metadata]) => metadata.visibility === 'private' || metadata.auto !== undefined)
-        .map(([name, metadata]) => [
-        name,
-        metadata.auto === undefined
-            ? { visibility: metadata.visibility }
-            : {
-                visibility: metadata.visibility,
-                auto: {
-                    on: [...new Set(metadata.auto.on)].sort(compareUnicode),
-                    set: metadata.auto.set,
-                },
-            },
-    ])
-        .sort(([left], [right]) => compareUnicode(left, right)));
-}
-function canonicalizeDirectedEndpoints(value) {
-    return {
-        ...value,
-        source: { ...value.source, accepts: [...value.source.accepts].sort(compareSchemaRefs) },
-        target: { ...value.target, accepts: [...value.target.accepts].sort(compareSchemaRefs) },
-    };
-}
-function canonicalizeIncidentEndpoints(value) {
-    return [
-        { ...value[0], accepts: [...value[0].accepts].sort(compareSchemaRefs) },
-        { ...value[1], accepts: [...value[1].accepts].sort(compareSchemaRefs) },
-    ];
-}
-function canonicalizeCoreEdge(edge, origin, orientationByClass) {
-    const isLocal = edge.class.origin === origin;
-    const isUndirected = isLocal && orientationByClass.get(edge.class.name) === 'undirected';
-    const [source, target] = isUndirected && compareCoreEndpoints(edge.source, edge.target) > 0
-        ? [edge.target, edge.source]
-        : [edge.source, edge.target];
-    return {
-        class: edge.class,
-        source,
-        target,
-        properties: copyJsonValue(edge.properties),
-    };
-}
-function compareCoreEdges(left, right) {
-    return (compareSchemaRefs(left.class, right.class) ||
-        compareCoreEndpoints(left.source, right.source) ||
-        compareCoreEndpoints(left.target, right.target) ||
-        compareBytes(json.serialize(left.properties), json.serialize(right.properties)));
-}
-function compareCoreEndpoints(left, right) {
-    if (left.kind === 'domain')
-        return right.kind === 'domain' ? 0 : -1;
-    if (right.kind === 'domain')
-        return 1;
-    return compareSchemaRefs(left, right);
-}
-function compareBytes(left, right) {
-    const encoder = new TextEncoder();
-    const a = encoder.encode(left);
-    const b = encoder.encode(right);
-    const length = Math.min(a.length, b.length);
-    for (let index = 0; index < length; index++) {
-        if (a[index] !== b[index])
-            return (a[index] ?? 0) - (b[index] ?? 0);
-    }
-    return a.length - b.length;
-}
-function mapRecord(value, map) {
-    return Object.fromEntries(Object.entries(value)
-        .sort(([left], [right]) => compareUnicode(left, right))
-        .map(([name, entry]) => [name, map(entry, name)]));
-}
-function withDescription(value) {
-    return value.description === undefined ? {} : { description: value.description };
-}
-function copyJsonValue(value) {
-    if (typeof value === 'number') {
-        if (Object.is(value, -0))
-            throw new TypeError('Cannot canonicalize negative zero.');
-        return value;
-    }
-    if (value === null || typeof value !== 'object')
-        return value;
-    if (Array.isArray(value))
-        return value.map((entry) => copyJsonValue(entry));
-    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, copyJsonValue(entry)]));
-}
-//# sourceMappingURL=domain.js.map

package/dist/v1/schema/canonical/freeze.d.ts

@@ -1,2 +1 @@
 export declare function deepFreeze<T>(value: T): Readonly<T>;
-//# sourceMappingURL=freeze.d.ts.map

package/dist/v1/schema/canonical/freeze.js

@@ -7,4 +7,3 @@ export function deepFreeze(value) {
     }
     return Object.freeze(value);
 }
-//# sourceMappingURL=freeze.js.map

package/dist/v1/schema/canonical/revision.d.ts

@@ -0,0 +1,11 @@
+import type { Revision } from '../../addressing/index.js';
+import { type DomainSchema, type DomainSchemaIR } from '../model/schema.js';
+export interface CanonicalDomainSchema {
+    readonly schema: DomainSchema;
+    readonly bytes: Uint8Array;
+    readonly revision: Revision;
+}
+export declare function canonicalDomainSchema(value: DomainSchema): CanonicalDomainSchema;
+/** Internal acceptance seam. The caller must establish whole-Domain validity first. */
+export declare function canonicalDomainSchemaAfterValidation(value: DomainSchemaIR): CanonicalDomainSchema;
+export declare function revisionOfDomainSchema(schema: DomainSchema): Revision;

package/dist/v1/schema/canonical/revision.js

@@ -0,0 +1,20 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { asDomainSchema } from '../model/schema.js';
+import { digestDomainSchemaBytes } from './domain.digest.js';
+import { canonicalizeDomainSchema } from './domain.js';
+// Only canonical schemas created here own a retained revision, never caller-owned input.
+const revisions = new WeakMap();
+export function canonicalDomainSchema(value) {
+    return canonicalDomainSchemaAfterValidation(value);
+}
+/** Internal acceptance seam. The caller must establish whole-Domain validity first. */
+export function canonicalDomainSchemaAfterValidation(value) {
+    const schema = asDomainSchema(canonicalizeDomainSchema(value));
+    const bytes = json.encode(schema);
+    const revision = digestDomainSchemaBytes(bytes);
+    revisions.set(schema, revision);
+    return Object.freeze({ schema, bytes, revision });
+}
+export function revisionOfDomainSchema(schema) {
+    return revisions.get(schema) ?? canonicalDomainSchema(schema).revision;
+}

package/dist/v1/schema/codec/header.d.ts

@@ -0,0 +1,17 @@
+import type { Key } from '../../addressing/index.js';
+import type { DomainDependencyMap } from '../../addressing/index.js';
+/**
+ * Structurally trusted routing information used to discover an exact
+ * dependency closure before whole-Domain semantic acceptance is possible.
+ *
+ * This is deliberately not a DomainSchema: callers must still load the
+ * declared revisions and pass the original document to acceptDomainSchema.
+ */
+export interface DomainSchemaHeader {
+    readonly format: 'astrale.dsl';
+    readonly version: 'v1';
+    readonly origin: Key.Origin;
+    readonly dependencies: DomainDependencyMap;
+}
+/** Decode detached Schema bytes or text and retain only validated closure-routing identity. */
+export declare function header(input: string | Uint8Array): DomainSchemaHeader;

package/dist/v1/schema/codec/header.js

@@ -0,0 +1,26 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { routeDomainSchema } from '../validation/domain.route.js';
+/** Decode detached Schema bytes or text and retain only validated closure-routing identity. */
+export function header(input) {
+    let decoded;
+    try {
+        decoded = json.decode(input);
+    }
+    catch (error) {
+        if (error instanceof json.DecodeError) {
+            throw new SchemaError([diagnostic('DV_JSON_VALUE', '', error.message)]);
+        }
+        throw error;
+    }
+    const structured = routeDomainSchema(decoded);
+    return Object.freeze({
+        format: structured.format,
+        version: structured.version,
+        dependencies: Object.freeze(Object.fromEntries(Object.entries(structured.dependencies).map(([alias, dependency]) => [
+            alias,
+            Object.freeze({ ...dependency }),
+        ]))),
+        origin: structured.origin,
+    });
+}

package/dist/v1/schema/codec/schema.d.ts

@@ -0,0 +1,5 @@
+import type { DomainSchemaLookup } from '../dependency/lookup.js';
+import type { DomainSchema } from '../model/schema.js';
+export declare function decodeDomainSchema(input: string | Uint8Array, lookup?: DomainSchemaLookup): DomainSchema;
+export declare function serializeDomainSchema(schema: DomainSchema): string;
+export declare function encodeDomainSchema(schema: DomainSchema): Uint8Array;

package/dist/v1/schema/codec/schema.js

@@ -0,0 +1,21 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { acceptDomainSchema } from '../admission/accept.js';
+import { emptyDomainSchemaLookup } from '../dependency/lookup.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+export function decodeDomainSchema(input, lookup = emptyDomainSchemaLookup()) {
+    try {
+        return acceptDomainSchema(json.decode(input), lookup);
+    }
+    catch (error) {
+        if (error instanceof json.DecodeError) {
+            throw new SchemaError([diagnostic('DV_JSON_VALUE', '', error.message)]);
+        }
+        throw error;
+    }
+}
+export function serializeDomainSchema(schema) {
+    return json.serialize(schema);
+}
+export function encodeDomainSchema(schema) {
+    return json.encode(schema);
+}

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,27 @@
+import type { Value } from '@astrale-os/kernel-dsl/value';
+import type { CallableOutput, CallableInputContract, FunctionDefinition, MethodDefinition } from '../../../language/callable/model/callable.js';
+import type { ResolvedFunction, ResolvedMethod } from '../../../language/callable/resolved.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: CallableInputContract;
+    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 {};