@astrale-os/kernel-dsl 0.2.0-beta.3 → 0.2.0-beta.30

package/dist/v1/builder/{compiler → lowering}/view.js

@@ -1,27 +1,27 @@
-import { compareSchemaRefs } from '../../schema/reference.js';
+import { compareDefinitionRefs } from '../../addressing/ordering.js';
+import { viewAuthoringInput } from '../view/authoring.js';
 export class V1ViewCompiler {
     context;
     constructor(context) {
         this.context = context;
     }
-    compile(value, pointer) {
-        const config = value.config;
+    compile(value, name, pointer) {
+        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.resolveNodeDefinition(entry, `${pointer}/target/definitions/${index}`))
-                        .sort(compareSchemaRefs),
+                        .map((entry, index) => this.context.resolveNodeClass(entry, `${pointer}/target/definitions/${index}`))
+                        .sort(compareDefinitionRefs),
                 },
-            auth: config.auth ?? 'required',
         };
     }
 }
 function isTargetList(input) {
     return Array.isArray(input);
 }
-//# sourceMappingURL=view.js.map

package/dist/v1/builder/{policy.d.ts → policy/authoring.d.ts}

@@ -1,20 +1,29 @@
-import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm } from '../schema/policy/ast.js';
-import type { ClassRef } from '../schema/reference.js';
-import type { EdgeClassAuthoring, NodeClassAuthoring } from './definition.js';
-import type { Lazy } from './internal/authoring.lazy.js';
+import type { ClassRef } from '../../addressing/index.js';
+import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm, PolicyObjectRef } from '../../language/policy/model/policy.js';
+import type { PolicyObjectInput } from '../callable/authoring.js';
+import type { EdgeClass, NodeClass } 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<EdgeClassAuthoring>;
+    readonly class: Lazy<EdgeClass>;
     readonly target: CanonicalPolicyPatternTerm;
     readonly repeat?: {
         readonly min: number;
         readonly max: number;
     };
 }
