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

package/dist/v1/language/class/resolved.d.ts

@@ -0,0 +1,126 @@
+import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
+import type { ClassRef, DefinitionKey, Key, PropertyKey } from '../../addressing/index.js';
+import type { ResolvedMethodCollection } from '../callable/resolved.js';
+import type { StateTopology } from '../state/index.js';
+import type { Diagnostic } from '../validation/diagnostic.js';
+import type { OrderingKind } from '../value/ordering.js';
+import type { ClassDefinition, ClassKind } from './model/class.js';
+import type { DataDefinition } from './model/data.js';
+import type { PropertyDefinition } from './model/property.js';
+import type { PropertyValues } from './property-values.js';
+export interface ResolvedProperty<out Value = PortableValue, out Required extends boolean = boolean, out State extends StateTopology | undefined = StateTopology | undefined, out Input = Value> {
+    readonly owner: AnyResolvedClass;
+    readonly name: string;
+    readonly key: PropertyKey;
+    readonly definition: Omit<PropertyDefinition, 'required' | 'state'> & {
+        readonly required: Required;
+        readonly state?: State;
+    };
+    /** The one portable scalar ordering domain, when the Property is orderable. */
+    readonly ordering?: OrderingKind;
+    validate(input: unknown): readonly Diagnostic[];
+    readonly __value?: Value;
+    readonly __input?: Input;
+}
+export interface ResolvedData {
+    readonly owner: ResolvedClass<'node'>;
+    readonly definition: DataDefinition;
+}
+export type ResolvedPropertyCollection<ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<unknown>>> = Readonly<Record<PropertyKey, ResolvedProperty<unknown>>>, ByName extends Readonly<Record<string, ResolvedProperty<unknown>>> = Readonly<Record<never, never>>> = Readonly<ByName> & Iterable<ByKey[keyof ByKey]> & {
+    readonly byKey: ByKey;
+    get<Key extends keyof ByKey>(key: Key): ByKey[Key];
+    get(key: PropertyKey): ResolvedProperty | undefined;
+    from(input: PropertyInput<ByKey, ByName>): PropertyValues;
+};
+export interface ResolvedClass<Kind extends ClassKind = ClassKind, Properties extends ResolvedPropertyCollection = ResolvedPropertyCollection, InstanceMethods extends ResolvedMethodCollection = ResolvedMethodCollection, StaticMethods extends ResolvedMethodCollection = ResolvedMethodCollection, SelfProperties extends ResolvedPropertyCollection = ResolvedPropertyCollection, SelfInstanceMethods extends ResolvedMethodCollection = ResolvedMethodCollection, SelfStaticMethods extends ResolvedMethodCollection = ResolvedMethodCollection, Definition extends Extract<ClassDefinition, {
+    readonly kind: Kind;
+}> = Extract<ClassDefinition, {
+    readonly kind: Kind;
+}>, Parents extends readonly unknown[] = readonly unknown[]> {
+    readonly ref: ClassRef;
+    readonly key: DefinitionKey<string, 'class'>;
+    readonly kind: Kind;
+    readonly abstract: boolean;
+    readonly definition: Definition;
+    readonly extends: Parents & readonly ResolvedClass<Kind>[];
+    /** Local observation Policies; Class inheritance never contributes an attachment. */
+    readonly policies: Definition['policies'];
+    readonly data: Kind extends 'node' ? ResolvedData | undefined : undefined;
+    readonly properties: Properties;
+    readonly methods: Kind extends 'node' ? InstanceMethods : ResolvedMethodCollection<Record<never, never>>;
+    readonly static: {
+        readonly methods: Kind extends 'node' ? StaticMethods : ResolvedMethodCollection<Record<never, never>>;
+    };
+    readonly self: {
+        readonly data: Kind extends 'node' ? ResolvedData | undefined : undefined;
+        readonly properties: SelfProperties;
+        readonly methods: Kind extends 'node' ? SelfInstanceMethods : ResolvedMethodCollection<Record<never, never>>;
+        readonly static: {
+            readonly methods: Kind extends 'node' ? SelfStaticMethods : ResolvedMethodCollection<Record<never, never>>;
+        };
+    };
+    satisfies(selected: ResolvedClass<Kind>): boolean;
+    validateProperties(input: unknown): readonly Diagnostic[];
+}
+/** One resolved Class with an exact graph kind, used at heterogeneous Domain boundaries. */
+export type AnyResolvedClass = ResolvedClass<'node'> | ResolvedClass<'edge'>;
+/** Exact Class keys satisfied by one resolved Class, including transitive parents. */
+export type ClassSatisfactionKeysOf<Class> = ClassSatisfactionKeys<Class, never>;
+type ClassSatisfactionKeys<Class, Seen> = Class extends Seen ? never : (Class extends {
+    readonly key: infer ExactKey extends DefinitionKey<Key.Origin, 'class'>;
+} ? ExactKey : never) | (Class extends ResolvedClass<ClassKind, ResolvedPropertyCollection, ResolvedMethodCollection, ResolvedMethodCollection, ResolvedPropertyCollection, ResolvedMethodCollection, ResolvedMethodCollection, ClassDefinition, infer Parents> ? ClassSatisfactionKeys<Extract<Parents[number], ResolvedClass>, Seen | Class> : never);
+export type PropertyValueOf<Property> = Property extends ResolvedProperty<infer Value, boolean, StateTopology | undefined, unknown> ? Value : never;
+export type PropertiesOf<Class> = Class extends {
+    readonly properties: infer Properties extends ResolvedPropertyCollection;
+} ? Properties : ResolvedPropertyCollection<Record<never, never>>;
+export type PropertyValuesOf<Class> = PropertyValues & Readonly<{
+    [Key in keyof PropertyByKeyOf<Class>]?: PropertyValueOf<PropertyByKeyOf<Class>[Key]>;
+}>;
+export type PropertyInputOf<Class> = PropertyWriteInput<PropertyByKeyOf<Class>, PropertyByNameOf<Class>>;
+export type MethodsOf<Class> = Class extends {
+    readonly kind: 'node';
+    readonly methods: infer Methods extends ResolvedMethodCollection;
+} ? Methods : ResolvedMethodCollection<Record<never, never>>;
+export type StaticMethodsOf<Class> = Class extends {
+    readonly kind: 'node';
+    readonly static: {
+        readonly methods: infer Methods extends ResolvedMethodCollection;
+    };
+} ? Methods : ResolvedMethodCollection<Record<never, never>>;
+export type SelfPropertiesOf<Class> = Class extends {
+    readonly self: {
+        readonly properties: infer Properties extends ResolvedPropertyCollection;
+    };
+} ? Properties : ResolvedPropertyCollection<Record<never, never>>;
+export type SelfMethodsOf<Class> = Class extends {
+    readonly kind: 'node';
+    readonly self: {
+        readonly methods: infer Methods extends ResolvedMethodCollection;
+    };
+} ? Methods : ResolvedMethodCollection<Record<never, never>>;
+export type SelfStaticMethodsOf<Class> = Class extends {
+    readonly kind: 'node';
+    readonly self: {
+        readonly static: {
+            readonly methods: infer Methods extends ResolvedMethodCollection;
+        };
+    };
+} ? Methods : ResolvedMethodCollection<Record<never, never>>;
+type PropertyInput<ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<unknown>>>, ByName extends Readonly<Record<string, ResolvedProperty<unknown>>>> = Readonly<{
+    [Key in keyof ByKey]?: PropertyValueOf<ByKey[Key]>;
+} & {
+    [Name in keyof ByName]?: PropertyValueOf<ByName[Name]>;
+}>;
+type PropertyWriteInput<ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<unknown>>>, ByName extends Readonly<Record<string, ResolvedProperty<unknown>>>> = Readonly<{
+    [Key in keyof ByKey]?: PropertyWriteValueOf<ByKey[Key]>;
+} & {
+    [Name in keyof ByName]?: PropertyWriteValueOf<ByName[Name]>;
+}>;
+type PropertyWriteValueOf<Property> = Property extends ResolvedProperty<unknown, boolean, StateTopology | undefined, infer Input> ? Input : never;
+type PropertyByKeyOf<Class> = PropertiesOf<Class> extends {
+    readonly byKey: infer ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<unknown>>>;
+} ? ByKey : Readonly<Record<never, never>>;
+type PropertyByNameOf<Class> = Readonly<{
+    [Name in Exclude<keyof PropertiesOf<Class>, keyof ResolvedPropertyCollection>]: Extract<PropertiesOf<Class>[Name], ResolvedProperty<unknown, boolean, StateTopology | undefined, unknown>>;
+}>;
+export {};

