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

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

@@ -10,11 +10,11 @@ export function ClassKey(input) {
 /** Construction, admission, and structural-coordinate operations for exact Class keys. */
 (function (ClassKey) {
     function of(ref) {
-        const admitted = acceptDefinitionRef(ref);
-        if (admitted.kind !== 'class') {
+        const key = Key.of(ref);
+        if (!key.slice(key.indexOf(':') + 1).startsWith('class.')) {
             throw new TypeError(`Invalid ClassKey coordinate: ${JSON.stringify(ref)}.`);
         }
-        return Key.of(admitted);
+        return key;
     }
     ClassKey.of = of;
     function is(input) {

package/dist/v1/addressing/definition-ref.js

@@ -8,55 +8,39 @@ const DEFINITION_KINDS = new Set([
 ]);
 /** Admit and detach one canonical DefinitionRef from an untrusted value. */
 export function acceptDefinitionRef(input) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
-        invalid(input);
-    }
+    return readDefinitionRef(input) ?? invalid(input);
+}
+/** Identify a canonical DefinitionRef-shaped value without retaining caller state. */
+export function isDefinitionRef(input) {
+    return readDefinitionRef(input) !== undefined;
+}
+/** Compare exact Definition coordinates, independent of object identity. */
+export function equalDefinitionRefs(left, right) {
+    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
+}
+function invalid(input) {
+    throw new TypeError(`Invalid DefinitionRef: ${JSON.stringify(input)}.`);
+}
+/** A detached copy of the canonical DefinitionRef `input` holds, reading each field once. */
+function readDefinitionRef(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        return undefined;
     const value = input;
     const keys = Reflect.ownKeys(value);
     if (keys.length !== 3 ||
         !keys.every((key) => key === 'origin' || key === 'kind' || key === 'name')) {
-        invalid(input);
+        return undefined;
     }
-    const origin = value.origin;
-    const kind = value.kind;
-    const name = value.name;
+    const { origin, kind, name } = value;
     if (typeof origin !== 'string' ||
         !DOMAIN_ORIGIN_PATTERN.test(origin) ||
         typeof kind !== 'string' ||
         !DEFINITION_KINDS.has(kind) ||
         typeof name !== 'string' ||
         !definitionNameMatches(kind, name)) {
-        invalid(input);
+        return undefined;
     }
-    return Object.freeze({
-        origin,
-        kind: kind,
-        name,
-    });
-}
-/** Identify a canonical DefinitionRef-shaped value without retaining caller state. */
-export function isDefinitionRef(input) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input))
-        return false;
-    const value = input;
-    const keys = Reflect.ownKeys(value);
-    if (keys.length !== 3 ||
-        !keys.every((key) => key === 'origin' || key === 'kind' || key === 'name')) {
-        return false;
-    }
-    return (typeof value.origin === 'string' &&
-        DOMAIN_ORIGIN_PATTERN.test(value.origin) &&
-        typeof value.kind === 'string' &&
-        DEFINITION_KINDS.has(value.kind) &&
-        typeof value.name === 'string' &&
-        definitionNameMatches(value.kind, value.name));
-}
-/** Compare exact Definition coordinates, independent of object identity. */
-export function equalDefinitionRefs(left, right) {
-    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
-}
-function invalid(input) {
-    throw new TypeError(`Invalid DefinitionRef: ${JSON.stringify(input)}.`);
+    return Object.freeze({ origin, kind: kind, name });
 }
 function definitionNameMatches(kind, name) {
     return kind === 'core' ? CORE_SLUG_PATTERN.test(name) : MEMBER_NAME_PATTERN.test(name);

package/dist/v1/addressing/domain-dependency.d.ts

@@ -10,9 +10,3 @@ export type DomainDependency = JsonObject & {
 export type DependencyAlias = string;
 /** Exact direct dependency pins keyed by their authored aliases. */
 export type DomainDependencyMap = Readonly<Record<DependencyAlias, DomainDependency>>;
-/** Representation-neutral admission budgets shared by source and compiled closures. */
-export declare const dependencyLimits: Readonly<{
-    direct: 32;
-    closure: 256;
-    depth: 32;
-}>;

package/dist/v1/addressing/domain-dependency.js

@@ -1,6 +1 @@
-/** Representation-neutral admission budgets shared by source and compiled closures. */
-export const dependencyLimits = Object.freeze({
-    direct: 32,
-    closure: 256,
-    depth: 32,
-});
+export {};

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

@@ -12,7 +12,10 @@ export declare namespace Key {
     type Definition<Kind extends DefinitionKind = DefinitionKind, Name extends string = string, Origin extends Key.Origin = Key.Origin> = DefinitionKey<Origin, Kind, Name>;
     type Callable = DefinitionKey<Key.Origin, 'function'> | MethodKey;
     type View = DefinitionKey<Key.Origin, 'view'>;
-    /** Derive a canonical Definition key from its structured coordinate. */
+    /**
+     * Derive a canonical Definition key from its structured coordinate. A frozen coordinate of data
+     * fields cannot change, so its key is derived once and read back for every later call.
+     */
     function of<const Ref extends DefinitionRef>(ref: Ref): DefinitionKey<Ref['origin'], Ref['kind'], Ref['name']>;
     function origin(input: Key): Key.Origin;
     function is(input: unknown): input is Key;

package/dist/v1/addressing/key.js

@@ -1,8 +1,11 @@
 import { acceptDefinitionRef, } from './definition-ref.js';
 import { DOMAIN_ORIGIN_PATTERN } from './patterns.js';
 const DEFINITION_KEY = /^(?:class|function|policy|view)\.([A-Za-z][A-Za-z0-9_]*)$/u;
-const CORE_KEY = /^core\.([a-z][a-z0-9-]{0,99})$/u;
+// The slug is the whole rest of the coordinate, its own `.` included: no member follows a Core key.
+const CORE_KEY = /^core\.((?=.{1,100}$)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*)$/u;
 const MEMBER_KEY = /^class\.([A-Za-z][A-Za-z0-9_]*)\.(property|method)\.([A-Za-z][A-Za-z0-9_]*)$/u;
+/** The keys of frozen Definition coordinates, derived once each. */
+const derived = new WeakMap();
 export function Key(input) {
     if (typeof input !== 'string' || !isCanonicalKey(input)) {
         throw new TypeError(`Invalid Key: ${JSON.stringify(input)}.`);
@@ -11,10 +14,22 @@ export function Key(input) {
 }
 /** Canonical origin-qualified address operations. */
 (function (Key) {
-    /** Derive a canonical Definition key from its structured coordinate. */
+    /**
+     * Derive a canonical Definition key from its structured coordinate. A frozen coordinate of data
+     * fields cannot change, so its key is derived once and read back for every later call.
+     */
     function of(ref) {
+        const object = typeof ref === 'object' && ref !== null;
+        const known = object ? derived.get(ref) : undefined;
+        if (known !== undefined)
+            return known;
+        // Decided before admission reads the fields: only then are the fields read the final ones.
+        const stable = object && immutable(ref);
         const definition = acceptDefinitionRef(ref);
-        return Key(`${definition.origin}:${definition.kind}.${definition.name}`);
+        const key = Key(`${definition.origin}:${definition.kind}.${definition.name}`);
+        if (stable)
+            derived.set(ref, key);
+        return key;
     }
     Key.of = of;
     function origin(input) {
@@ -37,3 +52,8 @@ function isCanonicalKey(input) {
 function isCanonicalCoordinate(input) {
     return DEFINITION_KEY.test(input) || CORE_KEY.test(input) || MEMBER_KEY.test(input);
 }
+/** A frozen object of data fields answers every read alike; a getter may not. */
+function immutable(ref) {
+    return (Object.isFrozen(ref) &&
+        Reflect.ownKeys(ref).every((key) => 'value' in Reflect.getOwnPropertyDescriptor(ref, key)));
+}

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

@@ -4,3 +4,5 @@ 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;
+/** Order strings by UTF-16 code unit, the order `<` gives strings. */
+export declare function compareCodeUnits(left: string, right: string): number;

package/dist/v1/addressing/ordering.js

@@ -18,3 +18,7 @@ export function compareUnicode(left, right) {
     }
     return a.length - b.length;
 }
+/** Order strings by UTF-16 code unit, the order `<` gives strings. */
+export function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

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

@@ -3,6 +3,7 @@ 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;
+/** Labels of `[a-z][a-z0-9-]*` joined by `.`, 100 code points at most: `graph.reader`. */
 export declare const CORE_SLUG_PATTERN: RegExp;
 export declare const DOMAIN_REVISION_PATTERN: RegExp;
 export declare const PROPERTY_KEY_PATTERN: RegExp;
@@ -19,4 +20,3 @@ export declare const patterns: Readonly<{
     revision: RegExp;
     revisionFullMatch: "sha256:[0-9a-f]{64}";
 }>;
-export declare function assertMemberName(name: string): void;

package/dist/v1/addressing/patterns.js

@@ -1,7 +1,8 @@
 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;
+/** Labels of `[a-z][a-z0-9-]*` joined by `.`, 100 code points at most: `graph.reader`. */
+export const CORE_SLUG_PATTERN = /^(?=.{1,100}$)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*$/u;
 export const DOMAIN_REVISION_PATTERN = /^sha256:[0-9a-f]{64}$/u;
 const DOMAIN_REVISION_FULL_MATCH = 'sha256:[0-9a-f]{64}';
 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])?';
@@ -22,8 +23,3 @@ export const patterns = Object.freeze({
     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)}.`);
-    }
-}

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

@@ -1,9 +1,9 @@
 import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
 import type { z } from 'zod';
 import type { PolicyRef } from '../../addressing/index.js';
-import type { BinaryInputProjection, CallableExecution, FunctionAuth } from '../../language/callable/model/callable.js';
+import type { BinaryInputProjection, CallableAdmission, CallableExecution, FunctionAuth } 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 { Class } from '../class/handle.js';
 import type { ValueSchemaInput } from '../class/property.js';
 import type { CoreNode } from '../core/authoring.js';
 import type { Policy, PolicyInput } from '../policy/authoring.js';
@@ -62,6 +62,8 @@ export interface CallableInputBase<Input extends FunctionInputSchema = ValueSche
     readonly output: CallableOutputInput;
     /** `{ durable: true }` makes an invocation return an Execution reference. */
     readonly execution?: CallableExecution;
+    /** `{ maxAge }`: how old, in seconds, the admission a call is served under may be. */
+    readonly admission?: CallableAdmission;
 }
 type ConcreteCallableInput<Input extends FunctionInputSchema = ValueSchemaInput> = CallableInputBase<Input> & ({
     readonly auth: 'anonymous';
@@ -83,7 +85,7 @@ export type MethodInput = ConcreteCallableInput & {
     readonly abstract?: boolean;
 };
 export type CallableInput = FunctionInput | MethodInput;
-export interface CallableProjection<out Input = unknown, out Output = unknown, out Auth extends FunctionAuth = FunctionAuth, out Static extends boolean = boolean, out Abstract extends boolean = boolean, out Execution extends CallableExecution | undefined = CallableExecution | undefined> {
+export interface CallableProjection<out Input = unknown, out Output = unknown, out Auth extends FunctionAuth = FunctionAuth, out Static extends boolean = boolean, out Abstract extends boolean = boolean, out Execution extends CallableExecution | undefined = CallableExecution | undefined, out Admission extends CallableAdmission | undefined = CallableAdmission | undefined> {
     readonly [CALLABLE_PROJECTION_VALUE]: true;
     readonly input: Input;
     readonly output: Output;
@@ -91,6 +93,7 @@ export interface CallableProjection<out Input = unknown, out Output = unknown, o
     readonly static: Static;
     readonly abstract: Abstract;
     readonly execution: Execution;
+    readonly admission: Admission;
 }
 type ValueInputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
 type FunctionInputOf<Schema> = Schema extends BinaryInputAuthoring<infer Metadata> ? BinaryInputProjection<ValueInputOf<Metadata>> : ValueInputOf<Schema>;
@@ -98,6 +101,9 @@ type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Valu
 type ExecutionOfConfig<Config extends CallableInput> = Config extends {
     readonly execution: infer Execution extends CallableExecution;
 } ? Execution : undefined;
+type AdmissionOfConfig<Config extends CallableInput> = Config extends {
+    readonly admission: infer Admission extends CallableAdmission;
+} ? Admission : undefined;
 type CallableOutputOf<Input extends CallableOutputInput> = Input extends StreamOutput<infer Item> ? {
     readonly mode: 'stream';
     readonly item: ValueOutputOf<Item>;
@@ -120,12 +126,12 @@ export type ProjectionOfCallable<Value extends Function | Method> = Value extend
 export declare function callableConfiguration(value: Function | Method): CallableInput;
 type PolicyObjectAuthoring = Class | Function | Method | Policy | View | CoreNode;
 export type PolicyObjectInput = Lazy<PolicyObjectAuthoring | PolicyObjectRef>;
-export declare function func<const Config extends FunctionInput, Input = FunctionInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>>(config: Config): Function<CallableProjection<Input, Output, Auth, false, false, Execution>>;
+export declare function func<const Config extends FunctionInput, Input = FunctionInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>, Admission extends CallableAdmission | undefined = AdmissionOfConfig<Config>>(config: Config): Function<CallableProjection<Input, Output, Auth, false, false, Execution, Admission>>;
 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, Abstract extends boolean = Config extends {
     readonly abstract: infer Value extends boolean;
-} ? Value : false, Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>>(config: Config): Method<CallableProjection<Input, Output, Auth, Static, Abstract, Execution>>;
+} ? Value : false, Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>, Admission extends CallableAdmission | undefined = AdmissionOfConfig<Config>>(config: Config): Method<CallableProjection<Input, Output, Auth, Static, Abstract, Execution, Admission>>;
 export declare function callableInputField(name: string): Extract<PolicyCheckObject, {
     readonly kind: 'input';
 }>;

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

@@ -18,6 +18,7 @@ export function func(config) {
         'static',
         'abstract',
         'execution',
+        'admission',
     ]);
     const value = authoringValue('function', {});
     callableInputs.set(value, { ...config });
@@ -33,6 +34,7 @@ export function method(config) {
         'static',
         'abstract',
         'execution',
+        'admission',
     ]);
     const value = authoringValue('method', {});
     callableInputs.set(value, { ...config });