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

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

@@ -1,10 +1,13 @@
+import { isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS, } from '../../language/callable/admission.js';
 import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { diagnostic } from '../diagnostic.js';
-/** Validate the execution modifier of every local Function and Node Method. */
+/** 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)) {
-        validateExecution(declaration, `/functions/${escapePointer(name)}`, diagnostics);
+        const pointer = `/functions/${escapePointer(name)}`;
+        validateExecution(declaration, pointer, diagnostics);
+        validateAdmission(declaration, pointer, diagnostics);
     }
     for (const [name, declaration] of Object.entries(schema.classes)) {
         if (declaration.kind !== 'node')
@@ -12,10 +15,22 @@ export function validateCallables(schema) {
         for (const [method, value] of Object.entries(declaration.methods)) {
             const pointer = `/classes/${escapePointer(name)}/methods/${escapePointer(method)}`;
             validateExecution(value, pointer, diagnostics);
+            validateAdmission(value, pointer, diagnostics);
         }
     }
     return Object.freeze(diagnostics);
 }
+/**
+ * An admission age is a whole number of seconds within the language ceiling. It has no zero
+ * spelling: an absent admission age is the one canonical form of a call admitted afresh.
+ */
+function validateAdmission(declaration, pointer, diagnostics) {
+    if (declaration.admission === undefined)
+        return;
+    if (isAdmissionMaxAge(declaration.admission.maxAge))
+        return;
+    diagnostics.push(diagnostic('DV_CALLABLE_ADMISSION', `${pointer}/admission/maxAge`, `An admission age is an integer number of seconds from 1 to ${MAXIMUM_ADMISSION_AGE_SECONDS}; omit it to admit every call afresh.`));
+}
 /**
  * An Execution records its initiating caller and its admitted input, from which the run is
  * resubmitted, and retains one portable outcome. A durable callable therefore needs a known caller,

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

@@ -2,16 +2,19 @@ import { Key } from '../../addressing/key.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
 import { classSatisfies as satisfiesClass, isGraphRoot } from '../../language/class/inheritance.js';
+import { lifetimeBreaches, lifetimeScope } from '../../language/class/lifetime.js';
+import { keyableProperty } from '../../language/class/unique.js';
 import { admitStateTopology } from '../../language/state/topology.js';
 import { isBlobValueSchema } from '../../language/value/model/blob.js';
 import { classifyOrdering } from '../../language/value/ordering.js';
 import { diagnostic } from '../diagnostic.js';
-import { createValueSchemaRegistry } from '../resolution/value.registry.js';
+import { createDomainValueSchemaRegistry, createValueSchemaRegistry, } from '../resolution/value.registry.js';
 const formatDefinitionRef = Key.of;
 /** Validate the semantic contracts owned by Class declarations. */
 export function validateDefinitions(environment, analysis) {
     const diagnostics = [...analysis.diagnostics];
     const schema = environment.candidate;
+    let scope;
     for (const [name, declaration] of Object.entries(schema.classes)) {
         const ref = localRef(schema.origin, name);
         const pointer = `/classes/${escapePointer(name)}`;
@@ -26,7 +29,10 @@ export function validateDefinitions(environment, analysis) {
         validateParents(environment, ref, declaration.kind, declaration.extends, diagnostics);
         if (declaration.kind === 'edge') {
             validateEdgeContract(environment, ref, declaration, diagnostics);
+            scope ??= lifetimeScope([...environment.definitions.values()].map(({ declaration }) => declaration));
+            validateEdgeLifetimes(scope, ref, declaration, pointer, diagnostics);
         }
+        validateUniqueProperties(environment, analysis, ref, declaration, pointer, diagnostics);
     }
     validateEdgeClassComposition(environment, diagnostics);
     return Object.freeze(diagnostics);
@@ -87,9 +93,15 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
         return;
     for (const [name, method] of Object.entries(declaration.methods)) {
         const methodPointer = `${pointer}/methods/${escapePointer(name)}`;
-        if (!isMethodExecutable(declaration, method) && method.policy !== undefined) {
+        if (isMethodExecutable(declaration, method))
+            continue;
+        if (method.policy !== undefined) {
             diagnostics.push(diagnostic('DV_METHOD_ABSTRACT', `${methodPointer}/policy`, 'Abstract Methods cannot have a Policy.'));
         }
+        // An admission age qualifies the admission of an executable declaration, like its Policy.
+        if (method.admission !== undefined) {
+            diagnostics.push(diagnostic('DV_METHOD_ABSTRACT', `${methodPointer}/admission`, 'Abstract Methods cannot have an admission age.'));
+        }
     }
 }
 function validateParents(environment, owner, ownerKind, parents, diagnostics) {
@@ -103,6 +115,9 @@ function validateParents(environment, owner, ownerKind, parents, diagnostics) {
         if (target.ref.kind !== 'class' || target.declaration.kind !== ownerKind) {
             diagnostics.push(diagnostic('DV_CLASS_KIND', pointer, `${formatDefinitionRef(owner)} cannot extend different-kind Class ${formatDefinitionRef(parent)}.`, formatDefinitionRef(parent)));
         }
+        else if (target.declaration.inheritance === 'final') {
+            diagnostics.push(diagnostic('DV_CLASS_INHERITANCE', pointer, `${formatDefinitionRef(owner)} cannot extend final Class ${formatDefinitionRef(parent)}.`, formatDefinitionRef(parent)));
+        }
     }
 }
 function validateEdgeContract(environment, owner, declaration, diagnostics) {
@@ -123,6 +138,56 @@ function validateEdgeContract(environment, owner, declaration, diagnostics) {
         }
     }
 }
+/**
+ * Each Property a key tuple names is one of the Class's own or inherited Properties, and keyable:
+ * a single-kind scalar by its ordering facet that no automatic program writes (D-S1). Properties
+ * inherit without redefinition, so the key reads one meaning on every descendant it covers. A Node
+ * tuple names Properties only; an Edge tuple names them as `{ property }` beside its other fields.
+ */
+function validateUniqueProperties(environment, analysis, owner, declaration, pointer, diagnostics) {
+    if (declaration.kind === 'edge' && declaration.orientation !== 'directed')
+        return;
+    if (declaration.unique === undefined)
+        return;
+    const properties = analysis.definitions.get(definitionRefIndex(owner))?.properties;
+    if (properties === undefined)
+        return;
+    const code = declaration.kind === 'node' ? 'DV_NODE_UNIQUE' : 'DV_EDGE_UNIQUE';
+    const registries = new Map();
+    const registryOf = (origin) => {
+        if (!registries.has(origin)) {
+            const schema = environment.dependencies.get(origin);
+            const registry = origin === environment.candidate.origin
+                ? createValueSchemaRegistry(environment)
+                : schema === undefined
+                    ? undefined
+                    : createDomainValueSchemaRegistry(schema);
+            if (registry !== undefined)
+                registries.set(origin, registry);
+        }
+        return registries.get(origin);
+    };
+    const check = (key, at) => {
+        const property = properties.get(key);
+        if (property === undefined) {
+            diagnostics.push(diagnostic(code, at, `${key} is not a Property of the Class.`));
+            return;
+        }
+        const registry = registryOf(property.owner.origin);
+        const ordering = registry === undefined ? undefined : classifyOrdering(property.schema, registry);
+        if (!keyableProperty(ordering, property.auto)) {
+            diagnostics.push(diagnostic(code, at, 'A key Property is a string, number, boolean or instant that no automatic program writes.'));
+        }
+    };
+    if (declaration.kind === 'node') {
+        declaration.unique.forEach((tuple, t) => tuple.forEach((key, f) => check(key, `${pointer}/unique/${t}/${f}`)));
+        return;
+    }
+    declaration.unique.forEach((tuple, t) => tuple.forEach((field, f) => {
+        if (typeof field !== 'string')
+            check(field.property, `${pointer}/unique/${t}/${f}/property`);
+    }));
+}
 function validateEndpoint(environment, owner, endpoint, count, side, diagnostics) {
     // An Edge Class binds only the Nodes of its Domain and its dependents: it cannot oblige the
     // Nodes of a Class another Domain owns to carry its Edges.
@@ -145,6 +210,19 @@ function validateEndpoint(environment, owner, endpoint, count, side, diagnostics
         }
     }
 }
