@astrale-os/kernel-dsl 0.2.0-beta.8 → 0.2.0

package/dist/v1/builder/lowering/schema/context.d.ts

@@ -1,13 +1,13 @@
-import type { CoreRef, ClassRef, DefinitionRef, FunctionRef, PolicyRef, ViewRef } from '../../../addressing/index.js';
+import type { ClassRef, DefinitionRef, FunctionRef, PolicyRef, ViewRef } from '../../../addressing/index.js';
 import type { DomainDependency } from '../../../addressing/index.js';
 import type { ClassKind } from '../../../language/class/model/class.js';
 import type { CoreEndpointRef } from '../../../language/core/model/core.js';
-import type { PolicyObjectRef } from '../../../language/policy/model/policy.js';
+import type { PolicyObjectRef } from '../../../language/index.js';
 import type { ValueSchemaRegistry } from '../../../language/value/reference/registry.js';
 import type { DomainSchema, DomainSchemaIR } from '../../../schema/model/schema.js';
 import type { Function, PolicyObjectInput } from '../../callable/authoring.js';
 import type { Class, ClassReferenceInput } from '../../class/authoring.js';
-import type { CoreNode } from '../../core/authoring.js';
+import type { CoreEndpoint, CoreNode } from '../../core/authoring.js';
 import type { Policy } from '../../policy/authoring.js';
 import type { View } from '../../view/authoring.js';
 import { type Lazy } from '../../schema/lazy.js';