package/dist/v1/language/class/resolved.js

@@ -0,0 +1 @@
+export {};

package/dist/v1/language/core/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './model/core.js';
+export type * from './resolved.js';

package/dist/v1/language/core/index.js

@@ -0,0 +1 @@
+export {};

package/dist/v1/language/core/model/core.d.ts

@@ -0,0 +1,26 @@
+import type { ClassRef, CoreRef, DefinitionBase } from '../../../addressing/index.js';
+import type { PropertyValues } from '../../class/property-values.js';
+import type { PolicyObjectRef } from '../../policy/model/policy.js';
+export interface DomainEndpointRef {
+    readonly kind: 'domain';
+}
+/**
+ * One Core Edge endpoint: the owning Domain itself, or any local Definition whose installed
+ * projection resolves through an exact member Path. That is the same projected-member vocabulary
+ * a Policy object names, so both languages address one identity the same way.
+ */
+export type CoreEndpointRef = PolicyObjectRef | DomainEndpointRef;
+export interface CoreDefinition extends DefinitionBase<CoreRef> {
+    readonly class: ClassRef;
+    readonly properties: PropertyValues;
+}
+export interface CoreEdge {
+    readonly class: ClassRef;
+    readonly source: CoreEndpointRef;
+    readonly target: CoreEndpointRef;
+    readonly properties: PropertyValues;
+}
+export interface CoreContent {
+    readonly nodes: Readonly<Record<string, CoreDefinition>>;
+    readonly edges: readonly CoreEdge[];
+}

