@astrale-os/kernel-dsl 0.2.0-beta.2 → 0.2.0-beta.20

package/dist/v1/addressing/method-key.js

@@ -0,0 +1,60 @@
+import { acceptDefinitionRef } from './definition-ref.js';
+import { Key } from './key.js';
+import { MEMBER_NAME_PATTERN } from './patterns.js';
+/** Admit exact canonical Method-key text. */
+export function MethodKey(input) {
+    if (!MethodKey.is(input)) {
+        throw new TypeError(`Invalid canonical MethodKey: ${JSON.stringify(input)}.`);
+    }
+    return input;
+}
+/** Construction, admission, and decomposition for canonical Class-owned Method keys. */
+(function (MethodKey) {
+    function of(owner, name) {
+        const admitted = acceptDefinitionRef(owner);
+        if (admitted.kind !== 'class' || !MEMBER_NAME_PATTERN.test(name)) {
+            throw new TypeError(`Invalid MethodKey address: ${JSON.stringify({ owner, name })}.`);
+        }
+        return Key(`${admitted.origin}:class.${admitted.name}.method.${name}`);
+    }
+    MethodKey.of = of;
+    function is(input) {
+        if (typeof input !== 'string' || !Key.is(input))
+            return false;
+        const coordinate = input.slice(input.indexOf(':') + 1);
+        return coordinate.startsWith('class.') && coordinate.includes('.method.');
+    }
+    MethodKey.is = is;
+    function address(input) {
+        const admitted = MethodKey(input);
+        const separator = admitted.indexOf(':');
+        const coordinate = admitted.slice(separator + ':class.'.length);
+        const member = coordinate.indexOf('.method.');
+        return Object.freeze({
+            kind: 'method',
+            owner: acceptDefinitionRef({
+                origin: admitted.slice(0, separator),
+                kind: 'class',
+                name: coordinate.slice(0, member),
+            }),
+            name: coordinate.slice(member + '.method.'.length),
+        });
+    }
+    MethodKey.address = address;
+})(MethodKey || (MethodKey = {}));
+/** Decompose one admitted callable key into its semantic Function or Method address. */
+export function callableAddress(input) {
+    if (MethodKey.is(input))
+        return MethodKey.address(input);
+    const admitted = Key(input);
+    const separator = admitted.indexOf(':');
+    const coordinate = admitted.slice(separator + 1);
+    if (!coordinate.startsWith('function.')) {
+        throw new TypeError(`Invalid callable Key: ${JSON.stringify(input)}.`);
+    }
+    return acceptDefinitionRef({
+        origin: admitted.slice(0, separator),
+        kind: 'function',
+        name: coordinate.slice('function.'.length),
+    });
+}

package/dist/v1/addressing/ordering.d.ts

@@ -0,0 +1,6 @@
+import type { DefinitionRef } from './definition-ref.js';
+/** Internal exact-kind index for deterministic semantic tables. */
+export declare function definitionRefIndex(ref: DefinitionRef): string;
+export declare function compareDefinitionRefs(left: DefinitionRef, right: DefinitionRef): number;
+/** Locale-independent Unicode code-point ordering for canonical DSL values. */
+export declare function compareUnicode(left: string, right: string): number;

package/dist/v1/addressing/ordering.js

@@ -0,0 +1,20 @@
+/** Internal exact-kind index for deterministic semantic tables. */
+export function definitionRefIndex(ref) {
+    return `${ref.origin}\u0000${ref.kind}\u0000${ref.name}`;
+}
+export function compareDefinitionRefs(left, right) {
+    return (compareUnicode(left.origin, right.origin) ||
+        compareUnicode(left.kind, right.kind) ||
+        compareUnicode(left.name, right.name));
+}
+/** Locale-independent Unicode code-point ordering for canonical DSL values. */
+export function compareUnicode(left, right) {
+    const a = Array.from(left, (value) => value.codePointAt(0) ?? 0);
+    const b = Array.from(right, (value) => value.codePointAt(0) ?? 0);
+    const length = Math.min(a.length, b.length);
+    for (let index = 0; index < length; index += 1) {
+        if (a[index] !== b[index])
+            return (a[index] ?? 0) - (b[index] ?? 0);
+    }
+    return a.length - b.length;
+}

package/dist/v1/addressing/patterns.d.ts

@@ -2,17 +2,26 @@
 export type DomainOrigin = string;
 export declare const DOMAIN_ORIGIN_PATTERN: RegExp;
 export declare const MEMBER_NAME_PATTERN: RegExp;