@@ -19,9 +19,6 @@ export declare class BuilderContext {
     readonly localDefinitions: Map<string, DefinitionRef<import("../../../addressing/definition-ref.js").Definition.Kind, string>>;
     readonly localClassKinds: Map<string, ClassKind>;
     readonly policies: Map<object, PolicyRef>;
-    readonly coreNodes: Map<CoreNode<Lazy<import("../../class/authoring.js").NodeClass<import("../../class/authoring.js").NodeClassInput>>, (Readonly<Record<`${string}:class.${string}.property.${string}`, import("../../../language/index.js").PropertyValue>> | Readonly<{} & {
-        [x: string]: unknown;
-    }>) & import("../../../../value/types.js").Object>, CoreRef>;
     readonly policyObjects: Map<object, PolicyObjectRef>;
     readonly policyObjectRefs: Set<string>;
     readonly usedForeignOrigins: Set<string>;
@@ -36,11 +33,17 @@ export declare class BuilderContext {
     resolveEdgeClass(input: ClassReferenceInput, pointer: string): ClassRef;
     resolvePolicy(input: Lazy<unknown>, pointer: string): PolicyRef;
     resolvePolicyObject(input: PolicyObjectInput | PolicyObjectRef, pointer: string): PolicyObjectRef;
-    resolveCoreEndpoint(value: CoreNode | CoreEndpointRef, pointer: string): CoreEndpointRef;
+    /** A Core fact belongs to the Domain that declares it, so a dependency endpoint never resolves. */
+    resolveCoreEndpoint(input: CoreEndpoint, pointer: string): CoreEndpointRef;
+    /**
+     * The shared lookup from one already-resolved authoring value to its ref; each caller owns its
+     * own admission rule and diagnostic.
+     */
+    private policyObjectRef;
     dependencies(): Readonly<Record<string, DomainDependency>>;
     valueRegistry(): ValueSchemaRegistry;
     noteDomainEndpointReferences(schema: DomainSchemaIR): void;
     private assertVisible;
     private classKind;
-    private capturePolicyObject;
+    capturePolicyObject(value: object, ref: PolicyObjectRef): void;
 }

package/dist/v1/builder/lowering/schema/context.js

@@ -1,5 +1,7 @@
 import { compareDefinitionRefs, compareUnicode, definitionRefIndex, } from '../../../addressing/ordering.js';
 import { DEPENDENCY_ALIAS_PATTERN } from '../../../addressing/patterns.js';
+import { isMethodExecutable } from '../../../language/callable/executable.js';
+import { policyObjectKey, policyObjectOrigin } from '../../../language/index.js';
 import { graphNodePathSchema } from '../../../language/value/syntax/node-path/schema.js';
 import { revisionOfDomainSchema } from '../../../schema/canonical/revision.js';
 import { requireDomainClosure } from '../../../schema/resolution/closure.js';
@@ -13,7 +15,6 @@ export class BuilderContext {
     localDefinitions = new Map();
     localClassKinds = new Map();
     policies = new Map();
-    coreNodes = new Map();
     policyObjects = new Map();
     policyObjectRefs = new Set();
     usedForeignOrigins = new Set();
@@ -50,22 +51,21 @@ export class BuilderContext {
         this.capturePolicyObject(value, ref);
     }
     capturePolicy(value, ref, pointer) {
-        this.ownership.capture(value, `${ref.origin}:policy.${ref.name}`, pointer);
+        this.ownership.captureDefinition(value, ref, pointer);
         this.policies.set(value, ref);
         this.capturePolicyObject(value, ref);
     }
     captureCoreNode(value, slug, pointer) {
-        this.ownership.capture(value, `${this.origin}:core.${slug}`, pointer);
         const ref = { origin: this.origin, kind: 'core', name: slug };
-        this.coreNodes.set(value, ref);
+        this.ownership.captureDefinition(value, ref, pointer);
         this.capturePolicyObject(value, ref);
     }
     captureFunction(value, ref, pointer) {
-        this.ownership.capture(value, `${ref.origin}:function.${ref.name}`, pointer);
+        this.ownership.captureDefinition(value, ref, pointer);
         this.capturePolicyObject(value, ref);
     }
     captureView(value, ref, pointer) {
-        this.ownership.capture(value, `${ref.origin}:view.${ref.name}`, pointer);
+        this.ownership.captureDefinition(value, ref, pointer);
         this.capturePolicyObject(value, ref);
     }
     resolveClass(input, kind, pointer) {
@@ -108,28 +108,45 @@ export class BuilderContext {
         return { ...ref };
     }
     resolvePolicyObject(input, pointer) {
-        const value = resolveLazy(input, pointer);
-        const ref = isPolicyObjectRef(value)
-            ? value
-            : typeof value === 'object' && value !== null
-                ? this.policyObjects.get(value)
-                : undefined;
-        if (ref === undefined ||
-            ref.origin !== this.origin ||
-            !this.policyObjectRefs.has(definitionRefIndex(ref))) {
-            fail('BUILDER_POLICY_REF', pointer, 'Policy ref(...) must name one registered local Definition, Function, Policy, View, or Core Node.');
+        const ref = this.policyObjectRef(resolveLazy(input, pointer));
+        const origin = ref === undefined ? undefined : policyObjectOrigin(ref);
+        const dependency = origin === undefined ? undefined : this.#dependencies.get(origin)?.schema;
+        const admitted = ref !== undefined &&
+            (origin === this.origin
+                ? this.policyObjectRefs.has(policyObjectKey(ref))
+                : dependency !== undefined && hasPolicyObject(dependency, ref));
+        if (!admitted || ref === undefined) {
+            fail('BUILDER_POLICY_REF', pointer, 'Policy ref(...) must name one registered local or direct-dependency Definition, Function, Method, Policy, View, or Core Node.');
         }
+        const admittedOrigin = policyObjectOrigin(ref);
+        if (admittedOrigin !== this.origin)
+            this.usedForeignOrigins.add(admittedOrigin);
         return { ...ref };
     }
-    resolveCoreEndpoint(value, pointer) {
+    /** A Core fact belongs to the Domain that declares it, so a dependency endpoint never resolves. */
+    resolveCoreEndpoint(input, pointer) {
+        const value = resolveLazy(input, pointer);
         if (isDomainEndpointRef(value))
             return { kind: 'domain' };
-        const ref = isCoreRef(value) ? value : this.coreNodes.get(value);
-        if (ref === undefined || ref.origin !== this.origin) {
-            fail('BUILDER_CORE_REF', pointer, 'A Core reference must name a registered local Core Node.');
+        const ref = this.policyObjectRef(value);
+        if (ref === undefined ||
+            policyObjectOrigin(ref) !== this.origin ||
+            !this.policyObjectRefs.has(policyObjectKey(ref))) {
+            fail('BUILDER_CORE_REF', pointer, 'A Core Edge endpoint must name one registered local Definition, Function, Method, Policy, View, or Core Node.');
         }
         return { ...ref };
     }
+    /**
+     * The shared lookup from one already-resolved authoring value to its ref; each caller owns its
+     * own admission rule and diagnostic.
+     */
+    policyObjectRef(value) {
+        if (isPolicyObjectRef(value))
+            return value;
+        return typeof value === 'object' && value !== null
+            ? (this.policyObjects.get(value) ?? this.ownership.definition(value))
+            : undefined;
+    }
     dependencies() {
         return Object.fromEntries([...this.#dependencies.values()]
             .sort((left, right) => compareUnicode(left.alias, right.alias))
@@ -191,7 +208,7 @@ export class BuilderContext {
     }
     capturePolicyObject(value, ref) {
         this.policyObjects.set(value, ref);
-        this.policyObjectRefs.add(definitionRefIndex(ref));
+        this.policyObjectRefs.add(policyObjectKey(ref));
     }
 }
 function escapePointer(value) {
@@ -217,18 +234,12 @@ function isDefinitionRef(value) {
         typeof candidate.name === 'string' &&
         candidate.kind === 'class');
 }
-function isCoreRef(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    const candidate = value;
-    return (typeof candidate.origin === 'string' &&
-        candidate.kind === 'core' &&
-        typeof candidate.name === 'string');
-}
 function isPolicyObjectRef(value) {
     if (typeof value !== 'object' || value === null)
         return false;
     const candidate = value;
+    if (candidate.kind === 'method')
+        return isDefinitionRef(candidate.owner) && typeof candidate.name === 'string';
     return (typeof candidate.origin === 'string' &&
         typeof candidate.name === 'string' &&
         (candidate.kind === 'class' ||
@@ -245,3 +256,22 @@ function definitionRefsOf(schema) {
     }
     return refs.sort(compareDefinitionRefs);
 }
+function hasPolicyObject(schema, ref) {
+    switch (ref.kind) {
+        case 'method': {
+            const owner = schema.classes[ref.owner.name];
+            const method = owner?.kind === 'node' ? owner.methods[ref.name] : undefined;
+            return method !== undefined && isMethodExecutable(owner, method);
+        }
+        case 'class':
+            return Object.hasOwn(schema.classes, ref.name);
+        case 'function':
+            return Object.hasOwn(schema.functions, ref.name);
+        case 'policy':
+            return Object.hasOwn(schema.policies, ref.name);
+        case 'view':
+            return Object.hasOwn(schema.views, ref.name);
+        case 'core':
+            return Object.hasOwn(schema.core.nodes, ref.name);
+    }
+}

package/dist/v1/builder/lowering/schema/ownership.d.ts

@@ -1,8 +1,8 @@
-import type { DefinitionRef } from '../../../addressing/index.js';
+import type { PolicyObjectRef } from '../../../language/index.js';
 export declare class OwnershipCapture {
     #private;
-    captureDefinition(value: object, ref: DefinitionRef, pointer: string): void;
+    captureDefinition(value: object, ref: PolicyObjectRef, pointer: string): void;
     capture(value: object, owner: string, pointer: string): void;
-    definition(value: object): DefinitionRef | undefined;
+    definition(value: object): PolicyObjectRef | undefined;
     commit(): void;
 }

package/dist/v1/builder/lowering/schema/ownership.js

@@ -1,3 +1,4 @@
+import { policyObjectKey } from '../../../language/index.js';
 import { fail } from '../../schema/diagnostic.js';
 const definitionOwners = new WeakMap();
 const semanticOwners = new WeakMap();
@@ -5,7 +6,7 @@ export class OwnershipCapture {
     #definitions = new Map();
     #owners = new Map();
     captureDefinition(value, ref, pointer) {
-        this.capture(value, `${ref.origin}:${ref.kind}.${ref.name}`, pointer);
+        this.capture(value, policyObjectKey(ref), pointer);
         this.#definitions.set(value, ref);
     }
     capture(value, owner, pointer) {

package/dist/v1/builder/lowering/value/compile.js

@@ -1,5 +1,5 @@
 import { accept as acceptJsonValue } from '@astrale-os/kernel-dsl/value';
-import { z } from 'zod';
+import { ZodType } from 'zod';
 import { compareDefinitionRefs } from '../../../addressing/ordering.js';
 import { canonicalizeValueSchema } from '../../../language/value/profile/canonicalize.js';
 import { validateValueSchema } from '../../../language/value/profile/validate.js';
@@ -36,18 +36,28 @@ export class BuilderValueSchemas {
             compiled[name] = {
                 schema: canonicalizeValueSchema(schema, 'property-facet', this.registry),
                 required: authoredInput?.options.required ?? isRequired(schemaInput),
-                visibility: authoredInput?.options.visibility ?? 'public',
                 ...(autoInput === undefined ? {} : { auto: autoInput.options }),
+                ...(authoredInput?.options.immutable === undefined
+                    ? {}
+                    : { immutable: authoredInput.options.immutable }),
                 ...(authoredInput?.options.description === undefined
                     ? {}
                     : { description: authoredInput.options.description }),
+                ...(authoredInput?.machine === undefined
+                    ? {}
+                    : {
+                        state: {
+                            initial: authoredInput.machine.initial,
+                            transitions: authoredInput.machine.transitions,
+                        },
+                    }),
             };
         }
         return compiled;
     }
     lower(input, conversionContext, pointer, zodPosition = 'value') {
         let schema;
-        if (input instanceof z.ZodType) {
+        if (input instanceof ZodType) {
             const converted = convertZodToValueSchema(input, conversionContext, this.registry, pointer, {
                 position: zodPosition,
                 validate: false,
@@ -130,7 +140,7 @@ function isAutoProperty(value) {
     return isAuthoringValue(value, 'auto');
 }
 function isRequired(value) {
-    if (!(value instanceof z.ZodType))
+    if (!(value instanceof ZodType))
         return true;
     return !zodObjectPropertyIsOptional(value);
 }

package/dist/v1/builder/lowering/value/zod.d.ts

@@ -1,8 +1,8 @@
-import { z } from 'zod';
+import { ZodType } from 'zod';
 import type { JsonSchema, ValueSchemaContext } from '../../../language/value/model/schema.js';
 import type { ValueSchemaRegistry } from '../../../language/value/reference/registry.js';
 import type { BuilderDiagnostic } from '../../schema/diagnostic.js';
-export type ZodValueSchemaConversion = {
+type ZodValueSchemaConversion = {
     readonly ok: true;
     readonly schema: JsonSchema;
     readonly diagnostics: readonly [];
@@ -10,7 +10,7 @@ export type ZodValueSchemaConversion = {
     readonly ok: false;
     readonly diagnostics: readonly BuilderDiagnostic[];
 };
-export interface ZodValueSchemaConversionOptions {
+interface ZodValueSchemaConversionOptions {
     /** Undefined is representable only as absence at a containing object-property boundary. */
     readonly position?: 'value' | 'object-property';
     /** Builder-only lowering hook keyed by the original Zod schema identity. */
@@ -19,7 +19,7 @@ export interface ZodValueSchemaConversionOptions {
     readonly validate?: boolean;
 }
 export interface ZodValueSchemaOverrideContext {
-    readonly zodSchema: z.ZodType;
+    readonly zodSchema: ZodType;
     readonly jsonSchema: Record<string, unknown>;
     readonly path: readonly (string | number)[];
 }
@@ -27,6 +27,7 @@ export interface ZodValueSchemaOverrideContext {
  * Converts only Zod contracts whose JSON-value acceptance is represented
  * without coercion, effects, custom predicates, or format assertions.
  */
-export declare function convertZodToValueSchema(zodSchema: z.ZodType, context: ValueSchemaContext, registry: ValueSchemaRegistry, pointer?: string, options?: ZodValueSchemaConversionOptions): ZodValueSchemaConversion;
+export declare function convertZodToValueSchema(zodSchema: ZodType, context: ValueSchemaContext, registry: ValueSchemaRegistry, pointer?: string, options?: ZodValueSchemaConversionOptions): ZodValueSchemaConversion;
 /** Whether explicit Zod optionality makes a containing object property absent-able. */
-export declare function zodObjectPropertyIsOptional(schema: z.ZodType): boolean;
+export declare function zodObjectPropertyIsOptional(schema: ZodType): boolean;
+export {};

package/dist/v1/builder/lowering/value/zod.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { ZodObject, ZodType, toJSONSchema } from 'zod';
 import { VALUE_SCHEMA_DIALECT } from '../../../language/value/model/schema.js';
 import { canonicalizeValueSchema } from '../../../language/value/profile/canonicalize.js';
 import { validateValueSchema } from '../../../language/value/profile/validate.js';
@@ -15,19 +15,19 @@ export function convertZodToValueSchema(zodSchema, context, registry, pointer =
         return { ok: false, diagnostics };
     let converted;
     try {
-        const raw = z.toJSONSchema(zodSchema, {
+        const raw = toJSONSchema(zodSchema, {
             target: 'draft-2020-12',
             unrepresentable: 'throw',
             io: 'input',
             cycles: 'ref',
             reused: 'inline',
             override: ({ zodSchema: source, jsonSchema, path }) => {
-                if (source instanceof z.ZodObject) {
+                if (source instanceof ZodObject) {
                     jsonSchema.required = Object.entries(source.shape)
                         .filter(([, property]) => !zodObjectPropertyIsOptional(property))
                         .map(([name]) => name);
                 }
-                if (source instanceof z.ZodType) {
+                if (source instanceof ZodType) {
                     lowerFullMatchChecks(source, jsonSchema);
                     options.override?.({
                         jsonSchema: jsonSchema,
@@ -161,7 +161,10 @@ function inspectCheck(def, pointer, diagnostics) {
         return;
     }
     if (def.check === 'string_format' && def.format === 'regex' && def.pattern instanceof RegExp) {
-        if (!isLosslessRegexp(def.pattern)) {
+        if (def.pattern.flags === '') {
+            diagnostics.push(diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', pointer, 'Zod RegExp without the u flag reads \\p{...} as literal text, and classes and quantifiers by UTF-16 code unit, unlike the V1 I-Regexp it would lower to; add the u flag.'));
+        }
+        else if (!isLosslessRegexp(def.pattern)) {
             diagnostics.push(diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', pointer, 'Zod RegExp flags, anchors, dot semantics, or syntax cannot be preserved as a V1 I-Regexp substring pattern.'));
         }
     }
@@ -284,7 +287,7 @@ function getCheckDefinition(value) {
     return isPlainRecord(internals?.def) ? internals.def : undefined;
 }
 function isZodType(value) {
-    return value instanceof z.ZodType;
+    return value instanceof ZodType;
 }
 function escapePointerToken(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
@@ -292,8 +295,14 @@ function escapePointerToken(value) {
 function isPlainRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
+/**
+ * Whether a Zod RegExp search means its source read as an I-Regexp. Only the u flag qualifies:
+ * without it, `\p{L}` matches the text `p{L}`, and classes and quantifiers apply to UTF-16 code
+ * units rather than scalars; `v` reads class syntax differently, and every other flag changes the
+ * match itself.
+ */
 function isLosslessRegexp(pattern) {
-    if (pattern.flags !== '' && pattern.flags !== 'u')
+    if (pattern.flags !== 'u')
         return false;
     if (!isIRegexp(pattern.source))
         return false;

package/dist/v1/builder/lowering/view.d.ts

@@ -1,11 +1,12 @@
 import type { ViewDefinition } from '../../language/view/model/view.js';
 import type { View } from '../view/authoring.js';
 import type { BuilderContext } from './schema/context.js';
-export interface ViewCompiler {
-    compile(value: View, name: string, pointer: string): ViewDefinition;
+interface ViewCompiler {
+    compile(value: View, name: string): ViewDefinition;
 }
 export declare class V1ViewCompiler implements ViewCompiler {
     readonly context: BuilderContext;
     constructor(context: BuilderContext);
-    compile(value: View, name: string, pointer: string): ViewDefinition;
+    compile(value: View, name: string): ViewDefinition;
 }
+export {};

package/dist/v1/builder/lowering/view.js

@@ -1,27 +1,15 @@
-import { compareDefinitionRefs } from '../../addressing/ordering.js';
 import { viewAuthoringInput } from '../view/authoring.js';
 export class V1ViewCompiler {
     context;
     constructor(context) {
         this.context = context;
     }
-    compile(value, name, pointer) {
+    compile(value, name) {
         const config = viewAuthoringInput(value);
-        const target = config.target;
         return {
             ref: { origin: this.context.origin, kind: 'view', name },
             ...(config.description === undefined ? {} : { description: config.description }),
-            target: target === undefined || target === 'domain'
-                ? { kind: 'domain' }
-                : {
-                    kind: 'definition',
-                    definitions: (isTargetList(target) ? target : [target])
-                        .map((entry, index) => this.context.resolveNodeClass(entry, `${pointer}/target/definitions/${index}`))
-                        .sort(compareDefinitionRefs),
-                },
+            target: { kind: 'domain' },
         };
     }
 }
-function isTargetList(input) {
-    return Array.isArray(input);
-}

package/dist/v1/builder/policy/authoring.d.ts

@@ -1,21 +1,37 @@
 import type { ClassRef } from '../../addressing/index.js';
-import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm } from '../../language/policy/model/policy.js';
-import type { EdgeClass, NodeClass } from '../class/authoring.js';
+import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm, PolicyObjectRef } from '../../language/policy/model/policy.js';
+import type { PolicyObjectInput } from '../callable/authoring.js';
+import type { EdgeClassReferenceInput, NodeClassReferenceInput } from '../class/authoring.js';
 import type { AuthoringValue } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
 export interface PolicyEdgeInput {
     readonly source: CanonicalPolicyPatternTerm;
-    readonly class: Lazy<EdgeClass>;
+    readonly class: EdgeClassReferenceInput;
     readonly target: CanonicalPolicyPatternTerm;
     readonly repeat?: {
         readonly min: number;
         readonly max: number;
     };
 }
+export interface PolicyNodeBinder {
+    (): CanonicalPolicyPatternTerm;
+    (definition: NodeClassReferenceInput): CanonicalPolicyPatternTerm;
+    readonly exact: (definition: NodeClassReferenceInput) => CanonicalPolicyPatternTerm;
+}
 export interface PolicyExistsContext {
-    node(definition: Lazy<NodeClass>): CanonicalPolicyPatternTerm;
+    readonly node: PolicyNodeBinder;
 }
 export interface PolicyPatternContext {
+    ref(member: PolicyObjectInput): CanonicalPolicyPatternTerm;
+    sameNode(left: CanonicalPolicyPatternTerm, right: CanonicalPolicyPatternTerm): PolicyPatternExpression;
+    /**
+     * The caller, as each Identity of its live composition: a branch holds when the caller or a
+     * group it extends through `extends_with`, at any depth, satisfies it, each constraint holds and
+     * no exclusion denies it. A fact a group holds is one Edge from the subject: a walk over
+     * `extends_with` reads raw Edges and skips the constraints and exclusions of the groups it
+     * crosses. Membership in a group is `sameNode(subject, object)` checked against that group. One
+     * Identity satisfies a whole branch: facts that different groups supply are separate checks.
+     */
     readonly subject: CanonicalPolicyPatternTerm;
     readonly object: CanonicalPolicyPatternTerm;
     readonly source: CanonicalPolicyPatternTerm;
@@ -45,8 +61,9 @@ export interface PolicyBuilder {
 export declare function policyDeclaration(value: Policy): PolicyDeclaration;
 export declare const policy: PolicyBuilder;
 export declare function createPatternContext(options: {
-    readonly resolveEdgeClass: (value: Lazy<EdgeClass>, pointer: string) => ClassRef;
-    readonly resolveNodeClass: (value: Lazy<NodeClass>, pointer: string) => ClassRef;
+    readonly resolveObject: (value: PolicyObjectInput, pointer: string) => PolicyObjectRef;
+    readonly resolveEdgeClass: (value: EdgeClassReferenceInput, pointer: string) => ClassRef;
+    readonly resolveNodeClass: (value: NodeClassReferenceInput, pointer: string) => ClassRef;
     readonly pointer: string;
 }): PolicyPatternContext;
 export type { PolicyCheckExpression };

package/dist/v1/builder/policy/authoring.js

@@ -32,6 +32,11 @@ export function createPatternContext(options) {
     const source = Object.freeze({ kind: 'source' });
     const target = Object.freeze({ kind: 'target' });
     const context = {
+        ref: (member) => ({
+            kind: 'ref',
+            ref: options.resolveObject(member, `${options.pointer}/match/ref`),
+        }),
+        sameNode: (left, right) => ({ sameNode: { left, right } }),
         subject,
         object,
         source,
@@ -49,16 +54,38 @@ export function createPatternContext(options) {
         },
         exists(build) {
             const nodes = [];
-            const where = build({
-                node(definition) {
-                    const variable = Object.freeze({ kind: 'variable', id: nextVariable++ });
-                    nodes.push({
-                        variable,
-                        class: options.resolveNodeClass(definition, `${options.pointer}/match/exists/nodes`),
-                    });
-                    return variable;
+            const bind = (selector, definition) => {
+                const variable = Object.freeze({ kind: 'variable', id: nextVariable++ });
+                if (selector === 'any') {
+                    nodes.push({ variable, selector: Object.freeze({ kind: 'any' }) });
+                }
+                else {
+                    const classRef = options.resolveNodeClass(definition, `${options.pointer}/match/exists/nodes`);
+                    nodes.push(selector === 'exact'
+                        ? { variable, class: classRef }
+                        : { variable, selector: Object.freeze({ kind: 'satisfies', class: classRef }) });
+                }
+                return variable;
+            };
+            const node = function (...args) {
+                if (args.length > 1 || (args.length === 1 && args[0] === undefined)) {
+                    fail('BUILDER_POLICY', `${options.pointer}/match/exists/nodes`, 'node(...) accepts either no arguments or one Node Class.');
+                }
+                return args.length === 0
+                    ? bind('any')
+                    : bind('satisfies', args[0]);
+            };
+            Object.defineProperty(node, 'exact', {
+                enumerable: true,
+                value(definition) {
+                    if (arguments.length !== 1 || definition === undefined) {
+                        fail('BUILDER_POLICY', `${options.pointer}/match/exists/nodes`, 'node.exact(...) requires exactly one Node Class.');
+                    }
+                    return bind('exact', definition);
                 },
             });
+            Object.freeze(node);
+            const where = build({ node });
             if (nodes.length === 0) {
                 fail('BUILDER_POLICY_EMPTY_EXISTS', `${options.pointer}/match/exists/nodes`, 'exists(...) must declare at least one variable Node.');
             }

package/dist/v1/builder/schema/define.d.ts

@@ -1,10 +1,13 @@
+import type { Domain } from '../../domain/model/domain.js';
 import type { DomainSchema } from '../../schema/model/schema.js';
-import type { DomainSchemaInput } from './input.js';
-import type { DomainOfInput } from './projection.js';
+import type { DomainSchemaInput, EntrypointOf } from './input.js';
+import type { ResolvedDomainOfInput } from './projection.js';
 export type { DomainSchemaInput } from './input.js';
 /** Exact named Schema produced from one authored input. */
-export interface DefinedSchema<Origin extends string, Input extends DomainSchemaInput> extends DomainSchema<Origin, Input, DomainOfInput<Origin, Input>> {
+export interface DefinedSchema<Origin extends string, Resolved extends Domain> extends DomainSchema<Origin, Resolved> {
 }
 /** Build and semantically accept one immutable V1 DomainSchema. */
-export declare function defineSchema<const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input): DefinedSchema<Origin, Input>;
-export type { DirectDependenciesOf, DomainOfInput } from './projection.js';
+export declare function defineSchema<const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input & {
+    readonly entrypoint?: EntrypointOf<Input>;
+}): DefinedSchema<Origin, ResolvedDomainOfInput<Origin, Input>>;
+export type { ResolvedDomainOfInput } from './projection.js';

package/dist/v1/builder/schema/diagnostic.d.ts

@@ -1,5 +1,5 @@
 import type { DiagnosticCode as LanguageDiagnosticCode } from '../../language/validation/diagnostic.js';
-export type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_NESTED' | 'BUILDER_AUTO_SET_INVALID' | 'BUILDER_CALLABLE_AUTH' | 'BUILDER_CALLABLE_PLACEMENT' | 'BUILDER_CALLABLE_POLICY_AUTH' | 'BUILDER_CORE_CLASS' | 'BUILDER_CORE_EDGE' | 'BUILDER_CORE_NODE' | 'BUILDER_CORE_PROPERTY' | 'BUILDER_CORE_REF' | 'BUILDER_DEFINITION' | 'BUILDER_DEPENDENCY_CONFLICT' | 'BUILDER_DEPENDENCY_ALIAS' | 'BUILDER_DEPENDENCY_DIRECT' | 'BUILDER_DUPLICATE_MEMBER' | 'BUILDER_FOREIGN_POLICY' | 'BUILDER_FULL_MATCH_INVALID' | 'BUILDER_FUNCTION' | 'BUILDER_METHOD' | 'BUILDER_PATH_DUPLICATE' | 'BUILDER_PATH_EMPTY' | 'BUILDER_POLICY' | 'BUILDER_POLICY_COMPOSITION' | 'BUILDER_POLICY_CYCLE' | 'BUILDER_POLICY_EMPTY_COMPOSITION' | 'BUILDER_POLICY_EMPTY_EXISTS' | 'BUILDER_POLICY_INPUT' | 'BUILDER_POLICY_REF' | 'BUILDER_POLICY_SELF' | 'BUILDER_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | 'BUILDER_UNKNOWN_FIELD' | 'BUILDER_UNOWNED_REFERENCE' | 'BUILDER_VIEW' | 'ZOD_SCHEMA_NOT_LOSSLESS';
+export type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_IMMUTABLE' | 'BUILDER_AUTO_NESTED' | 'BUILDER_AUTO_SET_INVALID' | 'BUILDER_CALLABLE_AUTH' | 'BUILDER_CALLABLE_PLACEMENT' | 'BUILDER_CALLABLE_POLICY_AUTH' | 'BUILDER_CORE_CLASS' | 'BUILDER_CORE_EDGE' | 'BUILDER_CORE_NODE' | 'BUILDER_CORE_PROPERTY' | 'BUILDER_CORE_REF' | 'BUILDER_DEFINITION' | 'BUILDER_DEPENDENCY_CONFLICT' | 'BUILDER_DEPENDENCY_ALIAS' | 'BUILDER_DEPENDENCY_DIRECT' | 'BUILDER_DUPLICATE_MEMBER' | 'BUILDER_FOREIGN_POLICY' | 'BUILDER_FULL_MATCH_INVALID' | 'BUILDER_FUNCTION' | 'BUILDER_METHOD' | 'BUILDER_PATH_DUPLICATE' | 'BUILDER_PATH_EMPTY' | 'BUILDER_POLICY' | 'BUILDER_POLICY_COMPOSITION' | 'BUILDER_POLICY_CYCLE' | 'BUILDER_POLICY_EMPTY_COMPOSITION' | 'BUILDER_POLICY_EMPTY_EXISTS' | 'BUILDER_POLICY_INPUT' | 'BUILDER_POLICY_REF' | 'BUILDER_POLICY_SELF' | 'BUILDER_PROPERTY_IMMUTABLE_INVALID' | 'BUILDER_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | 'BUILDER_UNKNOWN_FIELD' | 'BUILDER_UNOWNED_REFERENCE' | 'BUILDER_VIEW' | 'ZOD_SCHEMA_NOT_LOSSLESS';
 export interface BuilderDiagnostic<out Code extends BuilderDiagnosticCode = BuilderDiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;

package/dist/v1/builder/schema/handle.d.ts

@@ -1,7 +1,8 @@
 export declare const AUTHORING: unique symbol;
-export type AuthoringKind = 'definition' | 'function' | 'method' | 'callable-output' | 'policy' | 'view' | 'core-node' | 'core-edge' | 'property' | 'auto';
+type AuthoringKind = 'definition' | 'function' | 'method' | 'callable-input' | 'callable-output' | 'policy' | 'view' | 'core-node' | 'core-edge' | 'property' | 'auto';
 export interface AuthoringValue<Kind extends AuthoringKind> {
     readonly [AUTHORING]: Kind;
 }
 export declare function authoringValue<Kind extends AuthoringKind, Value extends object>(kind: Kind, value: Value): Readonly<Value & AuthoringValue<Kind>>;
 export declare function isAuthoringValue<Kind extends AuthoringKind>(value: unknown, kind: Kind): value is AuthoringValue<Kind> & object;
+export {};

package/dist/v1/builder/schema/input.d.ts

@@ -6,10 +6,18 @@ import type { Policy } from '../policy/authoring.js';
 import type { View } from '../view/authoring.js';
 /** Complete authoring input accepted by defineSchema. */
 export interface DomainSchemaInput {
-    readonly dependencies?: Readonly<Record<string, DomainSchema<string, unknown>>>;
+    /** Display name of the Domain, one trimmed line of 1 to 100 characters. */
+    readonly name: string;
+    /** Name of the one declared View this Domain opens by default. */
+    readonly entrypoint?: string;
+    readonly dependencies?: Readonly<Record<string, DomainSchema<string>>>;
     readonly classes?: Readonly<Record<string, Class>>;
     readonly functions?: Readonly<Record<string, Function>>;
     readonly policies?: Readonly<Record<string, Policy>>;
     readonly views?: Readonly<Record<string, View>>;
     readonly core?: CoreInput;
 }
+/** An entrypoint can only name one of the Views the same input declares. */
+export type EntrypointOf<Input extends DomainSchemaInput> = Input extends {
+    readonly views: infer Views;
+} ? Extract<keyof Views, string> : never;