+export interface PolicyNodeBinder {
+    (): CanonicalPolicyPatternTerm;
+    (definition: Lazy<NodeClass>): CanonicalPolicyPatternTerm;
+    readonly exact: (definition: Lazy<NodeClass>) => CanonicalPolicyPatternTerm;
+}
 export interface PolicyExistsContext {
-    node(definition: Lazy<NodeClassAuthoring>): CanonicalPolicyPatternTerm;
+    readonly node: PolicyNodeBinder;
 }
 export interface PolicyPatternContext {
+    ref(member: PolicyObjectInput): CanonicalPolicyPatternTerm;
+    sameNode(left: CanonicalPolicyPatternTerm, right: CanonicalPolicyPatternTerm): PolicyPatternExpression;
     readonly subject: CanonicalPolicyPatternTerm;
     readonly object: CanonicalPolicyPatternTerm;
     readonly source: CanonicalPolicyPatternTerm;
@@ -28,23 +37,25 @@ export interface MatchPolicyInput {
     readonly description?: string;
     readonly match: (context: PolicyPatternContext) => PolicyPatternExpression;
 }
-export interface PolicyComposition {
+interface PolicyComposition {
     readonly operator: 'allOf' | 'anyOf';
     readonly policies: readonly [PolicyInput, ...PolicyInput[]];
 }
-export interface Policy {
-    readonly input: MatchPolicyInput | PolicyComposition;
+export interface Policy extends AuthoringValue<'policy'> {
 }
 export type PolicyInput = Lazy<Policy>;
-export declare function definePolicy(input: MatchPolicyInput | PolicyComposition): Policy;
-export declare const policy: {
-    readonly allOf: (first: PolicyInput, ...rest: readonly PolicyInput[]) => PolicyComposition;
-    readonly anyOf: (first: PolicyInput, ...rest: readonly PolicyInput[]) => PolicyComposition;
-};
+type PolicyDeclaration = MatchPolicyInput | PolicyComposition;
+export interface PolicyBuilder {
+    (input: MatchPolicyInput): Policy;
+    readonly allOf: (first: PolicyInput, ...rest: readonly PolicyInput[]) => Policy;
+    readonly anyOf: (first: PolicyInput, ...rest: readonly PolicyInput[]) => Policy;
+}
+export declare function policyDeclaration(value: Policy): PolicyDeclaration;
+export declare const policy: PolicyBuilder;
 export declare function createPatternContext(options: {
-    readonly resolveEdgeClass: (value: Lazy<EdgeClassAuthoring>, pointer: string) => ClassRef;
-    readonly resolveNodeClass: (value: Lazy<NodeClassAuthoring>, pointer: string) => ClassRef;
+    readonly resolveObject: (value: PolicyObjectInput, pointer: string) => PolicyObjectRef;
+    readonly resolveEdgeClass: (value: Lazy<EdgeClass>, pointer: string) => ClassRef;
+    readonly resolveNodeClass: (value: Lazy<NodeClass>, pointer: string) => ClassRef;
     readonly pointer: string;
 }): PolicyPatternContext;
 export type { PolicyCheckExpression };
-//# sourceMappingURL=policy.d.ts.map

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

@@ -0,0 +1,115 @@
+import { assertKnownKeys, fail } from '../schema/diagnostic.js';
+import { authoringValue } from '../schema/handle.js';
+const declarations = new WeakMap();
+const compositions = new WeakSet();
+export function policyDeclaration(value) {
+    const declaration = declarations.get(value);
+    if (declaration === undefined)
+        fail('BUILDER_POLICY', '/', 'Policies are created by policy(...).');
+    return declaration;
+}
+function createPolicy(input) {
+    if ('operator' in input) {
+        if (!compositions.has(input)) {
+            fail('BUILDER_POLICY_COMPOSITION', '/', 'Policy compositions are created by policy.allOf(...) or policy.anyOf(...).');
+        }
+    }
+    else {
+        assertKnownKeys(input, ['description', 'match']);
+    }
+    const value = authoringValue('policy', {});
+    declarations.set(value, input);
+    return value;
+}
+export const policy = Object.freeze(Object.assign(createPolicy, {
+    allOf: (first, ...rest) => createPolicy(composition('allOf', first === undefined ? [] : [first, ...rest])),
+    anyOf: (first, ...rest) => createPolicy(composition('anyOf', first === undefined ? [] : [first, ...rest])),
+}));
+export function createPatternContext(options) {
+    let nextVariable = 0;
+    const subject = Object.freeze({ kind: 'subject' });
+    const object = Object.freeze({ kind: 'object' });
+    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,
+        target,
+        edge(input) {
+            assertKnownKeys(input, ['source', 'class', 'target', 'repeat']);
+            if (input.repeat !== undefined)
+                assertKnownKeys(input.repeat, ['min', 'max']);
+            return {
+                source: input.source,
+                class: options.resolveEdgeClass(input.class, `${options.pointer}/match/class`),
+                target: input.target,
+                ...(input.repeat === undefined ? {} : { repeat: { ...input.repeat } }),
+            };
+        },
+        exists(build) {
+            const nodes = [];
+            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.');
+            }
+            return { exists: { nodes, where } };
+        },
+        allOf(...expressions) {
+            nonEmpty(expressions, `${options.pointer}/match/allOf`);
+            return { allOf: expressions };
+        },
+        anyOf(...expressions) {
+            nonEmpty(expressions, `${options.pointer}/match/anyOf`);
+            return { anyOf: expressions };
+        },
+    };
+    return Object.freeze(context);
+}
+function composition(operator, policies) {
+    nonEmpty(policies, `/${operator}`);
+    const value = {
+        operator,
+        policies: [...policies],
+    };
+    compositions.add(value);
+    return value;
+}
+function nonEmpty(values, pointer) {
+    if (values.length === 0)
+        fail('BUILDER_POLICY_EMPTY_COMPOSITION', pointer, 'Policy composition must be non-empty.');
+}

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

@@ -0,0 +1,11 @@
+import type { Domain } from '../../domain/model/domain.js';
+import type { DomainSchema } from '../../schema/model/schema.js';
+import type { DomainSchemaInput } 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, 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, ResolvedDomainOfInput<Origin, Input>>;
+export type { ResolvedDomainOfInput } from './projection.js';

package/dist/v1/builder/{schema.js → schema/define.js}

@@ -1,6 +1,5 @@
-import { compileSchema } from './compiler/schema.js';
+import { compileSchema } from '../lowering/schema/compile.js';
 /** Build and semantically accept one immutable V1 DomainSchema. */
 export function defineSchema(origin, input) {
     return compileSchema(origin, input);
 }
-//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,16 @@
+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 interface BuilderDiagnostic<out Code extends BuilderDiagnosticCode = BuilderDiagnosticCode> {
+    readonly code: Code;
+    readonly pointer: string;
+    readonly message: string;
+    readonly ref?: string;
+}
+export declare function diagnostic<const Code extends BuilderDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): BuilderDiagnostic<Code>;
+export declare class BuilderError extends Error {
+    readonly diagnostics: readonly BuilderDiagnostic[];
+    constructor(diagnostics: readonly BuilderDiagnostic[]);
+}
+export declare function assertKnownKeys(value: object, allowed: readonly string[], pointer?: string): void;
+export declare function fail(code: BuilderDiagnosticCode, pointer: string, message: string): never;
+export declare function escapeToken(value: string): string;

