@astrale-os/kernel-dsl 0.2.0-beta.1 → 0.2.0-beta.10

package/dist/v1/builder/{value-schema.d.ts → value/schema.d.ts}

@@ -1,5 +1,5 @@
-import type { JsonSchemaObject } from '../schema/value/schema.js';
-import type { ValueSchemaInput } from './property.js';
+import type { JsonSchemaObject } from '../../language/value/model/schema.js';
+import type { ValueSchemaInput } from '../class/property.js';
 declare const VALUE_SCHEMA_TYPE: unique symbol;
 /** Type-only value retained by one lossless Value Schema authored in TypeScript. */
 export interface TypedValueSchema<out Value = unknown> extends JsonSchemaObject {
@@ -14,4 +14,3 @@ export interface TypedValueSchema<out Value = unknown> extends JsonSchemaObject
  */
 export declare function valueSchema<Value>(): <const Schema extends ValueSchemaInput>(schema: Schema) => Schema & TypedValueSchema<Value>;
 export {};
-//# sourceMappingURL=value-schema.d.ts.map

package/dist/v1/builder/{value-schema.js → value/schema.js}

@@ -8,4 +8,3 @@
 export function valueSchema() {
     return (schema) => schema;
 }
-//# sourceMappingURL=value-schema.js.map

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

@@ -0,0 +1,17 @@
+import type { NodeClassReferenceInput } from '../class/authoring.js';
+import type { AUTHORING } from '../schema/handle.js';
+export type ViewDefinitionTargetsInput = readonly [
+    NodeClassReferenceInput,
+    ...NodeClassReferenceInput[]
+];
+export type ViewTargetInput = 'domain' | NodeClassReferenceInput | ViewDefinitionTargetsInput;
+export interface ViewInput {
+    readonly description?: string;
+    readonly target?: ViewTargetInput;
+}
+export interface View {
+    readonly [AUTHORING]: 'view';
+}
+/** Internal lowering access; View authoring handles expose no public configuration object. */
+export declare function viewAuthoringInput(value: View): ViewInput;
+export declare function view<const Config extends ViewInput>(config: Config & Record<Exclude<keyof Config, keyof ViewInput>, never>): View;

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

@@ -0,0 +1,16 @@
+import { assertKnownKeys } from '../schema/diagnostic.js';
+import { authoringValue } from '../schema/handle.js';
+const viewInputs = new WeakMap();
+/** Internal lowering access; View authoring handles expose no public configuration object. */
+export function viewAuthoringInput(value) {
+    const input = viewInputs.get(value);
+    if (input === undefined)
+        throw new TypeError('Unknown View authoring handle.');
+    return input;
+}
+export function view(config) {
+    assertKnownKeys(config, ['description', 'target']);
+    const value = authoringValue('view', {});
+    viewInputs.set(value, { ...config });
+    return value;
+}

package/dist/v1/bundle/codec.d.ts

@@ -3,4 +3,3 @@ export declare function acceptDomainSchemaBundle(input: unknown): DomainSchemaBu
 export declare function decodeDomainSchemaBundle(input: string | Uint8Array): DomainSchemaBundle;
 export declare function serializeDomainSchemaBundle(bundle: DomainSchemaBundleValue): string;
 export declare function encodeDomainSchemaBundle(bundle: DomainSchemaBundleValue): Uint8Array;
-//# sourceMappingURL=codec.d.ts.map

package/dist/v1/bundle/codec.js

@@ -1,12 +1,17 @@
 import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, json, } from '@astrale-os/kernel-dsl/value';
-import { DomainSchemaError, diagnostic } from '../schema/diagnostic.js';
-import { acceptDomainSchema } from '../schema/domain.accept.js';
-import { MemoryDomainSchemaLookup } from '../schema/domain.lookup.js';
-import { canonicalDomainSchemaAfterValidation } from '../schema/domain.revision.js';
-import { revisionOfDomainSchema } from '../schema/domain.revision.js';
-import { compareUnicode } from '../schema/reference.js';
+import { dependencyLimits } from '../addressing/domain-dependency.js';
+import { compareUnicode } from '../addressing/ordering.js';
+import { acceptDomainSchema } from '../schema/admission/accept.js';
+import { canonicalDomainSchemaAfterValidation } from '../schema/canonical/revision.js';
+import { revisionOfDomainSchema } from '../schema/canonical/revision.js';
+import { MemoryDomainSchemaLookup } from '../schema/dependency/lookup.js';
+import { SchemaError } from '../schema/diagnostic.js';
+import { BundleError, diagnostic } from './diagnostic.js';
 import { asDomainSchemaBundle, } from './model.js';
 import { parseDomainSchemaBundleStructure } from './structure.js';
