@astrale-os/kernel-dsl 0.2.0-beta.5 → 0.2.0-beta.7

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;