package/dist/v1/builder/schema/diagnostic.js

@@ -0,0 +1,31 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+export function diagnostic(code, pointer, message, ref) {
+    return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
+}
+export class BuilderError extends Error {
+    diagnostics;
+    constructor(diagnostics) {
+        const ordered = [...diagnostics].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
+            compareUnicode(left.code, right.code) ||
+            compareUnicode(left.message, right.message));
+        super(ordered
+            .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
+            .join('\n'));
+        this.name = 'BuilderError';
+        this.diagnostics = Object.freeze(ordered);
+    }
+}
+export function assertKnownKeys(value, allowed, pointer = '') {
+    const accepted = new Set(allowed);
+    for (const key of Object.keys(value)) {
+        if (!accepted.has(key)) {
+            fail('BUILDER_UNKNOWN_FIELD', `${pointer}/${escapeToken(key)}`, `Unknown builder field ${key}.`);
+        }
+    }
+}
+export function fail(code, pointer, message) {
+    throw new BuilderError([diagnostic(code, pointer, message)]);
+}
+export function escapeToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

package/dist/v1/builder/{internal/authoring.d.ts → schema/handle.d.ts}

@@ -1,8 +1,7 @@
 export declare const AUTHORING: unique symbol;
-export type AuthoringKind = 'definition' | 'function' | 'callable-output' | 'policy' | 'view' | 'core-node' | 'core-edge' | 'property' | 'auto' | 'policy-composition';
+export type AuthoringKind = 'definition' | 'function' | 'method' | '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;
-//# sourceMappingURL=authoring.d.ts.map

package/dist/v1/builder/{internal/authoring.js → schema/handle.js}

@@ -12,4 +12,3 @@ export function isAuthoringValue(value, kind) {
         value !== null &&
         value[AUTHORING] === kind);
 }
-//# sourceMappingURL=authoring.js.map

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

@@ -0,0 +1,15 @@
+import type { DomainSchema } from '../../schema/model/schema.js';
+import type { Function } from '../callable/authoring.js';
+import type { Class } from '../class/authoring.js';
+import type { CoreInput } from '../core/authoring.js';
+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>>>;
+    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;
+}

package/dist/v1/builder/schema/input.js

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

package/dist/v1/builder/{internal/authoring.lazy.d.ts → schema/lazy.d.ts}

@@ -1,3 +1,2 @@
 export type Lazy<T> = T | (() => T);
 export declare function resolveLazy<T>(value: Lazy<T>, pointer: string): T;
-//# sourceMappingURL=authoring.lazy.d.ts.map

package/dist/v1/builder/{internal/authoring.lazy.js → schema/lazy.js}

@@ -11,4 +11,3 @@ export function resolveLazy(value, pointer) {
     }
     return current;
 }
-//# sourceMappingURL=authoring.lazy.js.map