package/dist/v1/language/core/model/core.js

@@ -0,0 +1 @@
+export {};

package/dist/v1/language/core/resolved.d.ts

@@ -0,0 +1,25 @@
+import type { DefinitionKey } from '../../addressing/index.js';
+import type { ResolvedMethod } from '../callable/resolved.js';
+import type { PropertyValues } from '../class/property-values.js';
+import type { ResolvedClass } from '../class/resolved.js';
+import type { ResolvedDefinition } from '../resolved.js';
+import type { CoreDefinition } from './model/core.js';
+export interface ResolvedCoreDefinition {
+    readonly ref: CoreDefinition['ref'];
+    readonly key: DefinitionKey<string, 'core'>;
+    readonly class: ResolvedClass<'node'>;
+    readonly properties: PropertyValues;
+    readonly definition: CoreDefinition;
+}
+export interface ResolvedDomainEndpoint {
+    readonly kind: 'domain';
+    readonly origin: string;
+}
+/** The owning Domain, one local Definition, or one local Class-owned Method. */
+export type ResolvedCoreEndpoint = ResolvedDefinition | ResolvedMethod | ResolvedDomainEndpoint;
+export interface ResolvedCoreEdge {
+    readonly class: ResolvedClass<'edge'>;
+    readonly source: ResolvedCoreEndpoint;
+    readonly target: ResolvedCoreEndpoint;
+    readonly properties: PropertyValues;
+}

package/dist/v1/language/core/resolved.js

@@ -0,0 +1 @@
+export {};

package/dist/v1/language/definition/metadata.d.ts

@@ -0,0 +1,12 @@
+/** Exact V1 bound for optional human-facing declaration descriptions. */
+export declare const description: Readonly<{
+    readonly type: 'string';
+    readonly minLength: 1;
+    readonly maxLength: 1000;
+}>;
+/** Exact V1 bound for optional Node Class presentation icons. */
+export declare const icon: Readonly<{
+    readonly type: 'string';
+    readonly minLength: 1;
+    readonly maxLength: 8000;
+}>;

package/dist/v1/language/definition/metadata.js

@@ -0,0 +1,12 @@
+/** Exact V1 bound for optional human-facing declaration descriptions. */
+export const description = Object.freeze({
+    type: 'string',
+    minLength: 1,
+    maxLength: 1000,
+});
+/** Exact V1 bound for optional Node Class presentation icons. */
+export const icon = Object.freeze({
+    type: 'string',
+    minLength: 1,
+    maxLength: 8000,
+});