+export declare const DEPENDENCY_ALIAS_PATTERN: RegExp;
 export declare const CORE_SLUG_PATTERN: RegExp;
 export declare const DOMAIN_REVISION_PATTERN: RegExp;
-export declare const PROPERTY_KEY_FULL_MATCH = "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:(class|interface)\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*";
+export declare const DOMAIN_REVISION_FULL_MATCH = "sha256:[0-9a-f]{64}";
+export declare const DOMAIN_ORIGIN_FULL_MATCH = "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?";
+export declare const MEMBER_NAME_FULL_MATCH = "[A-Za-z][A-Za-z0-9_]*";
+export declare const DEPENDENCY_ALIAS_FULL_MATCH = "[a-z][A-Za-z0-9]*";
+export declare const PROPERTY_KEY_FULL_MATCH = "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:class\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*";
 export declare const PROPERTY_KEY_PATTERN: RegExp;
 export declare const patterns: Readonly<{
     coreSlug: RegExp;
+    dependencyAlias: RegExp;
+    dependencyAliasFullMatch: "[a-z][A-Za-z0-9]*";
     memberName: RegExp;
+    memberNameFullMatch: "[A-Za-z][A-Za-z0-9_]*";
     origin: RegExp;
+    originFullMatch: "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?";
     propertyKey: RegExp;
-    propertyKeyFullMatch: "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:(class|interface)\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*";
+    propertyKeyFullMatch: "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:class\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*";
     revision: RegExp;
+    revisionFullMatch: "sha256:[0-9a-f]{64}";
 }>;
 export declare function assertMemberName(name: string): void;
-//# sourceMappingURL=patterns.d.ts.map

package/dist/v1/addressing/patterns.js

@@ -1,20 +1,29 @@
 export const DOMAIN_ORIGIN_PATTERN = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u;
 export const MEMBER_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/u;
+export const DEPENDENCY_ALIAS_PATTERN = /^[a-z][A-Za-z0-9]*$/u;
 export const CORE_SLUG_PATTERN = /^[a-z][a-z0-9-]{0,99}$/u;
 export const DOMAIN_REVISION_PATTERN = /^sha256:[0-9a-f]{64}$/u;
-export const PROPERTY_KEY_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:(class|interface)\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*';
+export const DOMAIN_REVISION_FULL_MATCH = 'sha256:[0-9a-f]{64}';
+export const DOMAIN_ORIGIN_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?';
+export const MEMBER_NAME_FULL_MATCH = '[A-Za-z][A-Za-z0-9_]*';
+export const DEPENDENCY_ALIAS_FULL_MATCH = '[a-z][A-Za-z0-9]*';
+export const PROPERTY_KEY_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:class\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*';
 export const PROPERTY_KEY_PATTERN = new RegExp(`^(?:${PROPERTY_KEY_FULL_MATCH})$`, 'u');
 export const patterns = Object.freeze({
     coreSlug: CORE_SLUG_PATTERN,
+    dependencyAlias: DEPENDENCY_ALIAS_PATTERN,
+    dependencyAliasFullMatch: DEPENDENCY_ALIAS_FULL_MATCH,
     memberName: MEMBER_NAME_PATTERN,
+    memberNameFullMatch: MEMBER_NAME_FULL_MATCH,
     origin: DOMAIN_ORIGIN_PATTERN,
+    originFullMatch: DOMAIN_ORIGIN_FULL_MATCH,
     propertyKey: PROPERTY_KEY_PATTERN,
     propertyKeyFullMatch: PROPERTY_KEY_FULL_MATCH,
     revision: DOMAIN_REVISION_PATTERN,
+    revisionFullMatch: DOMAIN_REVISION_FULL_MATCH,
 });
 export function assertMemberName(name) {
     if (!MEMBER_NAME_PATTERN.test(name)) {
         throw new TypeError(`Invalid member name: ${JSON.stringify(name)}.`);
     }
 }
-//# sourceMappingURL=patterns.js.map

package/dist/v1/addressing/property-key.d.ts