+/**
+ * The lifetime laws over the lifetimes a Schema declares. What an endpoint derives where it
+ * declares nothing is never refused here: a stored Registry decoded again keeps it.
+ */
+function validateEdgeLifetimes(scope, owner, declaration, pointer, diagnostics) {
+    const sides = declaration.orientation === 'directed'
+        ? ['source', 'target']
+        : ['first endpoint', 'second endpoint'];
+    const keys = declaration.orientation === 'directed' ? ['source', 'target'] : ['0', '1'];
+    for (const { index, reason } of lifetimeBreaches(declaration, scope)) {
+        diagnostics.push(diagnostic('DV_EDGE_LIFETIME', `${pointer}/endpoints/${keys[index]}/onDelete`, `${formatDefinitionRef(owner)} ${sides[index]} ${reason}`));
+    }
+}
 /** Edge inheritance is refinement, not a second interface composition mechanism. */
 function validateEdgeClassComposition(environment, diagnostics) {
     for (const resolved of environment.definitions.values()) {

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

@@ -1,6 +1,7 @@
 import { Key } from '../../addressing/key.js';
 import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
+import { coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueKeys, nodeUniqueKeys, } from '../../language/class/unique.js';
 import { policyObjectKey, policyObjectOrigin, projectedMemberClass, } from '../../language/policy/model/policy.js';
 import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
 import { diagnostic } from '../diagnostic.js';
@@ -10,9 +11,34 @@ export function validateCore(environment, analysis, registry) {
     const diagnostics = [];
     const nodesByRef = resolveCoreNodes(environment, analysis, registry, diagnostics);
     const edges = resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnostics);
+    validateCoreNodeKeys(environment, nodesByRef, diagnostics);
     validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics);
     return Object.freeze(diagnostics);
 }