+function escapeToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
 export function acceptDomainSchemaBundle(input) {
     let admitted;
     try {
@@ -14,7 +19,7 @@ export function acceptDomainSchemaBundle(input) {
     }
     catch (error) {
         if (error instanceof JsonBoundaryError) {
-            throw new DomainSchemaError([diagnostic('DV_JSON_VALUE', error.pointer, error.message)]);
+            throw new BundleError([diagnostic('DV_JSON_VALUE', error.pointer, error.message)]);
         }
         throw error;
     }
@@ -26,7 +31,7 @@ export function decodeDomainSchemaBundle(input) {
     }
     catch (error) {
         if (error instanceof json.DecodeError) {
-            throw new DomainSchemaError([diagnostic('DV_JSON_VALUE', '', error.message)]);
+            throw new BundleError([diagnostic('DV_JSON_VALUE', '', error.message)]);
         }
         throw error;
     }
@@ -43,6 +48,14 @@ function acceptBundleValue(input) {
     const closure = structure.closure.map((schema, index) => candidate(schema, `/closure/${index}`));
     const diagnostics = [];
     const candidates = new Map();
+    if (closure.length + 1 > dependencyLimits.closure) {
+        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/closure', `A dependency closure may contain at most ${dependencyLimits.closure} Domains.`));
+    }
+    for (const entry of [root, ...closure]) {
+        if (Object.keys(entry.schema.dependencies).length > dependencyLimits.direct) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', `${entry.pointer}/dependencies`, `A Domain may declare at most ${dependencyLimits.direct} direct dependency aliases.`));
+        }
+    }
     for (const entry of closure) {
         if (entry.key === root.key) {
             diagnostics.push(diagnostic('BUNDLE_ROOT_DUPLICATED', entry.pointer, 'The root schema must not also appear in the bundle closure.'));
@@ -56,20 +69,20 @@ function acceptBundleValue(input) {
         candidates.set(entry.key, entry);
     }
     const reachable = new Set();
-    collectReachable(root, root, candidates, reachable, new Set(), new Map(), diagnostics);
+    collectReachable(root, root, candidates, reachable, new Set(), new Map(), diagnostics, 0);
     for (const entry of candidates.values()) {
         if (!reachable.has(entry.key)) {
             diagnostics.push(diagnostic('BUNDLE_CLOSURE_EXTRA', entry.pointer, `Schema ${entry.schema.origin}@${entry.revision} is not reachable from the root.`));
         }
     }
     if (diagnostics.length > 0)
-        throw new DomainSchemaError(diagnostics);
+        throw new BundleError(diagnostics);
     const accepted = new Map();
     const acceptCandidate = (entry) => {
         const existing = accepted.get(entry.key);
         if (existing !== undefined)
             return existing.schema;
-        for (const dependency of entry.schema.dependencies) {
+        for (const dependency of Object.values(entry.schema.dependencies)) {
             const nested = candidates.get(keyOf(dependency.origin, dependency.revision));
             if (nested !== undefined)
                 acceptCandidate(nested);
@@ -78,7 +91,7 @@ function acceptBundleValue(input) {
             const schema = acceptDomainSchema(entry.schema, new MemoryDomainSchemaLookup([...accepted.values()]));
             const revision = revisionOfDomainSchema(schema);
             if (revision !== entry.revision) {
-                throw new DomainSchemaError([
+                throw new BundleError([
                     diagnostic('BUNDLE_SCHEMA_REVISION', '', `Accepted schema revision ${revision} differs from indexed revision ${entry.revision}.`),
                 ]);
             }
@@ -86,9 +99,9 @@ function acceptBundleValue(input) {
             return schema;
         }
         catch (error) {
-            if (!(error instanceof DomainSchemaError))
+            if (!(error instanceof SchemaError))
                 throw error;
-            throw new DomainSchemaError(error.diagnostics.map((item) => diagnostic(item.code, `${entry.pointer}${item.pointer}`, item.message, item.ref)));
+            throw new BundleError(error.diagnostics.map((item) => diagnostic(item.code, `${entry.pointer}${item.pointer}`, item.message, item.ref)));
         }
     };
     for (const entry of candidates.values()) {
@@ -111,14 +124,19 @@ function candidate(schema, pointer) {
         pointer,
     };
 }
-function collectReachable(current, root, candidates, reachable, active, revisions, diagnostics) {
+function collectReachable(current, root, candidates, reachable, active, revisions, diagnostics, depth) {
     if (active.has(current.key)) {
         diagnostics.push(diagnostic('BUNDLE_CLOSURE_CYCLE', current.pointer, `Bundle dependency cycle reaches ${current.schema.origin}@${current.revision}.`));
         return;
     }
     active.add(current.key);
-    for (const [index, dependency] of current.schema.dependencies.entries()) {
-        const pointer = `${current.pointer}/dependencies/${index}`;
+    if (depth > dependencyLimits.depth) {
+        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', current.pointer, `Dependency depth ${depth} exceeds the maximum ${dependencyLimits.depth}.`));
+        active.delete(current.key);
+        return;
+    }
+    for (const [alias, dependency] of Object.entries(current.schema.dependencies)) {
+        const pointer = `${current.pointer}/dependencies/${escapeToken(alias)}`;
         const dependencyKey = keyOf(dependency.origin, dependency.revision);
         if (dependencyKey === root.key) {
             diagnostics.push(diagnostic('BUNDLE_CLOSURE_CYCLE', pointer, 'Bundle dependency closure returns to its root.'));
@@ -137,7 +155,7 @@ function collectReachable(current, root, candidates, reachable, active, revision
             continue;
         }
         reachable.add(nested.key);
-        collectReachable(nested, root, candidates, reachable, active, revisions, diagnostics);
+        collectReachable(nested, root, candidates, reachable, active, revisions, diagnostics, depth + 1);
     }
     active.delete(current.key);
 }
@@ -148,4 +166,3 @@ function compareSchemas(left, right) {
 function keyOf(origin, revision) {
     return `${origin}\u0000${revision}`;
 }
-//# sourceMappingURL=codec.js.map

package/dist/v1/bundle/create.d.ts

@@ -0,0 +1,3 @@
+import type { DomainSchema } from '../schema/model/schema.js';
+import type { DomainSchemaBundle } from './model.js';
+export declare function createDomainSchemaBundle<const Root extends DomainSchema>(root: Root): DomainSchemaBundle<Root>;

package/dist/v1/bundle/create.js

@@ -0,0 +1,5 @@
+import { requireDomainClosure } from '../schema/resolution/closure.js';
+import { asDomainSchemaBundle } from './model.js';
+export function createDomainSchemaBundle(root) {
+    return asDomainSchemaBundle(root, requireDomainClosure(root).map(({ schema }) => schema));
+}

package/dist/v1/bundle/diagnostic.d.ts

@@ -0,0 +1,10 @@
+import type { SchemaDiagnostic, SchemaDiagnosticCode } from '../schema/diagnostic.js';
+export type BundleDiagnosticCode = SchemaDiagnosticCode | 'BUNDLE_CLOSURE_CYCLE' | 'BUNDLE_CLOSURE_EXTRA' | 'BUNDLE_CLOSURE_MISSING' | 'BUNDLE_REVISION_COHERENCE' | 'BUNDLE_ROOT_DUPLICATED' | 'BUNDLE_SCHEMA_DUPLICATED' | 'BUNDLE_SCHEMA_REVISION' | 'BUNDLE_STRUCTURE' | 'UNSUPPORTED_BUNDLE_FORMAT' | 'UNSUPPORTED_BUNDLE_VERSION';
+export type BundleDiagnostic<Code extends BundleDiagnosticCode = BundleDiagnosticCode> = Omit<SchemaDiagnostic, 'code'> & {
+    readonly code: Code;
+};
+export declare function diagnostic<const Code extends BundleDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): BundleDiagnostic<Code>;
+export declare class BundleError extends Error {
+    readonly diagnostics: readonly BundleDiagnostic[];
+    constructor(diagnostics: readonly BundleDiagnostic[]);
+}

package/dist/v1/bundle/diagnostic.js

@@ -0,0 +1,17 @@
+import { compareUnicode } from '../addressing/ordering.js';
+export function diagnostic(code, pointer, message, ref) {
+    return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
+}
+export class BundleError 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 = 'BundleError';
+        this.diagnostics = Object.freeze(ordered);
+    }
+}

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

@@ -1,5 +1,5 @@
 /** Create and transport one accepted schema with its exact dependency closure. */
-import type { DomainSchema } from '../schema/domain.ir.js';
+import type { DomainSchema } from '../schema/model/schema.js';
 import type { DOMAIN_BUNDLE_FORMAT, DOMAIN_BUNDLE_VERSION } from './model.js';
 /** Stable public name for the canonical exact dependency-closure envelope. */
 export interface Bundle<Root extends DomainSchema = DomainSchema> {
@@ -14,4 +14,5 @@ export declare function decode(input: string | Uint8Array): Bundle;
 export declare function encode(bundle: Bundle): Uint8Array;
 export declare function serialize(bundle: Bundle): string;
 export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
-//# sourceMappingURL=index.d.ts.map
+export { BundleError as Error } from './diagnostic.js';
+export type { BundleDiagnostic as Diagnostic, BundleDiagnosticCode as DiagnosticCode, } from './diagnostic.js';

package/dist/v1/bundle/index.js

@@ -1,6 +1,6 @@
 /** Create and transport one accepted schema with its exact dependency closure. */
 import { acceptDomainSchemaBundle, decodeDomainSchemaBundle, encodeDomainSchemaBundle, serializeDomainSchemaBundle, } from './codec.js';
-import { createDomainSchemaBundle } from './model.js';
+import { createDomainSchemaBundle } from './create.js';
 export function create(root) {
     return createDomainSchemaBundle(root);
 }
@@ -17,4 +17,4 @@ export function serialize(bundle) {
     return serializeDomainSchemaBundle(bundle);
 }
 export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
-//# sourceMappingURL=index.js.map
+export { BundleError as Error } from './diagnostic.js';

package/dist/v1/bundle/model.d.ts

@@ -1,4 +1,4 @@
-import type { DomainSchema } from '../schema/domain.ir.js';
+import type { DomainSchema } from '../schema/model/schema.js';
 export declare const DOMAIN_BUNDLE_FORMAT: 'astrale.dsl.bundle';
 export declare const DOMAIN_BUNDLE_VERSION: 'v1';
 declare const DOMAIN_SCHEMA_BUNDLE_BRAND: unique symbol;
@@ -12,8 +12,5 @@ export interface DomainSchemaBundleValue<Root extends DomainSchema = DomainSchem
 export type DomainSchemaBundle<Root extends DomainSchema = DomainSchema> = DomainSchemaBundleValue<Root> & {
     readonly [DOMAIN_SCHEMA_BUNDLE_BRAND]: true;
 };
-/** Package one accepted schema with the exact closure retained at acceptance. */
-export declare function createDomainSchemaBundle<const Root extends DomainSchema>(root: Root): DomainSchemaBundle<Root>;
 export declare function asDomainSchemaBundle<Root extends DomainSchema>(root: Root, closure: readonly DomainSchema[]): DomainSchemaBundle<Root>;
 export {};
-//# sourceMappingURL=model.d.ts.map

package/dist/v1/bundle/model.js

@@ -1,11 +1,6 @@
 import { deepFreeze } from '../schema/canonical/freeze.js';
-import { requireDomainClosure } from '../schema/resolution/closure.js';
 export const DOMAIN_BUNDLE_FORMAT = 'astrale.dsl.bundle';
 export const DOMAIN_BUNDLE_VERSION = 'v1';
-/** Package one accepted schema with the exact closure retained at acceptance. */
-export function createDomainSchemaBundle(root) {
-    return asDomainSchemaBundle(root, requireDomainClosure(root).map(({ schema }) => schema));
-}
 export function asDomainSchemaBundle(root, closure) {
     return deepFreeze({
         format: DOMAIN_BUNDLE_FORMAT,
@@ -14,4 +9,3 @@ export function asDomainSchemaBundle(root, closure) {
         closure: [...closure],
     });
 }
-//# sourceMappingURL=model.js.map

package/dist/v1/bundle/structure.d.ts

@@ -1,8 +1,7 @@
 import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
-import type { DomainSchemaIR } from '../schema/domain.ir.js';
+import type { DomainSchemaIR } from '../schema/model/schema.js';
 export interface DomainSchemaBundleStructure {
     readonly root: DomainSchemaIR;
     readonly closure: readonly DomainSchemaIR[];
 }
 export declare function parseDomainSchemaBundleStructure(input: JsonValue): DomainSchemaBundleStructure;
-//# sourceMappingURL=structure.d.ts.map

package/dist/v1/bundle/structure.js

@@ -1,9 +1,10 @@
-import { DomainSchemaError, diagnostic } from '../schema/diagnostic.js';
+import { SchemaError } from '../schema/diagnostic.js';
 import { routeDomainSchema } from '../schema/validation/domain.route.js';
+import { BundleError, diagnostic } from './diagnostic.js';
 import { DOMAIN_BUNDLE_FORMAT, DOMAIN_BUNDLE_VERSION } from './model.js';
 export function parseDomainSchemaBundleStructure(input) {
     if (!isObject(input)) {
-        throw new DomainSchemaError([
+        throw new BundleError([
             diagnostic('BUNDLE_STRUCTURE', '', 'DomainSchemaBundle must be an object.'),
         ]);
     }
@@ -38,9 +39,9 @@ export function parseDomainSchemaBundleStructure(input) {
         }
     }
     if (diagnostics.length > 0)
-        throw new DomainSchemaError(diagnostics);
+        throw new BundleError(diagnostics);
     if (root === undefined) {
-        throw new DomainSchemaError([
+        throw new BundleError([
             diagnostic('BUNDLE_STRUCTURE', '/root', 'DomainSchemaBundle root is missing.'),
         ]);
     }
@@ -53,7 +54,7 @@ function routeAt(value, pointer, diagnostics) {
         return routeDomainSchema(value);
     }
     catch (error) {
-        if (!(error instanceof DomainSchemaError))
+        if (!(error instanceof SchemaError))
             throw error;
         diagnostics.push(...error.diagnostics.map((entry) => diagnostic(entry.code, `${pointer}${entry.pointer}`, entry.message, entry.ref)));
         return undefined;
@@ -68,4 +69,3 @@ function describe(value) {
 function escapeToken(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=structure.js.map

package/dist/v1/bundle/transport.d.ts

@@ -0,0 +1,8 @@
+import type { Bundle } from './index.js';
+export type { Bundle } from './index.js';
+export declare const accept: (input: unknown) => Bundle;
+export declare const decode: (input: string | Uint8Array) => Bundle;
+export declare const encode: (bundle: Bundle) => Uint8Array;
+export declare const serialize: (bundle: Bundle) => string;
+export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
+export { BundleError as Error } from './diagnostic.js';

package/dist/v1/bundle/transport.js

@@ -0,0 +1,7 @@
+import { acceptDomainSchemaBundle, decodeDomainSchemaBundle, encodeDomainSchemaBundle, serializeDomainSchemaBundle, } from './codec.js';
+export const accept = (input) => acceptDomainSchemaBundle(input);
+export const decode = (input) => decodeDomainSchemaBundle(input);
+export const encode = (bundle) => encodeDomainSchemaBundle(bundle);
+export const serialize = (bundle) => serializeDomainSchemaBundle(bundle);
+export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
+export { BundleError as Error } from './diagnostic.js';

package/dist/v1/compiled/admission/accept.d.ts

@@ -0,0 +1,3 @@
+import type { CompiledSchema } from '../model/schema.js';
+/** Admit one detached compiled closure before indices and declarations become executable. */
+export declare function acceptCompiledSchema(input: unknown): CompiledSchema;