@astrale-os/kernel-dsl 0.2.0-beta.4 → 0.2.0-beta.40

package/dist/v1/schema/validation/value.js

@@ -1,13 +1,8 @@
+import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { validateValueSchema } from '../../language/value/profile/validate.js';
 import { diagnostic } from '../diagnostic.js';
-import { validateValueSchema } from '../value/profile/validate.js';
 export function validateEmbeddedValueSchemas(schema, registry) {
     const diagnostics = [];
-    for (const [name, value] of Object.entries(schema.types)) {
-        validate(value, 'named-type', `/types/${escapePointer(name)}`, registry, diagnostics);
-    }
-    for (const [name, declaration] of Object.entries(schema.interfaces)) {
-        validateDefinition(declaration, `/interfaces/${escapePointer(name)}`, registry, diagnostics);
-    }
     for (const [name, declaration] of Object.entries(schema.classes)) {
         validateDefinition(declaration, `/classes/${escapePointer(name)}`, registry, diagnostics);
     }
@@ -17,7 +12,9 @@ export function validateEmbeddedValueSchemas(schema, registry) {
     return Object.freeze(diagnostics);
 }
 function validateDefinition(declaration, pointer, registry, diagnostics) {
-    validate(declaration.properties, 'property-facet', `${pointer}/properties`, registry, diagnostics);
+    for (const [name, property] of Object.entries(declaration.properties)) {
+        validate(property.schema, 'property-facet', `${pointer}/properties/${escapePointer(name)}/schema`, registry, diagnostics);
+    }
     if ('methods' in declaration) {
         for (const [name, method] of Object.entries(declaration.methods)) {
             validateCallable(method, `${pointer}/methods/${escapePointer(name)}`, registry, diagnostics);
@@ -25,7 +22,12 @@ function validateDefinition(declaration, pointer, registry, diagnostics) {
     }
 }
 function validateCallable(declaration, pointer, registry, diagnostics) {
-    validate(declaration.input, 'callable-input', `${pointer}/input`, registry, diagnostics);
+    if (isBinaryInput(declaration.input)) {
+        validate(declaration.input.metadata, 'callable-input', `${pointer}/input/metadata`, registry, diagnostics);
+    }
+    else {
+        validate(declaration.input, 'callable-input', `${pointer}/input`, registry, diagnostics);
+    }
     if (declaration.output.mode === 'value') {
         validate(declaration.output.schema, 'callable-output', `${pointer}/output/schema`, registry, diagnostics);
     }
@@ -41,4 +43,3 @@ function validate(schema, context, pointer, registry, diagnostics) {
 function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=value.js.map

package/dist/v1/schema/validation/view.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainResolutionContext } from '../resolution/context.js';
+export declare function validateViews(environment: DomainResolutionContext): readonly SchemaDiagnostic[];

package/dist/v1/schema/validation/view.js

@@ -0,0 +1,29 @@
+import { Key } from '../../addressing/key.js';
+import { diagnostic } from '../diagnostic.js';
+const formatDefinitionRef = Key.of;
+export function validateViews(environment) {
+    const diagnostics = [];
+    for (const [name, view] of Object.entries(environment.candidate.views)) {
+        const pointer = `/views/${escapePointer(name)}`;
+        const ref = { origin: environment.candidate.origin, kind: 'view', name };
+        if (!sameRef(view.ref, ref)) {
+            diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `View ref must be exactly ${formatDefinitionRef(ref)}.`, formatDefinitionRef(view.ref)));
+        }
+        if (view.target.kind === 'definition') {
+            view.target.definitions.forEach((ref, index) => validateDefinitionTarget(environment, ref, `${pointer}/target/definitions/${index}`, diagnostics));
+        }
+    }
+    return Object.freeze(diagnostics);
+}
+function sameRef(left, right) {
+    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
+}
+function validateDefinitionTarget(environment, ref, pointer, diagnostics) {
+    const target = environment.resolve(ref);
+    if (target === undefined || target.ref.kind !== 'class' || target.kind !== 'node') {
+        diagnostics.push(diagnostic('DV_VIEW_TARGET', pointer, `Definition target ${formatDefinitionRef(ref)} does not resolve to a Node Class.`, formatDefinitionRef(ref)));
+    }
+}
+function escapePointer(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

package/dist/v1/value/full-match.d.ts

@@ -0,0 +1,2 @@
+/** Narrow public runtime owner for the portable full-string matcher. */
+export { fullMatch, type FullMatch } from '../language/value/syntax/full-match.js';

package/dist/v1/value/full-match.js

@@ -0,0 +1,2 @@
+/** Narrow public runtime owner for the portable full-string matcher. */
+export { fullMatch } from '../language/value/syntax/full-match.js';

package/dist/v1.d.ts

@@ -1,3 +1,2 @@
-/** Compatibility source facade; the explicit V1 module is owned by `./v1/index.ts`. */
+/** Source facade for the governing V1 module. */
 export * from './v1/index.js';
-//# sourceMappingURL=v1.d.ts.map

package/dist/v1.js

@@ -1,3 +1,2 @@
-/** Compatibility source facade; the explicit V1 module is owned by `./v1/index.ts`. */
+/** Source facade for the governing V1 module. */
 export * from './v1/index.js';
-//# sourceMappingURL=v1.js.map

package/dist/value/accept.d.ts

@@ -6,4 +6,12 @@ import { type Options } from './limits.js';
  * Every source property is obtained from one descriptor snapshot. Accessors are never invoked.
  */
 export declare function accept(input: unknown, options?: Options): Value;
-//# sourceMappingURL=accept.d.ts.map
+/** Admit unknown data into a deeply immutable snapshot; owned subtrees may be shared. */
+export declare function acceptImmutable(input: unknown, options?: Options): Value;
+/** Admit a read-only snapshot, sharing owned immutable subtrees without freezing new wrappers. */
+export declare function acceptForRead(input: unknown, options?: Options): Value;
+/**
+ * Private PropertyValues owner seam. Retain immediate recursive values, not the enclosing
+ * dictionary: its canonical coordinates are re-admitted by the Property owner on every use.
+ */
+export declare function acceptPropertyRoot(input: unknown): Value;

package/dist/value/accept.js

@@ -1,4 +1,5 @@
 import { BoundaryError } from './error.js';
+import { includeSnapshot, retainImmutableSnapshot, reusableSnapshot, } from './immutable.optimization.js';
 import { limitsFor } from './limits.js';
 import { assertHostString } from './unicode.js';
 /**
@@ -7,9 +8,45 @@ import { assertHostString } from './unicode.js';
  * Every source property is obtained from one descriptor snapshot. Accessors are never invoked.
  */
 export function accept(input, options) {
-    const state = { active: new WeakSet(), limits: limitsFor(options), members: 0 };
+    return snapshot(input, options, 'copy');
+}
+/** Admit unknown data into a deeply immutable snapshot; owned subtrees may be shared. */
+export function acceptImmutable(input, options) {
+    const captured = { propertyRoots: false };
+    const value = snapshot(input, options, 'immutable', captured);
+    if (value !== null && typeof value === 'object') {
+        retainImmutableSnapshot(value, captured.summary);
+    }
+    return value;
+}
+/** Admit a read-only snapshot, sharing owned immutable subtrees without freezing new wrappers. */
+export function acceptForRead(input, options) {
+    return snapshot(input, options, 'read');
+}
+/**
+ * Private PropertyValues owner seam. Retain immediate recursive values, not the enclosing
+ * dictionary: its canonical coordinates are re-admitted by the Property owner on every use.
+ */
+export function acceptPropertyRoot(input) {
+    return snapshot(input, undefined, 'immutable', { propertyRoots: true });
+}
+function snapshot(input, options, mode, captured) {
+    const state = {
+        active: new WeakSet(),
+        limits: limitsFor(options),
+        members: 0,
+        mode,
+        summary: mode === 'immutable' && !captured?.propertyRoots
+            ? { members: 0, depth: 0, stringBytes: 0 }
+            : undefined,
+        summaryDepth: 0,
+        propertyRoots: captured?.propertyRoots ?? false,
+    };
     try {
-        return admit(input, '', 0, state);
+        const value = admit(input, '', 0, state);
+        if (captured !== undefined)
+            captured.summary = state.summary;
+        return value;
     }
     catch (error) {
         if (error instanceof BoundaryError)
@@ -30,12 +67,20 @@ function admit(input, pointer, depth, state) {
         return input;
     }
     if (typeof input === 'string') {
-        assertHostString(input, pointer, state.limits.maxStringBytes);
+        admitString(input, pointer, state);
         return input;
     }
     if (typeof input !== 'object') {
         throw new BoundaryError('VALUE_TYPE', 'Expected a portable value', pointer);
     }
+    if (state.mode !== 'copy' && !(state.propertyRoots && depth === 0)) {
+        const summary = reusableSnapshot(input, state.limits, depth, state.members);
+        if (summary !== undefined) {
+            state.members += summary.members;
+            includeSnapshot(state.summary, summary, depth - state.summaryDepth);
+            return input;
+        }
+    }
     if (state.active.has(input)) {
         throw new BoundaryError('VALUE_CYCLE', 'Cyclic object graphs are not portable values', pointer);
     }
@@ -43,13 +88,33 @@ function admit(input, pointer, depth, state) {
         throw new BoundaryError('VALUE_LIMIT', `Container depth exceeds the ${state.limits.maxDepth}-level limit`, pointer);
     }
     state.active.add(input);
+    const parent = state.summary;
+    const parentDepth = state.summaryDepth;
+    const propertyRoot = state.mode === 'immutable' && state.propertyRoots && depth === 1;
+    if (propertyRoot) {
+        state.summary = { members: 0, depth: 0, stringBytes: 0 };
+        state.summaryDepth = depth;
+    }
+    if (state.summary !== undefined) {
+        state.summary.depth = Math.max(state.summary.depth, depth + 1 - state.summaryDepth);
+    }
     try {
-        return reflect(() => Array.isArray(input), pointer, 'Cannot inspect the host value brand')
+        const output = reflect(() => Array.isArray(input), pointer, 'Cannot inspect the host value brand')
             ? admitArray(input, pointer, depth + 1, state)
             : admitObject(input, pointer, depth + 1, state);
+        if (state.mode === 'immutable') {
+            Object.freeze(output);
+            if (propertyRoot) {
+                retainImmutableSnapshot(output, state.summary);
+                includeSnapshot(parent, state.summary, depth - parentDepth);
+            }
+        }
+        return output;
     }
     finally {
         state.active.delete(input);
+        state.summary = parent;
+        state.summaryDepth = parentDepth;
     }
 }
 function admitArray(input, pointer, depth, state) {
@@ -92,7 +157,7 @@ function admitObject(input, pointer, depth, state) {
             throw new BoundaryError('VALUE_OBJECT', 'Portable Objects cannot have symbol members', pointer);
         }
         const memberPointer = child(pointer, key);
-        assertHostString(key, memberPointer, state.limits.maxStringBytes);
+        admitString(key, memberPointer, state);
         const descriptor = ownDescriptor(descriptors, key);
         if (descriptor === undefined || !descriptor.enumerable || !('value' in descriptor)) {
             throw new BoundaryError('VALUE_OBJECT', 'Object members must be enumerable data properties', memberPointer);
@@ -115,10 +180,18 @@ function ownDescriptor(descriptors, name) {
 }
 function addMembers(state, count, pointer) {
     state.members += count;
+    if (state.summary !== undefined)
+        state.summary.members += count;
     if (state.members > state.limits.maxMembers) {
         throw new BoundaryError('VALUE_LIMIT', `Value exceeds the ${state.limits.maxMembers}-member limit`, pointer);
     }
 }
+function admitString(value, pointer, state) {
+    const bytes = assertHostString(value, pointer, state.limits.maxStringBytes);
+    if (state.summary !== undefined) {
+        state.summary.stringBytes = Math.max(state.summary.stringBytes, bytes);
+    }
+}
 function reflect(operation, pointer, message) {
     try {
         return operation();
@@ -130,4 +203,3 @@ function reflect(operation, pointer, message) {
 function child(pointer, token) {
     return `${pointer}/${token.replaceAll('~', '~0').replaceAll('/', '~1')}`;
 }
-//# sourceMappingURL=accept.js.map

package/dist/value/canonical.d.ts

@@ -1,5 +1,7 @@
+import type { Value } from './types.js';
 import { type Options } from './limits.js';
 /** RFC 8785 canonical JSON for one admitted portable snapshot. */
 export declare function serialize(input: unknown, options?: Options): string;
+/** Serialize a trusted portable value whose default structural admission proof is still valid. */
+export declare function serializeAdmitted(input: Value): string;
 export declare function encode(input: unknown, options?: Options): Uint8Array;
-//# sourceMappingURL=canonical.d.ts.map

package/dist/value/canonical.js

@@ -1,14 +1,22 @@
-import { accept } from './accept.js';
+import { acceptForRead } from './accept.js';
 import { BoundaryError } from './error.js';
-import { limitsFor } from './limits.js';
+import { defaultLimits, limitsFor } from './limits.js';
 import { utf8Length } from './unicode.js';
 const encoder = new TextEncoder();
 /** RFC 8785 canonical JSON for one admitted portable snapshot. */
 export function serialize(input, options) {
     const limits = limitsFor(options);
-    const output = serializeValue(accept(input, options));
-    if (utf8Length(output, limits.maxBytes) > limits.maxBytes) {
-        throw new BoundaryError('VALUE_LIMIT', `Canonical JSON exceeds the ${limits.maxBytes}-byte limit`);
+    return serializeSnapshot(acceptForRead(input, options), limits.maxBytes);
+}
+/** Serialize a trusted portable value whose default structural admission proof is still valid. */
+export function serializeAdmitted(input) {
+    return serializeSnapshot(input, defaultLimits.maxBytes);
+}
+function serializeSnapshot(input, maxBytes) {
+    const output = serializeValue(input);
+    // Scalar text uses at most three UTF-8 bytes per UTF-16 code unit, including JSON escapes.
+    if (output.length > maxBytes / 3 && utf8Length(output, maxBytes) > maxBytes) {
+        throw new BoundaryError('VALUE_LIMIT', `Canonical JSON exceeds the ${maxBytes}-byte limit`);
     }
     return output;
 }
@@ -39,4 +47,3 @@ function serializeObject(value) {
 function compareUtf16(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=canonical.js.map

package/dist/value/decode.d.ts

@@ -2,4 +2,3 @@ import type { Value } from './types.js';
 import { type Options } from './limits.js';
 /** Strictly decode one bounded JSON value. */
 export declare function decode(input: string | Uint8Array, options?: Options): Value;
-//# sourceMappingURL=decode.d.ts.map

package/dist/value/decode.js

@@ -106,4 +106,3 @@ function endContainer(state, kind, offset) {
 function failSyntax(message, offset) {
     throw new DecodeError('JSON_SYNTAX', message, offset);
 }
-//# sourceMappingURL=decode.js.map

package/dist/value/equal.d.ts

@@ -1,4 +1,3 @@
 import type { Value } from './types.js';
 /** Compare two portable Values by their canonical JSON meaning. */
 export declare function equal(left: Value, right: Value): boolean;
-//# sourceMappingURL=equal.d.ts.map

package/dist/value/equal.js

@@ -3,4 +3,3 @@ import { serialize } from './json.js';
 export function equal(left, right) {
     return left === right || serialize(left) === serialize(right);
 }
-//# sourceMappingURL=equal.js.map

package/dist/value/error.d.ts

@@ -10,4 +10,3 @@ export declare class DecodeError extends SyntaxError {
     readonly offset: number;
     constructor(code: DecodeErrorCode, message: string, offset: number, options?: ErrorOptions);
 }
-//# sourceMappingURL=error.d.ts.map

package/dist/value/error.js

@@ -19,4 +19,3 @@ export class DecodeError extends SyntaxError {
         this.offset = offset;
     }
 }
-//# sourceMappingURL=error.js.map

package/dist/value/immutable.optimization.d.ts

@@ -0,0 +1,12 @@
+import type { Limits } from './limits.js';
+export interface SnapshotSummary {
+    members: number;
+    depth: number;
+    stringBytes: number;
+}
+export declare function isImmutableSnapshot(value: object): boolean;
+/** Called only after admission has constructed and deeply frozen this container. */
+export declare function retainImmutableSnapshot(value: object, summary: SnapshotSummary): void;
+export declare function includeSnapshot(parent: SnapshotSummary | undefined, child: SnapshotSummary, depth: number): void;
+/** A failed fit must use normal admission, preserving its exact error pointer. */
+export declare function reusableSnapshot(value: object, limits: Limits, depth: number, members: number): SnapshotSummary | undefined;

package/dist/value/immutable.optimization.js

@@ -0,0 +1,28 @@
+// Only admission-owned, deeply immutable snapshots enter this table. A frozen
+// caller object is not a proof. Weak identity ownership retains no caller data.
+const snapshots = new WeakMap();
+export function isImmutableSnapshot(value) {
+    return snapshots.has(value);
+}
+/** Called only after admission has constructed and deeply frozen this container. */
+export function retainImmutableSnapshot(value, summary) {
+    if (!snapshots.has(value))
+        snapshots.set(value, summary);
+}
+export function includeSnapshot(parent, child, depth) {
+    if (parent === undefined)
+        return;
+    parent.members += child.members;
+    parent.depth = Math.max(parent.depth, depth + child.depth);
+    parent.stringBytes = Math.max(parent.stringBytes, child.stringBytes);
+}
+/** A failed fit must use normal admission, preserving its exact error pointer. */
+export function reusableSnapshot(value, limits, depth, members) {
+    const summary = snapshots.get(value);
+    if (summary === undefined ||
+        summary.members > limits.maxMembers - members ||
+        summary.depth > limits.maxDepth - depth ||
+        summary.stringBytes > limits.maxStringBytes)
+        return undefined;
+    return summary;
+}

package/dist/value/index.d.ts

@@ -1,5 +1,5 @@
 /** Portable values shared by the DSL and kernel contracts. */
-export { accept } from './accept.js';
+export { accept, acceptForRead, acceptImmutable } from './accept.js';
 export { equal } from './equal.js';
 export { BoundaryError, DecodeError } from './error.js';
 export type { BoundaryErrorCode, DecodeErrorCode } from './error.js';
@@ -7,4 +7,3 @@ export { defaultLimits } from './limits.js';
 export type { LimitOverrides, Limits, Options } from './limits.js';
 export * as json from './json.js';
 export type { Array, Object, Primitive, Value } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/value/index.js

@@ -1,7 +1,6 @@
 /** Portable values shared by the DSL and kernel contracts. */
-export { accept } from './accept.js';
+export { accept, acceptForRead, acceptImmutable } from './accept.js';
 export { equal } from './equal.js';
 export { BoundaryError, DecodeError } from './error.js';
 export { defaultLimits } from './limits.js';
 export * as json from './json.js';
-//# sourceMappingURL=index.js.map

package/dist/value/json.d.ts

@@ -1,4 +1,3 @@
-export { encode, serialize } from './canonical.js';
+export { encode, serialize, serializeAdmitted } from './canonical.js';
 export { decode } from './decode.js';
 export { DecodeError } from './error.js';
-//# sourceMappingURL=json.d.ts.map

package/dist/value/json.js

@@ -1,4 +1,3 @@
-export { encode, serialize } from './canonical.js';
+export { encode, serialize, serializeAdmitted } from './canonical.js';
 export { decode } from './decode.js';
 export { DecodeError } from './error.js';
-//# sourceMappingURL=json.js.map

package/dist/value/limits.d.ts

@@ -19,4 +19,3 @@ export interface Options {
 }
 export declare const defaultLimits: Readonly<Limits>;
 export declare function limitsFor(options: Options | undefined): Limits;
-//# sourceMappingURL=limits.d.ts.map

package/dist/value/limits.js

@@ -13,4 +13,3 @@ export function limitsFor(options) {
     }
     return candidate;
 }
-//# sourceMappingURL=limits.js.map

package/dist/value/types.d.ts

@@ -4,4 +4,3 @@ export type Object = {
     readonly [name: string]: Value;
 };
 export type Value = Primitive | Array | Object;
-//# sourceMappingURL=types.d.ts.map

package/dist/value/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/value/unicode.d.ts

@@ -1,5 +1,4 @@
 export declare function utf8Length(value: string, max?: number): number;
-export declare function assertHostString(value: string, pointer: string, maxBytes: number): void;
+export declare function assertHostString(value: string, pointer: string, maxBytes: number): number;
 export declare function assertDecodedString(value: string, offset: number, maxBytes: number): void;
 export declare function assertSourceString(value: string, maxBytes: number): void;
-//# sourceMappingURL=unicode.d.ts.map

package/dist/value/unicode.js

@@ -34,6 +34,7 @@ export function assertHostString(value, pointer, maxBytes) {
     if (length > maxBytes) {
         throw new BoundaryError('VALUE_LIMIT', `String exceeds the ${maxBytes}-byte UTF-8 limit`, pointer);
     }
+    return length;
 }
 export function assertDecodedString(value, offset, maxBytes) {
     if (value.includes('\u0000')) {
@@ -62,4 +63,3 @@ function isHighSurrogate(codeUnit) {
 function isLowSurrogate(codeUnit) {
     return codeUnit >= 0xdc00 && codeUnit <= 0xdfff;
 }
-//# sourceMappingURL=unicode.js.map

package/dist/version/dispatch.d.ts

@@ -22,4 +22,3 @@ type HandlerResult<Handlers extends readonly VersionHandler<unknown>[]> = Handle
 /** Dispatch by exact format and version before invoking version-owned admission. */
 export declare function dispatchLanguageVersion<const Handlers extends readonly VersionHandler<unknown>[]>(input: unknown, handlers: Handlers): HandlerResult<Handlers>;
 export {};
-//# sourceMappingURL=dispatch.d.ts.map

package/dist/version/dispatch.js

@@ -45,4 +45,3 @@ export function dispatchLanguageVersion(input, handlers) {
     }
     return matches[0].accept(input);
 }
-//# sourceMappingURL=dispatch.js.map

package/dist/version/index.d.ts

@@ -1,3 +1,2 @@
 export { LanguageVersionError, dispatchLanguageVersion, readLanguageVersion } from './dispatch.js';
 export type { LanguageVersion, LanguageVersionErrorCode, LanguageVersionOf, VersionHandler, } from './dispatch.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/version/index.js

@@ -1,2 +1 @@
 export { LanguageVersionError, dispatchLanguageVersion, readLanguageVersion } from './dispatch.js';
-//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.4",
+  "version": "0.2.0-beta.40",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {
@@ -27,25 +27,57 @@
       "types": "./dist/v1/addressing/index.d.ts",
       "import": "./dist/v1/addressing/index.js"
     },
+    "./v1/builder": {
+      "types": "./dist/v1/builder/index.d.ts",
+      "import": "./dist/v1/builder/index.js"
+    },
     "./v1/bundle": {
       "types": "./dist/v1/bundle/index.d.ts",
       "import": "./dist/v1/bundle/index.js"
     },
+    "./v1/bundle/transport": {
+      "types": "./dist/v1/bundle/transport.d.ts",
+      "import": "./dist/v1/bundle/transport.js"
+    },
+    "./v1/compiled": {
+      "types": "./dist/v1/compiled/index.d.ts",
+      "import": "./dist/v1/compiled/index.js"
+    },
+    "./v1/compiled/generated": {
+      "types": "./dist/v1/compiled/generated.d.ts",
+      "import": "./dist/v1/compiled/generated.js"
+    },
+    "./v1/compiled/loader": {
+      "types": "./dist/v1/compiled/loader/index.d.ts",
+      "import": "./dist/v1/compiled/loader/index.js"
+    },
+    "./v1/domain": {
+      "types": "./dist/v1/domain/index.d.ts",
+      "import": "./dist/v1/domain/index.js"
+    },
+    "./v1/language": {
+      "types": "./dist/v1/language/index.d.ts",
+      "import": "./dist/v1/language/index.js"
+    },
+    "./v1/language/state": {
+      "types": "./dist/v1/language/state/index.d.ts",
+      "import": "./dist/v1/language/state/index.js"
+    },
     "./v1/schema": {
       "types": "./dist/v1/schema/index.d.ts",
       "import": "./dist/v1/schema/index.js"
     },
-    "./v1/schema/full-match": {
-      "types": "./dist/v1/schema/value/full-match.d.ts",
-      "import": "./dist/v1/schema/value/full-match.js"
+    "./v1/schema/fingerprint": {
+      "types": "./dist/v1/schema/fingerprint.d.ts",
+      "import": "./dist/v1/schema/fingerprint.js"
     },
     "./v1/schema/revision": {
-      "types": "./dist/v1/schema/domain.revision.d.ts",
-      "import": "./dist/v1/schema/domain.revision.js"
+      "types": "./dist/v1/schema/revision.d.ts",
+      "import": "./dist/v1/schema/revision.js"
     },
-    "./v1/schema/validator": {
-      "types": "./dist/v1/schema/compiled/validator.d.ts",
-      "import": "./dist/v1/schema/compiled/validator.js"
+    "./v1/value/full-match": {
+      "types": "./dist/v1/value/full-match.d.ts",
+      "import": "./dist/v1/value/full-match.js"
     },
     "./value": {
       "types": "./dist/value/index.d.ts",
@@ -57,31 +89,30 @@
     "access": "public"
   },
   "dependencies": {
-    "@noble/hashes": "2.2.0",
+    "@noble/hashes": "2.3.0",
     "jsonc-parser": "3.3.1",
     "zod": "4.4.3"
   },
   "devDependencies": {
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.0",
-    "@typescript/native-preview": "latest",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "ajv": "^8.20.0",
     "re2js": "2.8.6",
-    "typescript": "~6.0.1-rc",
-    "vitest": "^4.0.18",
+    "typescript": "~6.0.3",
+    "vitest": "^5.0.1",
     "yaml": "2.9.0"
   },
-  "peerDependencies": {
-    "typescript": "~6.0.1-rc"
-  },
   "scripts": {
     "build": "tsgo",
     "clean": "rm -rf dist",
+    "conformance": "pnpm run spec:typecheck && tsgo --noEmit -p tsconfig.types.json && node scripts/check-public-api.mjs",
     "generate:value-schema-validator": "node scripts/generate-value-schema-meta-validator.mjs",
-    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.types.json",
-    "test": "node ../node_modules/@astrale-os/codegraph/dist/cli.js verify . && vitest run",
+    "layout:check": "node scripts/check-layout.mjs",
+    "spec:typecheck": "tsgo --noEmit -p tsconfig.spec.json",
+    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.types.json && tsgo -p tsconfig.workers.json",
+    "test": "pnpm run conformance && pnpm run layout:check && vitest run",
     "test:file": "vitest run",
-    "test:semantic-lock": "node ../node_modules/@astrale-os/codegraph/dist/cli.js verify . --require-pass",
-    "test:watch": "vitest",
-    "preinstall": "node -e \"try{require('./.check-workspace.cjs')}catch{}\""
+    "test:semantic-lock": "pnpm run conformance && pnpm run layout:check && vitest run",
+    "test:watch": "vitest"
   }
 }

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}

package/dist/upgrade/contract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../upgrade/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAE7E,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACtD,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,CAAA;CACrC;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,MAAM,mBAAmB,CAAC,MAAM,SAAS,eAAe,IAC1D;IAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACxD;IAAE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAA;CAAE,GAC5E;IAAE,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAA;CAAE,CAAA;AAE/E;;;;;GAKG;AACH,MAAM,WAAW,aAAa,CAAC,MAAM,SAAS,eAAe,EAAE,MAAM,SAAS,eAAe;IAC3F,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAA;IACxC,QAAQ,CAAC,EAAE,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAA;IACtC,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,mBAAmB,CAAC,MAAM,CAAC,CAAA;CAClE"}

package/dist/upgrade/contract.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract.js","sourceRoot":"","sources":["../../upgrade/contract.ts"],"names":[],"mappings":""}

package/dist/upgrade/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../upgrade/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,aAAa,EACb,mBAAmB,EACnB,YAAY,EACZ,eAAe,GAChB,MAAM,eAAe,CAAA"}

package/dist/upgrade/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../upgrade/index.ts"],"names":[],"mappings":""}

package/dist/v1/addressing/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../v1/addressing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,EACnB,uBAAuB,EACvB,oBAAoB,EACpB,QAAQ,GACT,MAAM,eAAe,CAAA;AACtB,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAC9B,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAC9B,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA"}