@@ -1,18 +1,13 @@
-import type { SchemaRef } from './schema-ref.js';
-import { Key, type Key as SemanticKey } from './key.js';
-import { Ref } from './ref.js';
-export type PropertyKey<Origin extends Key.Origin = Key.Origin, Owner extends Ref.Class | Ref.Interface = Ref.Class | Ref.Interface, Name extends string = string> = SemanticKey<Origin, Ref.Property<Owner, Name>>;
-type CanonicalPropertyKey = PropertyKey;
-type SchemaDefinitionRef<Name extends string = string> = SchemaRef<'class', Name> | SchemaRef<'interface', Name>;
-export declare function PropertyKey<Origin extends Key.Origin = Key.Origin, Owner extends Ref.Class | Ref.Interface = Ref.Class | Ref.Interface, Name extends string = string>(input: string): PropertyKey<Origin, Owner, Name>;
-/** Construction and admission operations for canonical PropertyKeys. */
+import { type ClassRef } from './definition-ref.js';
+import { Key, type PropertyKey as CanonicalPropertyKey } from './key.js';
+export type PropertyKey<Origin extends Key.Origin = Key.Origin, Owner extends string = string, Name extends string = string> = CanonicalPropertyKey<Origin, Owner, Name>;
+export declare function PropertyKey<Origin extends Key.Origin = Key.Origin, Owner extends string = string, Name extends string = string>(input: string): PropertyKey<Origin, Owner, Name>;
+/** Construction and admission operations for canonical Class-owned Property keys. */
 export declare namespace PropertyKey {
-    function of<const Arguments extends readonly [owner: SchemaDefinitionRef, name: string] | readonly [origin: Key.Origin, owner: Ref.Class | Ref.Interface, name: string]>(...args: Arguments): Arguments extends readonly [owner: SchemaDefinitionRef, name: infer Name extends string] ? PropertyKey<Key.Origin, Ref.Class | Ref.Interface, Name> : Arguments extends readonly [
-        origin: infer Origin extends Key.Origin,
-        owner: infer Owner extends Ref.Class | Ref.Interface,
-        name: infer Name extends string
-    ] ? PropertyKey<Origin, Owner, Name> : never;
+    function of<const Owner extends ClassRef, const Name extends string>(owner: Owner, name: Name): PropertyKey<Owner['origin'], Owner['name'], Name>;
     function is(input: unknown): input is CanonicalPropertyKey;
+    function address(input: PropertyKey): {
+        readonly owner: ClassRef;
+        readonly name: string;
+    };
 }
-export {};
-//# sourceMappingURL=property-key.d.ts.map

package/dist/v1/addressing/property-key.js

@@ -1,30 +1,39 @@
+import { acceptDefinitionRef } from './definition-ref.js';
 import { Key } from './key.js';
-import { Ref } from './ref.js';
+import { MEMBER_NAME_PATTERN, PROPERTY_KEY_PATTERN } from './patterns.js';
 export function PropertyKey(input) {
     if (!PropertyKey.is(input)) {
         throw new TypeError(`Invalid canonical PropertyKey: ${JSON.stringify(input)}.`);
     }
     return input;
 }