+/**
+ * No two Core Nodes hold one key under a tuple covering their Classes, whichever Class or ancestor
+ * declares it (DV-NODE-UNIQUE); Activation checks them against stored data.
+ */
+function validateCoreNodeKeys(environment, nodesByRef, diagnostics) {
+    const resolve = (ref) => environment.resolveAny(ref)?.declaration;
+    const holders = new Map();
+    for (const node of nodesByRef.values()) {
+        const declaration = resolve(node.classRef);
+        if (declaration === undefined)
+            continue;
+        const pointer = `/core/nodes/${escapePointer(node.slug)}`;
+        const keys = nodeUniqueKeys(coveringNodeUniqueTuples(declaration, resolve), {
+            props: environment.candidate.core.nodes[node.slug].properties,
+        });
+        const previous = keys.map((key) => holders.get(key)).find((at) => at !== undefined);
+        if (previous !== undefined) {
+            diagnostics.push(diagnostic('DV_CORE_NODE_UNIQUE', pointer, `Core Node holds a key the Core Node at ${previous} holds.`));
+        }
+        for (const key of keys)
+            if (!holders.has(key))
+                holders.set(key, pointer);
+    }
+}
 function resolveCoreNodes(environment, analysis, registry, diagnostics) {
     const nodes = new Map();
     for (const [slug, node] of Object.entries(environment.candidate.core.nodes)) {
@@ -175,6 +201,7 @@ function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
             diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', edge.pointer, 'Core Edge violates noSelf.'));
         }
     }
+    validateCoreEdgeKeys(environment, edges, diagnostics);
     for (const { declaration, edges: classEdges } of edgeSlices.values()) {
         if (declaration.constraints.acyclic === true && hasDirectedCycle(classEdges)) {
             diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', '/core/edges', 'Core Edge set violates exact-Class acyclicity.'));
@@ -182,6 +209,29 @@ function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
         validateCardinality(environment, declaration, classEdges, nodesByRef, diagnostics);
     }
 }