package/dist/v1/language/definition.d.ts

@@ -0,0 +1,7 @@
+import type { FunctionDefinition } from './callable/model/callable.js';
+import type { ClassDefinition } from './class/model/class.js';
+import type { CoreDefinition } from './core/model/core.js';
+import type { PolicyDefinition } from './policy/model/policy.js';
+import type { ViewDefinition } from './view/model/view.js';
+/** Every named V1 product Definition. Property and Method remain Class-owned members. */
+export type Definition = ClassDefinition | FunctionDefinition | PolicyDefinition | ViewDefinition | CoreDefinition;

package/dist/v1/language/definition.js

@@ -0,0 +1 @@
+export {};

package/dist/v1/language/index.d.ts

@@ -0,0 +1,28 @@
+export { isMethodExecutable } from './callable/executable.js';
+export { isBinaryInput } from './callable/model/callable.js';
+export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodKey, PolicyRef, PropertyKey, ViewRef, } from '../addressing/index.js';
+export type { Value as PropertyValue } from '@astrale-os/kernel-dsl/value';
+export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject, } from './value/model/schema.js';
+export type { OrderingKind } from './value/ordering.js';
+export { stateMachine } from './state/index.js';
+export type { EventOf, StateMachine, StateOf, StateTopology } from './state/index.js';
+export type * from './callable/model/callable.js';
+export type * from './callable/resolved.js';
+export type * from './class/model/class.js';
+export type { DataDefinition, DataFacet, MediaType } from './class/model/data.js';
+export type * from './class/model/edge.js';
+export type * from './class/model/property.js';
+export type * from './class/resolved.js';
+export type * from './class/facets.js';
+export { PropertyValues } from './class/property-values.js';
+export type { PropertyValuesOperations } from './class/property-values.js';
+export type * from './core/model/core.js';
+export type * from './core/resolved.js';
+export type { Definition } from './definition.js';
+export type { ResolvedDefinition, ResolvedDefinitionOf } from './resolved.js';
+export type { Diagnostic, DiagnosticCode } from './validation/diagnostic.js';
+export type * from './policy/model/policy.js';
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './policy/model/policy.js';
+export type * from './policy/resolved.js';
+export type * from './view/model/view.js';
+export type * from './view/resolved.js';

package/dist/v1/language/index.js

@@ -0,0 +1,5 @@
+export { isMethodExecutable } from './callable/executable.js';
+export { isBinaryInput } from './callable/model/callable.js';
+export { stateMachine } from './state/index.js';
+export { PropertyValues } from './class/property-values.js';
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './policy/model/policy.js';

package/dist/v1/language/policy/analysis/branches.d.ts

@@ -0,0 +1,20 @@
+import type { PolicyEdgePattern, PolicyPatternExpression, PolicyPatternTerm, PolicyVariableSelector } from '../model/policy.js';
+export interface PatternBranch {
+    readonly terms: ReadonlyMap<string, PolicyPatternTerm>;
+    readonly equalities: readonly (readonly [string, string])[];
+    readonly edges: readonly PatternEdgeUse[];
+    readonly variables: ReadonlyMap<string, PolicyVariableSelector>;
+    readonly requiredVariables: ReadonlySet<string>;
+    readonly namespace: string;
+}
+export interface PatternEdgeUse {
+    readonly pattern: PolicyEdgePattern;
+    readonly namespace: string;
+}
+export type PolicyTargetMode = 'object' | 'edge';
+export declare function branchesOf(pattern: PolicyPatternExpression, namespace: string): readonly PatternBranch[];
+export declare function branchProduct(children: readonly (readonly PatternBranch[])[]): readonly PatternBranch[];
+export declare function capBranches(values: readonly PatternBranch[]): readonly PatternBranch[];
+export declare function isConnected(branch: PatternBranch): boolean;
+export declare function targetMode(branch: PatternBranch): PolicyTargetMode | undefined;
+export declare function termKey(term: PolicyPatternTerm, namespace: string): string;

package/dist/v1/language/policy/analysis/branches.js