-/** Construction and admission operations for canonical PropertyKeys. */
+/** Construction and admission operations for canonical Class-owned Property keys. */
 (function (PropertyKey) {
-    function of(...args) {
-        let result;
-        if (args.length === 3) {
-            const [origin, owner, name] = args;
-            result = Key.of(origin, Ref.property(owner, name));
+    function of(owner, name) {
+        const admitted = acceptDefinitionRef(owner);
+        if (admitted.kind !== 'class' || !MEMBER_NAME_PATTERN.test(name)) {
+            throw new TypeError(`Invalid PropertyKey coordinate: ${JSON.stringify({ owner, name })}.`);
         }
-        else {
-            const [schemaOwner, name] = args;
-            const owner = Ref.fromSchema(schemaOwner);
-            result = Key.of(schemaOwner.origin, Ref.property(owner, name));
-        }
-        return result;
+        return Key(`${admitted.origin}:class.${admitted.name}.property.${name}`);
     }
     PropertyKey.of = of;
     function is(input) {
-        return Key.is(input) && Ref.isProperty(Key.ref(input));
+        return typeof input === 'string' && Key.is(input) && PROPERTY_KEY_PATTERN.test(input);
     }
     PropertyKey.is = is;
+    function address(input) {
+        const admitted = PropertyKey(input);
+        const separator = admitted.indexOf(':');
+        const coordinate = admitted.slice(separator + ':class.'.length);
+        const member = coordinate.indexOf('.property.');
+        return Object.freeze({
+            owner: acceptDefinitionRef({
+                origin: admitted.slice(0, separator),
+                kind: 'class',
+                name: coordinate.slice(0, member),
+            }),
+            name: coordinate.slice(member + '.property.'.length),
+        });
+    }
+    PropertyKey.address = address;
 })(PropertyKey || (PropertyKey = {}));
-//# sourceMappingURL=property-key.js.map

package/dist/v1/addressing/revision.d.ts

@@ -0,0 +1,8 @@
+declare const DOMAIN_REVISION_BRAND: unique symbol;
+/** Content-addressed identity of one exact admitted Domain source. */
+export type Revision = `sha256:${string}` & {
+    readonly [DOMAIN_REVISION_BRAND]: true;
+};
+/** Content-address canonical Domain bytes with the one V1 revision algorithm. */
+export declare function digestRevisionBytes(bytes: Uint8Array): Revision;
+export {};

package/dist/v1/addressing/revision.js

@@ -0,0 +1,8 @@
+/** Content-address canonical Domain bytes with the one V1 revision algorithm. */
+export function digestRevisionBytes(bytes) {
+    let hexadecimal = '';
+    for (const byte of sha256(bytes))
+        hexadecimal += byte.toString(16).padStart(2, '0');
+    return `sha256:${hexadecimal}`;
+}
+import { sha256 } from '@noble/hashes/sha2.js';

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

@@ -0,0 +1,117 @@
+import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
+import type { z } from 'zod';
+import type { FunctionAuth, MethodInheritance } from '../../language/callable/model/callable.js';
+import type { PolicyCheckExpression, PolicyCheckObject, PolicyObjectRef } from '../../language/policy/model/policy.js';
+import type { Class } from '../class/authoring.js';
+import type { ValueSchemaInput } from '../class/property.js';
+import type { CoreNode } from '../core/authoring.js';
+import type { Policy, PolicyInput } from '../policy/authoring.js';
+import type { Lazy } from '../schema/lazy.js';
+import type { TypedValueSchema } from '../value/schema.js';
+import type { View } from '../view/authoring.js';
+import { type AUTHORING } from '../schema/handle.js';
+declare const CALLABLE_OUTPUT: unique symbol;
+declare const CALLABLE_PROJECTION: unique symbol;
+declare const CALLABLE_PROJECTION_VALUE: unique symbol;
+export interface CallablePolicyContext {
+    readonly input: Readonly<Record<string, Extract<PolicyCheckObject, {
+        readonly kind: 'input';
+    }>>>;
+    readonly self: Extract<PolicyCheckObject, {
+        readonly kind: 'self';
+    }>;
+    ref(member: PolicyObjectInput): Extract<PolicyCheckObject, {
+        readonly kind: 'ref';
+    }>;
+    check(policy: PolicyInput, object: PolicyCheckObject): PolicyCheckExpression;
+    allOf(first: PolicyCheckExpression, ...rest: readonly PolicyCheckExpression[]): PolicyCheckExpression;
+    anyOf(first: PolicyCheckExpression, ...rest: readonly PolicyCheckExpression[]): PolicyCheckExpression;
+}
+export type CallablePolicyBuilder = (context: CallablePolicyContext) => PolicyCheckExpression;
+export interface StreamOutput<out Item extends ValueSchemaInput = ValueSchemaInput> {
+    readonly mode: 'stream';
+    readonly item: Item;
+    readonly [CALLABLE_OUTPUT]: true;
+}
+export interface BinaryOutput {
+    readonly mode: 'binary';
+    readonly [CALLABLE_OUTPUT]: true;
+}
+export type CallableOutputInput = ValueSchemaInput | StreamOutput | BinaryOutput;
+export interface CallableInputBase {
+    readonly description?: string;
+    readonly input: ValueSchemaInput;
+    readonly output: CallableOutputInput;
+    readonly static?: boolean;
+    readonly inheritance?: MethodInheritance;
+}
+export type CallableInput = CallableInputBase & ({
+    readonly auth: 'anonymous';
+    readonly policy?: never;
+} | {
+    readonly auth: 'authenticated';
+    readonly policy?: never;
+} | {
+    readonly auth: 'authorized';
+    readonly policy?: CallablePolicyBuilder;
+});
+export type FunctionInput = CallableInput & {
+    readonly static?: never;
+    readonly inheritance?: never;
+};
+export type MethodInput = CallableInput;
+export interface CallableProjection<out Input = unknown, out Output = unknown, out Auth extends FunctionAuth = FunctionAuth, out Static extends boolean = boolean, out Inheritance extends MethodInheritance = MethodInheritance> {
+    readonly [CALLABLE_PROJECTION_VALUE]: true;
+    readonly input: Input;
+    readonly output: Output;
+    readonly auth: Auth;
+    readonly static: Static;
+    readonly inheritance: Inheritance;
+}
+type ValueInputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
+type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
+type CallableOutputOf<Input extends CallableOutputInput> = Input extends StreamOutput<infer Item> ? {
+    readonly mode: 'stream';
+    readonly item: ValueOutputOf<Item>;
+} : Input extends BinaryOutput ? {
+    readonly mode: 'binary';
+} : {
+    readonly mode: 'value';
+    readonly value: ValueOutputOf<Input>;
+};
+export interface Function<out Projection = unknown> {
+    readonly [AUTHORING]: 'function';
+    readonly [CALLABLE_PROJECTION]?: () => Projection;
+}
+export interface Method<out Projection = unknown> {
+    readonly [AUTHORING]: 'method';
+    readonly [CALLABLE_PROJECTION]?: () => Projection;
+}
+export type ProjectionOfCallable<Value extends Function | Method> = Value extends Function<infer Projection> ? Projection : Value extends Method<infer Projection> ? Projection : never;
+/** Internal lowering access; Callable authoring handles expose no public configuration object. */
+export declare function callableConfiguration(value: Function | Method): CallableInput;
+export type PolicyObjectAuthoring = Class | Function | Policy | View | CoreNode;
+export type PolicyObjectInput = Lazy<PolicyObjectAuthoring>;
+export declare function func<const Config extends FunctionInput, Input = ValueInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth']>(config: Config): Function<CallableProjection<Input, Output, Auth, false, 'default'>>;
+export declare function method<const Config extends MethodInput, Input = ValueInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Static extends boolean = Config extends {
+    readonly static: true;
+} ? true : false, Inheritance extends MethodInheritance = Config extends {
+    readonly inheritance: infer Value extends MethodInheritance;
+} ? Value : 'default'>(config: Config): Method<CallableProjection<Input, Output, Auth, Static, Inheritance>>;
+export declare function callableInputField(name: string): Extract<PolicyCheckObject, {
+    readonly kind: 'input';
+}>;
+export declare function callableSelf(): Extract<PolicyCheckObject, {
+    readonly kind: 'self';
+}>;
+export declare function callableRef(ref: PolicyObjectRef): Extract<PolicyCheckObject, {
+    readonly kind: 'ref';
+}>;
+export declare function callablePolicyObject(value: PolicyCheckObject): PolicyCheckObject;
+/** Explicit non-value output contracts. Plain schemas remain value outputs. */
+export declare const output: {
+    readonly stream: <const Item extends ValueSchemaInput>(item: Item) => StreamOutput<Item>;
+    readonly binary: () => BinaryOutput;
+};
+export declare function isCallableOutputAuthoring(value: CallableOutputInput): value is StreamOutput | BinaryOutput;
+export {};

package/dist/v1/builder/{callable.js → callable/authoring.js}

@@ -1,6 +1,14 @@
-import { authoringValue, isAuthoringValue } from './internal/authoring.js';
-import { assertKnownKeys } from './internal/diagnostic.js';
-export function fn(config) {
+import { assertKnownKeys } from '../schema/diagnostic.js';
+import { authoringValue, isAuthoringValue } from '../schema/handle.js';
+const callableInputs = new WeakMap();
+/** Internal lowering access; Callable authoring handles expose no public configuration object. */
+export function callableConfiguration(value) {
+    const input = callableInputs.get(value);
+    if (input === undefined)
+        throw new TypeError('Unknown Callable authoring handle.');
+    return input;
+}
+export function func(config) {
     assertKnownKeys(config, [
         'description',
         'input',
@@ -10,9 +18,23 @@ export function fn(config) {
         'static',
         'inheritance',
     ]);
-    return authoringValue('function', {
-        config: { ...config },
-    });
+    const value = authoringValue('function', {});
+    callableInputs.set(value, { ...config });
+    return value;
+}
+export function method(config) {
+    assertKnownKeys(config, [
+        'description',
+        'input',
+        'output',
+        'auth',
+        'policy',
+        'static',
+        'inheritance',
+    ]);
+    const value = authoringValue('method', {});
+    callableInputs.set(value, { ...config });
+    return value;
 }
 export function callableInputField(name) {
     return Object.freeze({ kind: 'input', field: name });
@@ -43,4 +65,3 @@ export const output = Object.freeze({
 export function isCallableOutputAuthoring(value) {
     return isAuthoringValue(value, 'callable-output');
 }
-//# sourceMappingURL=callable.js.map