+/**
+ * No two Core Edges hold one key under a tuple covering their Classes, whichever Class or ancestor
+ * declares it (DV-EDGE-UNIQUE). Core Edges have no slug, so only tuples of endpoints and
+ * Properties can bind them; Activation checks them against stored data.
+ */
+function validateCoreEdgeKeys(environment, edges, diagnostics) {
+    const resolve = (ref) => environment.resolveAny(ref)?.declaration;
+    const holders = new Map();
+    for (const edge of edges) {
+        const keys = edgeUniqueKeys(coveringEdgeUniqueTuples(edge.declaration, resolve), {
+            source: edge.source.key,
+            target: edge.target.key,
+            props: edge.value.properties,
+        });
+        const previous = keys.map((key) => holders.get(key)).find((pointer) => pointer !== undefined);
+        if (previous !== undefined) {
+            diagnostics.push(diagnostic('DV_CORE_EDGE_UNIQUE', edge.pointer, `Core Edge holds a key the Core Edge at ${previous} holds.`));
+        }
+        for (const key of keys)
+            if (!holders.has(key))
+                holders.set(key, edge.pointer);
+    }
+}
 function validateCardinality(environment, declaration, edges, nodesByRef, diagnostics) {
     const subjects = cardinalitySubjects(edges, nodesByRef);
     if (declaration.orientation === 'undirected') {

package/dist/v1/schema/validation/domain.structure.js

@@ -83,6 +83,7 @@ const coreEndpointRefSchema = discriminatedUnion('kind', [
 const edgeEndpointBaseShape = {
     role: memberNameSchema,
     accepts: uniqueArray(classRefSchema).min(1),
+    onDelete: enumeration(['restrict', 'detach']).optional(),
 };
 const edgeCountSchema = enumeration(['0..*', '1..*', '0..1', '1']);
 const directedEdgeEndpointsSchema = strictObject({
@@ -98,6 +99,21 @@ const edgeConstraintsSchema = strictObject({
     noSelf: literal(true).optional(),
     acyclic: literal(true).optional(),
 });
+// A tuple names distinct fields: endpoints, the slug and Properties by key. Normalization puts
+// them, and the tuples, in canonical order (`compareEdgeUniqueFields`). No tuple is spelled by the
+// absence of the field, never by an empty list: one spelling per meaning, one revision.
+const edgeUniqueFieldSchema = union([
+    literal('source'),
+    literal('target'),
+    literal('slug'),
+    strictObject({ property: propertyKeySchema }),
+]);
+const edgeUniqueSchema = uniqueArray(uniqueArray(edgeUniqueFieldSchema).min(1), (tuple) => 
+// Two spellings of one set of fields are one tuple, repeated.
+JSON.stringify(tuple.map(canonicalJson).sort())).min(1);
+// A Node tuple names distinct Properties by key, which normalization puts in code-point order, as
+// it does the tuples (`compareNodeUniqueTuples`). Two orders of one set of keys are one tuple.
+const nodeUniqueSchema = uniqueArray(uniqueArray(propertyKeySchema).min(1), (tuple) => JSON.stringify([...tuple].sort())).min(1);
 const policyPatternSubjectSchema = strictObject({ kind: literal('subject') });
 const policyPatternObjectSchema = strictObject({ kind: literal('object') });
 const policyPatternSourceSchema = strictObject({ kind: literal('source') });
@@ -195,11 +211,16 @@ const valueFunctionInputSchema = jsonSchemaSchema.refine((value) => typeof value
 const callableExecutionSchema = strictObject({
     durable: boolean(),
 });
+// Its range is language meaning, refused by callable validation with DV_CALLABLE_ADMISSION.
+const callableAdmissionSchema = strictObject({
+    maxAge: number(),
+});
 const callableShape = {
     description: descriptionSchema.optional(),
     input: jsonSchemaSchema,
     output: callableOutputSchema,
     execution: callableExecutionSchema.optional(),
+    admission: callableAdmissionSchema.optional(),
     auth: enumeration(['anonymous', 'authenticated', 'authorized']),
     policy: union([literal(true), policyCheckExpressionSchema]).optional(),
 };
@@ -228,10 +249,13 @@ const edgeClassPoliciesSchema = strictObject({
     read: classPolicySchema.optional(),
     traverse: classPolicySchema.optional(),
 });
+// The default `'internal'` is the absence of the field: one spelling per meaning, one revision.
+const inheritanceSchema = enumeration(['open', 'final']);
 const nodeClassSchema = strictObject({
     ref: classRefSchema,
     kind: literal('node'),
     abstract: boolean(),
+    inheritance: inheritanceSchema.optional(),
     description: descriptionSchema.optional(),
     extends: uniqueArray(classRefSchema),
     properties: propertyRecordSchema,
@@ -239,15 +263,18 @@ const nodeClassSchema = strictObject({
     data: dataDeclarationSchema.optional(),
     icon: iconSchema.optional(),
     policies: nodeClassPoliciesSchema,
+    unique: nodeUniqueSchema.optional(),
 });
 const edgeClassShape = {
     ref: classRefSchema,
     kind: literal('edge'),
     abstract: boolean(),
+    inheritance: inheritanceSchema.optional(),
     description: descriptionSchema.optional(),
     extends: uniqueArray(classRefSchema),
     properties: propertyRecordSchema,
     constraints: edgeConstraintsSchema,
+    unique: edgeUniqueSchema.optional(),
 };
 const edgeClassSchema = strictObject({
     ...edgeClassShape,
@@ -257,14 +284,22 @@ const edgeClassSchema = strictObject({
 }).superRefine(validateEdgeOrientationShape);
 const classDeclarationSchema = discriminatedUnion('kind', [nodeClassSchema, edgeClassSchema]);
 function validateEdgeOrientationShape(value, context) {
-    if ((value.orientation === 'undirected') === Array.isArray(value.endpoints))
-        return;
-    context.addIssue({
-        code: 'custom',
-        path: ['endpoints'],
-        message: `${value.orientation} Edge endpoints have the wrong structural shape.`,
-        params: { structureCode: 'STRUCTURE_EDGE_ORIENTATION' },
-    });
+    if ((value.orientation === 'undirected') !== Array.isArray(value.endpoints)) {
+        context.addIssue({
+            code: 'custom',
+            path: ['endpoints'],
+            message: `${value.orientation} Edge endpoints have the wrong structural shape.`,
+            params: { structureCode: 'STRUCTURE_EDGE_ORIENTATION' },
+        });
+    }
+    if (value.orientation === 'undirected' && value.unique !== undefined) {
+        context.addIssue({
+            code: 'custom',
+            path: ['unique'],
+            message: 'Only a directed Edge Class declares unique tuples.',
+            params: { structureCode: 'STRUCTURE_EDGE_ORIENTATION' },
+        });
+    }
 }
 const functionDefinitionSchema = strictObject({
     ref: functionRefSchema,
@@ -368,11 +403,11 @@ function isStateTransitions(input) {
 function isRecord(input) {
     return input !== null && typeof input === 'object' && !Array.isArray(input);
 }
-function uniqueArray(element) {
+function uniqueArray(element, keyOf = canonicalJson) {
     return array(element).superRefine((values, context) => {
         const firstIndexByValue = new Map();
         values.forEach((value, index) => {
-            const key = canonicalJson(value);
+            const key = keyOf(value);
             const firstIndex = firstIndexByValue.get(key);
             if (firstIndex === undefined) {
                 firstIndexByValue.set(key, index);

package/dist/v1/schema/validation/policy/uses.js

@@ -28,11 +28,6 @@ function validateClassPolicyUses(context, typing, operation) {
             continue;
         const pointer = `/classes/${escapePointer(name)}/policies/${operation}`;
         if (isClassRuleChecks(ref)) {
-            // A rule lifts the Class ceiling the way a named Policy does, so, as a Policy connects its
-            // subject, each way the rule holds must pass through a check of the caller.
-            if (!checksNameTheCaller(ref)) {
-                context.add('PL_CONNECTIVITY', pointer, `Every branch of the ${operation} rule of Node Class ${name} must check a Policy: sameNode alone names no caller.`);
-            }
             // Structure admits Policy checks only on a Node Class: `self` is the observed exact Class.
             validateChecks(context, typing, ref, {
                 site: 'class',
@@ -107,6 +102,11 @@ function validateDeclaredMethods(context, typing, namespace, name, methods, rece
     }
 }
 function validateChecks(validation, typing, expression, context) {
+    // Checks decide the caller the way a named Policy does, so, as a Policy connects its subject,
+    // each way they hold must pass through a check of the caller.
+    if (!checksNameTheCaller(expression)) {
+        validation.add('PL_CONNECTIVITY', context.pointer, `${SITE[context.site].checks} must check a Policy on every branch: sameNode alone names no caller.`);
+    }
     const normalized = normalizePolicyChecks(expression);
     const measure = measureChecks(normalized);
     if (measure.depth > MAX_CHECK_DEPTH ||

package/dist/value/canonical.d.ts

@@ -5,3 +5,8 @@ export declare function serialize(input: unknown, options?: Options): string;
 /** Serialize a trusted portable value whose default structural admission proof is still valid. */
 export declare function serializeAdmitted(input: Value): string;
 export declare function encode(input: unknown, options?: Options): Uint8Array;
+/**
+ * The UTF-8 byte length of a trusted Value's canonical JSON, `encode(input).byteLength`: an
+ * admission-owned immutable root counted its bytes when it was admitted, so it is not serialized.
+ */
+export declare function byteLength(input: Value): number;

package/dist/value/canonical.js

@@ -31,6 +31,18 @@ function serializeSnapshot(input, maxBytes) {
 export function encode(input, options) {
     return encoder.encode(serialize(input, options));
 }
+/**
+ * The UTF-8 byte length of a trusted Value's canonical JSON, `encode(input).byteLength`: an
+ * admission-owned immutable root counted its bytes when it was admitted, so it is not serialized.
+ */
+export function byteLength(input) {
+    if (input !== null && typeof input === 'object') {
+        const bytes = immutableSnapshotBytes(input);
+        if (bytes !== undefined)
+            return bytes;
+    }
+    return utf8Length(serializeAdmitted(input));
+}
 function serializeValue(value) {
     if (value === null)
         return 'null';

package/dist/value/json.d.ts

@@ -1,3 +1,3 @@
-export { encode, serialize, serializeAdmitted } from './canonical.js';
+export { byteLength, encode, serialize, serializeAdmitted } from './canonical.js';
 export { decode } from './decode.js';
 export { DecodeError } from './error.js';

package/dist/value/json.js

@@ -1,3 +1,3 @@
-export { encode, serialize, serializeAdmitted } from './canonical.js';
+export { byteLength, encode, serialize, serializeAdmitted } from './canonical.js';
 export { decode } from './decode.js';
 export { DecodeError } from './error.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.11",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {

package/dist/v1/builder/lowering/core-properties.d.ts

@@ -1,10 +0,0 @@
-import type { CoreContent } from '../../language/core/model/core.js';
-import type { DomainSchemaLookup } from '../../schema/dependency/lookup.js';
-import type { DomainSchemaIR } from '../../schema/model/schema.js';
-import type { UnqualifiedCoreContent } from './core.js';
-type UnqualifiedDomainSchema = Omit<DomainSchemaIR, 'core'> & {
-    readonly core: UnqualifiedCoreContent;
-};
-/** Lower rich builder shorthand to the canonical full-key Core representation. */
-export declare function canonicalizeCorePropertyKeys(candidate: UnqualifiedDomainSchema, lookup: DomainSchemaLookup): CoreContent;
-export {};

package/dist/v1/builder/lowering/core-properties.js

@@ -1,76 +0,0 @@
-import { PropertyKey as admitPropertyKey } from '../../addressing/index.js';
-import { definitionRefIndex } from '../../addressing/ordering.js';
-import { createPropertyValues } from '../../language/class/property-values.js';
-import { analyzeDefinitions } from '../../schema/analysis/class.js';
-import { buildDomainResolutionContext } from '../../schema/resolution/context.js';
-import { escapeToken, fail } from '../schema/diagnostic.js';
-/** Lower rich builder shorthand to the canonical full-key Core representation. */
-export function canonicalizeCorePropertyKeys(candidate, lookup) {
-    // Core Property values do not participate in Class composition. Analyze the
-    // already-canonical Definition surface, then admit Core values below.
-    const analysisCandidate = {
-        ...candidate,
-        core: { nodes: {}, edges: [] },
-    };
-    const definitions = analyzeDefinitions(buildDomainResolutionContext(analysisCandidate, lookup)).definitions;
-    const nodes = Object.fromEntries(Object.entries(candidate.core.nodes).map(([slug, node]) => {
-        const definition = definitions.get(definitionRefIndex(node.class));
-        if (definition === undefined) {
-            fail('BUILDER_CORE_PROPERTY', `/core/nodes/${escapeToken(slug)}/class`, 'Core property shorthand requires a resolvable concrete Class.');
-        }
-        return [
-            slug,
-            {
-                ...node,
-                properties: qualify(node.properties, definition, `/core/nodes/${escapeToken(slug)}/properties`),
-            },
-        ];
-    }));
-    const edges = candidate.core.edges.map((edge, index) => {
-        const definition = definitions.get(definitionRefIndex(edge.class));
-        if (definition === undefined) {
-            fail('BUILDER_CORE_PROPERTY', `/core/edges/${index}/class`, 'Core property shorthand requires a resolvable concrete Class.');
-        }
-        return {
-            ...edge,
-            properties: qualify(edge.properties, definition, `/core/edges/${index}/properties`),
-        };
-    });
-    return { nodes, edges };
-}
-function qualify(input, definition, pointer) {
-    const byName = new Map();
-    for (const [key, field] of definition.properties) {
-        const candidates = byName.get(field.name) ?? [];
-        candidates.push(key);
-        byName.set(field.name, candidates);
-    }
-    const result = {};
-    const sourceByKey = new Map();
-    for (const [inputKey, value] of Object.entries(input)) {
-        const key = resolveInputKey(inputKey, definition, byName, `${pointer}/${escapeToken(inputKey)}`);
-        const previous = sourceByKey.get(key);
-        if (previous !== undefined) {
-            fail('BUILDER_CORE_PROPERTY', `${pointer}/${escapeToken(inputKey)}`, `Property is supplied twice through ${JSON.stringify(previous)} and ${JSON.stringify(inputKey)}.`);
-        }
-        sourceByKey.set(key, inputKey);
-        result[key] = value;
-    }
-    return createPropertyValues(Object.entries(result).map(([key, value]) => [admitPropertyKey(key), value]));
-}
-function resolveInputKey(input, definition, byName, pointer) {
-    if (admitPropertyKey.is(input)) {
-        const key = admitPropertyKey(input);
-        if (!definition.properties.has(key)) {
-            fail('BUILDER_CORE_PROPERTY', pointer, `Property ${input} is not present on the Core Class.`);
-        }
-        return key;
-    }
-    const candidates = byName.get(input) ?? [];
-    if (candidates.length === 1)
-        return candidates[0];
-    if (candidates.length === 0) {
-        fail('BUILDER_CORE_PROPERTY', pointer, `Property ${JSON.stringify(input)} does not exist.`);
-    }
-    fail('BUILDER_CORE_PROPERTY', pointer, `Property ${JSON.stringify(input)} is ambiguous; use one of: ${candidates.join(', ')}.`);
-}