@@ -0,0 +1,174 @@
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { policyObjectKey, policyVariableSelector } from '../model/policy.js';
+import { BRANCH_OVERFLOW } from './budgets.js';
+export function branchesOf(pattern, namespace) {
+    const variables = collectVariableClasses(pattern, namespace);
+    return branchesForNode(pattern, namespace, variables);
+}
+export function branchProduct(children) {
+    let result = [emptyBranch()];
+    for (const child of children) {
+        const next = [];
+        for (const left of result) {
+            for (const right of child) {
+                next.push(mergeBranches(left, right));
+                if (next.length >= BRANCH_OVERFLOW)
+                    return next;
+            }
+        }
+        result = next;
+    }
+    return result;
+}
+export function capBranches(values) {
+    return values.length <= BRANCH_OVERFLOW ? values : values.slice(0, BRANCH_OVERFLOW);
+}
+export function isConnected(branch) {
+    const mode = targetMode(branch);
+    if (mode === undefined)
+        return false;
+    const vertices = new Set(['subject', ...branch.terms.keys()]);
+    for (const variable of branch.requiredVariables)
+        vertices.add(variable);
+    const union = new UnionFind(vertices);
+    for (const edge of branch.edges) {
+        const source = termKey(edge.pattern.source, edge.namespace);
+        const target = termKey(edge.pattern.target, edge.namespace);
+        union.add(source);
+        union.add(target);
+        union.join(source, target);
+    }
+    for (const [left, right] of branch.equalities)
+        union.join(left, right);
+    const root = union.find('subject');
+    return [...vertices].every((vertex) => union.find(vertex) === root);
+}
+export function targetMode(branch) {
+    let object = false;
+    let source = false;
+    let target = false;
+    for (const term of branch.terms.values()) {
+        object ||= term.kind === 'object';
+        source ||= term.kind === 'source';
+        target ||= term.kind === 'target';
+    }
+    if (object && !source && !target)
+        return 'object';
+    if (!object && (source || target))
+        return 'edge';
+    return undefined;
+}
+export function termKey(term, namespace) {
+    return term.kind === 'variable'
+        ? variableKey(namespace, term.id)
+        : term.kind === 'ref'
+            ? `ref:${term.ref.kind === 'method' ? policyObjectKey(term.ref) : definitionRefIndex(term.ref)}`
+            : term.kind;
+}
+function branchesForNode(pattern, namespace, variables) {
+    if ('source' in pattern) {
+        return [
+            {
+                terms: new Map([pattern.source, pattern.target].map((term) => [termKey(term, namespace), term])),
+                equalities: [],
+                edges: [{ pattern, namespace }],
+                variables,
+                requiredVariables: new Set(),
+                namespace,
+            },
+        ];
+    }
+    if ('sameNode' in pattern) {
+        const terms = new Map([pattern.sameNode.left, pattern.sameNode.right].map((term) => [
+            termKey(term, namespace),
+            term,
+        ]));
+        return [
+            {
+                terms,
+                equalities: [
+                    [termKey(pattern.sameNode.left, namespace), termKey(pattern.sameNode.right, namespace)],
+                ],
+                edges: [],
+                variables,
+                requiredVariables: new Set(),
+                namespace,
+            },
+        ];
+    }
+    if ('exists' in pattern) {
+        const direct = new Set(pattern.exists.nodes.map((node) => variableKey(namespace, node.variable.id)));
+        return branchesForNode(pattern.exists.where, namespace, variables).map((branch) => ({
+            ...branch,
+            requiredVariables: new Set([...branch.requiredVariables, ...direct]),
+        }));
+    }
+    const children = ('allOf' in pattern ? pattern.allOf : pattern.anyOf).map((child) => branchesForNode(child, namespace, variables));
+    return 'allOf' in pattern ? branchProduct(children) : capBranches(children.flat());
+}
+function emptyBranch() {
+    return {
+        terms: new Map(),
+        equalities: [],
+        edges: [],
+        variables: new Map(),
+        requiredVariables: new Set(),
+        namespace: '$',
+    };
+}
+function mergeBranches(left, right) {
+    return {
+        terms: new Map([...left.terms, ...right.terms]),
+        equalities: [...left.equalities, ...right.equalities],
+        edges: [...left.edges, ...right.edges],
+        variables: new Map([...left.variables, ...right.variables]),
+        requiredVariables: new Set([...left.requiredVariables, ...right.requiredVariables]),
+        namespace: `${left.namespace}&${right.namespace}`,
+    };
+}
+function collectVariableClasses(pattern, namespace) {
+    const result = new Map();
+    const visit = (node) => {
+        if ('exists' in node) {
+            for (const variable of node.exists.nodes) {
+                result.set(variableKey(namespace, variable.variable.id), policyVariableSelector(variable));
+            }
+            visit(node.exists.where);
+        }
+        else if ('allOf' in node)
+            node.allOf.forEach(visit);
+        else if ('anyOf' in node)
+            node.anyOf.forEach(visit);
+    };
+    visit(pattern);
+    return result;
+}
+function variableKey(namespace, id) {
+    return `variable:${namespace}:${id}`;
+}
+class UnionFind {
+    #parents = new Map();
+    constructor(values) {
+        for (const value of values)
+            this.add(value);
+    }
+    add(value) {
+        if (!this.#parents.has(value))
+            this.#parents.set(value, value);
+    }
+    find(value) {
+        this.add(value);
+        const parent = this.#parents.get(value);
+        if (parent === value)
+            return value;
+        const root = this.find(parent);
+        this.#parents.set(value, root);
+        return root;
+    }
+    join(left, right) {
+        const a = this.find(left);
+        const b = this.find(right);
+        if (a !== b)
+            this.#parents.set(b, a);
+    }
+}

package/dist/v1/language/policy/analysis/budgets.d.ts

@@ -0,0 +1,16 @@
+import type { PolicyCheckExpression } from '../model/policy.js';
+export declare const MAX_PATTERN_DEPTH = 4;
+export declare const MAX_BRANCHES = 8;
+export declare const MAX_VARIABLES = 4;
+export declare const MAX_EDGES = 6;
+export declare const MAX_REPEAT = 3;
+export declare const MAX_DOMAINS = 4;
+export declare const MAX_CHECK_DEPTH = 4;
+export declare const MAX_CHECK_LEAVES = 8;
+export declare const BRANCH_OVERFLOW: number;
+export interface CheckMeasure {
+    readonly depth: number;
+    readonly branches: number;
+    readonly leaves: number;
+}
+export declare function measureChecks(expression: PolicyCheckExpression): CheckMeasure;

package/dist/v1/language/policy/analysis/budgets.js

@@ -0,0 +1,25 @@
+export const MAX_PATTERN_DEPTH = 4;
+export const MAX_BRANCHES = 8;
+export const MAX_VARIABLES = 4;
+export const MAX_EDGES = 6;
+export const MAX_REPEAT = 3;
+export const MAX_DOMAINS = 4;
+export const MAX_CHECK_DEPTH = 4;
+export const MAX_CHECK_LEAVES = 8;
+export const BRANCH_OVERFLOW = MAX_BRANCHES + 1;
+export function measureChecks(expression) {
+    if ('check' in expression || 'sameNode' in expression)
+        return { depth: 1, branches: 1, leaves: 1 };
+    const children = ('allOf' in expression ? expression.allOf : expression.anyOf).map(measureChecks);
+    const branches = 'allOf' in expression
+        ? children.reduce((value, child) => saturatingProduct(value, child.branches), 1)
+        : children.reduce((value, child) => Math.min(BRANCH_OVERFLOW, value + child.branches), 0);
+    return {
+        depth: 1 + Math.max(0, ...children.map((child) => child.depth)),
+        branches,
+        leaves: children.reduce((value, child) => value + child.leaves, 0),
+    };
+}
+function saturatingProduct(left, right) {
+    return Math.min(BRANCH_OVERFLOW, left * right);
+}

package/dist/v1/language/policy/index.d.ts

@@ -0,0 +1,4 @@
+export type * from './model/policy.js';
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './model/policy.js';
+export type * from './resolved.js';
+export * from './normalization/normalize.js';

package/dist/v1/language/policy/index.js

@@ -0,0 +1,2 @@
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './model/policy.js';
+export * from './normalization/normalize.js';

package/dist/v1/language/policy/model/policy.d.ts

@@ -0,0 +1,116 @@
+import type { CoreRef, ClassRef, FunctionRef, PolicyRef, ViewRef, DefinitionBase, MethodAddress } from '../../../addressing/index.js';
+export type PolicyPatternTerm = {
+    readonly kind: 'subject';
+} | {
+    readonly kind: 'object';
+} | {
+    readonly kind: 'source';
+} | {
+    readonly kind: 'target';
+} | {
+    readonly kind: 'variable';
+    readonly id: number;
+} | {
+    readonly kind: 'ref';
+    readonly ref: PolicyObjectRef;
+};
+/** Identity equality; both terms must resolve to one valid Node. */
+export interface PolicySameNode<Term> {
+    readonly sameNode: {
+        readonly left: Term;
+        readonly right: Term;
+    };
+}
+export interface ExactPolicyVariable {
+    readonly variable: {
+        readonly kind: 'variable';
+        readonly id: number;
+    };
+    readonly class: ClassRef;
+}
+export interface SelectedPolicyVariable {
+    readonly variable: {
+        readonly kind: 'variable';
+        readonly id: number;
+    };
+    readonly selector: {
+        readonly kind: 'any';
+    } | {
+        readonly kind: 'satisfies';
+        readonly class: ClassRef;
+    };
+}
+/**
+ * An existential Node binding. The class-bearing legacy form is deliberately retained as the
+ * canonical exact selector so persisted V1 DomainSchema documents keep their original meaning.
+ */
+export type PolicyVariable = ExactPolicyVariable | SelectedPolicyVariable;
+export type PolicyVariableSelector = {
+    readonly kind: 'exact';
+    readonly class: ClassRef;
+} | SelectedPolicyVariable['selector'];
+/** Resolve the semantic selector while preserving the legacy exact wire representation. */
+export declare function policyVariableSelector(variable: PolicyVariable): PolicyVariableSelector;
+/** Return the selector's referenced Class, when it has one. */
+export declare function policyVariableClass(variable: PolicyVariable): ClassRef | undefined;
+export interface PolicyRepeat {
+    readonly min: number;
+    readonly max: number;
+}
+export interface PolicyEdgePattern {
+    readonly source: PolicyPatternTerm;
+    readonly class: ClassRef;
+    readonly target: PolicyPatternTerm;
+    readonly repeat?: PolicyRepeat;
+}
+export type PolicyPatternExpression = PolicyEdgePattern | PolicySameNode<PolicyPatternTerm> | {
+    readonly exists: {
+        readonly nodes: readonly PolicyVariable[];
+        readonly where: PolicyPatternExpression;
+    };
+} | {
+    readonly allOf: readonly PolicyPatternExpression[];
+} | {
+    readonly anyOf: readonly PolicyPatternExpression[];
+};
+export type PolicyExpression = {
+    readonly match: PolicyPatternExpression;
+} | {
+    readonly allOf: readonly PolicyRef[];
+} | {
+    readonly anyOf: readonly PolicyRef[];
+};
+export interface PolicyDefinition extends DefinitionBase<PolicyRef> {
+    readonly expression: PolicyExpression;
+    readonly description?: string;
+}
+/** Local Domain members whose installed projection resolves through one exact member Path. */
+export type PolicyObjectRef = ClassRef | FunctionRef | PolicyRef | ViewRef | CoreRef | MethodAddress;
+/** Exact projected identity, including Class-owned Method declarations. */
+export declare function policyObjectKey(ref: PolicyObjectRef): string;
+export declare function policyObjectOrigin(ref: PolicyObjectRef): string;
+export declare function projectedMemberClass(ref: Exclude<PolicyObjectRef, CoreRef>): ClassRef;
+export type PolicyCheckObject = {
+    readonly kind: 'self';
+} | {
+    readonly kind: 'input';
+    readonly field: string;
+} | {
+    readonly kind: 'ref';
+    readonly ref: PolicyObjectRef;
+};
+/** Versioned Policy-check grammar specialized by each lifecycle boundary. */
+export type PolicyCheckExpression<Policy = PolicyRef, Object = PolicyCheckObject> = {
+    readonly check: Policy;
+    readonly object: Object;
+} | PolicySameNode<Object> | {
+    readonly allOf: readonly [
+        PolicyCheckExpression<Policy, Object>,
+        ...PolicyCheckExpression<Policy, Object>[]
+    ];
+} | {
+    readonly anyOf: readonly [
+        PolicyCheckExpression<Policy, Object>,
+        ...PolicyCheckExpression<Policy, Object>[]
+    ];
+};