@astrale-os/kernel-dsl 0.2.0-beta.46 → 0.2.0-beta.48

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

@@ -1,6 +1,7 @@
 import { Key } from '../../addressing/key.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
+import { classSatisfies as satisfiesClass, isGraphRoot } from '../../language/class/inheritance.js';
 import { admitStateTopology } from '../../language/state/topology.js';
 import { isBlobValueSchema } from '../../language/value/model/blob.js';
 import { classifyOrdering } from '../../language/value/ordering.js';
@@ -62,6 +63,15 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
                 diagnostics.push(diagnostic('DV_PROPERTY_STATE', `${propertyPointer}/state`, error instanceof Error ? error.message : 'Invalid State topology.'));
             }
         }
+        if (property.immutable !== undefined) {
+            const immutablePointer = `${propertyPointer}/immutable`;
+            if (property.auto !== undefined || property.state !== undefined) {
+                diagnostics.push(diagnostic('DV_PROPERTY_IMMUTABLE', immutablePointer, 'An immutable Property is neither automatic nor a State Property.'));
+            }
+            if (property.immutable === 'once' && property.required) {
+                diagnostics.push(diagnostic('DV_PROPERTY_IMMUTABLE', immutablePointer, 'A required immutable Property is written at creation: declare it create, not once.'));
+            }
+        }
         if (property.auto === undefined)
             continue;
         const autoPointer = `${propertyPointer}/auto`;
@@ -105,10 +115,6 @@ function validateEdgeContract(environment, owner, declaration, diagnostics) {
     validateEndpoint(environment, owner, endpoints[0], declaration.orientation === 'directed' ? 'source' : 'first endpoint', diagnostics);
     validateEndpoint(environment, owner, endpoints[1], declaration.orientation === 'directed' ? 'target' : 'second endpoint', diagnostics);
     if (declaration.orientation === 'undirected') {
-        if (!sameIncidentEndpointContract(declaration.endpoints[0], declaration.endpoints[1]) &&
-            undirectedEndpointsOverlap(environment, declaration.endpoints)) {
-            diagnostics.push(diagnostic('DV_EDGE_UNDIRECTED', '', `${formatDefinitionRef(owner)} has unequal undirected endpoint contracts whose accepted Node families overlap.`));
-        }
         if (declaration.constraints.acyclic === true) {
             diagnostics.push(diagnostic('DV_EDGE_CONSTRAINT', '', 'acyclic is valid only for directed Edge contracts.'));
         }
@@ -151,6 +157,8 @@ function validateEdgeClassComposition(environment, diagnostics) {
 }
 /** Whether `child` safely refines its parent Edge contract `parent`. */
 export function edgeContractRefines(environment, child, parent) {
+    if (isGraphRoot(parent))
+        return true;
     if (child.orientation !== parent.orientation)
         return false;
     if (parent.constraints.noSelf === true && child.constraints.noSelf !== true)
@@ -186,57 +194,18 @@ function countRefines(child, parent) {
     const [parentMinimum, parentMaximum] = bounds[parent];
     return childMinimum >= parentMinimum && childMaximum <= parentMaximum;
 }
-function sameIncidentEndpointContract(left, right) {
-    if (left.incident !== right.incident)
-        return false;
-    const a = [...left.accepts].map(definitionRefIndex).sort();
-    const b = [...right.accepts].map(definitionRefIndex).sort();
-    return a.length === b.length && a.every((value, index) => value === b[index]);
-}
-function undirectedEndpointsOverlap(environment, endpoints) {
-    for (const resolved of environment.definitions.values()) {
-        if (resolved.ref.kind !== 'class' ||
-            resolved.declaration.kind !== 'node' ||
-            resolved.declaration.abstract) {
-            continue;
-        }
-        const candidate = resolved.ref;
-        if (classSatisfies(environment, candidate, endpoints[0].accepts) &&
-            classSatisfies(environment, candidate, endpoints[1].accepts)) {
-            return true;
-        }
-    }
-    return false;
-}
 /** Whether `candidate` is, or is a Node Class extending, one of `accepts`. */
 export function classSatisfies(environment, candidate, accepts) {
     if (accepts.some((ref) => definitionRefIndex(ref) === definitionRefIndex(candidate)))
         return true;
-    const resolved = environment.resolveAny(candidate);
-    if (resolved === undefined ||
-        resolved.ref.kind !== 'class' ||
-        resolved.declaration.kind !== 'node') {
+    const resolve = (ref) => environment.resolveAny(ref)?.declaration;
+    const actual = resolve(candidate);
+    if (actual?.kind !== 'node')
         return false;
-    }
-    return extendsAny(environment, resolved.declaration.extends, accepts, new Set());
-}
-function extendsAny(environment, parents, accepts, visited) {
-    const accepted = new Set(accepts.map(definitionRefIndex));
-    for (const parent of parents) {
-        const key = definitionRefIndex(parent);
-        if (accepted.has(key))
-            return true;
-        if (visited.has(key))
-            continue;
-        visited.add(key);
-        const resolved = environment.resolveAny(parent);
-        if (resolved !== undefined &&
-            resolved.ref.kind === 'class' &&
-            extendsAny(environment, resolved.declaration.extends, accepts, visited)) {
-            return true;
-        }
-    }
-    return false;
+    return accepts.some((ref) => {
+        const required = resolve(ref);
+        return required !== undefined && satisfiesClass(actual, required, resolve);
+    });
 }
 function localRef(origin, name) {
     return { origin, kind: 'class', name };

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

@@ -4,6 +4,7 @@ import { isMethodExecutable } from '../../language/callable/executable.js';
 import { policyObjectKey, policyObjectOrigin, projectedMemberClass, } from '../../language/policy/model/policy.js';
 import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
 import { diagnostic } from '../diagnostic.js';
+import { classSatisfies } from './class.js';
 const formatDefinitionRef = Key.of;
 export function validateCore(environment, analysis, registry) {
     const diagnostics = [];
@@ -286,33 +287,6 @@ function hasDirectedCycle(edges) {
     };
     return [...outgoing.keys()].some(visit);
 }
-function classSatisfies(environment, classRef, accepts) {
-    if (accepts.some((ref) => definitionRefIndex(ref) === definitionRefIndex(classRef)))
-        return true;
-    const resolved = environment.resolveAny(classRef);
-    if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'node') {
-        return false;
-    }
-    return classExtendsAny(environment, resolved.declaration.extends, accepts, new Set());
-}
-function classExtendsAny(environment, parents, accepts, visited) {
-    const accepted = new Set(accepts.map(definitionRefIndex));
-    for (const parent of parents) {
-        const key = definitionRefIndex(parent);
-        if (accepted.has(key))
-            return true;
-        if (visited.has(key))
-            continue;
-        visited.add(key);
-        const resolved = environment.resolveAny(parent);
-        if (resolved !== undefined &&
-            resolved.ref.kind === 'class' &&
-            classExtendsAny(environment, resolved.declaration.extends, accepts, visited)) {
-            return true;
-        }
-    }
-    return false;
-}
 function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }

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

@@ -3,9 +3,10 @@ import type { DomainSchemaLookup } from '../dependency/lookup.js';
 import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainSchemaIR } from '../model/schema.js';
 import type { DomainResolutionContext } from '../resolution/context.js';
-export interface DomainSchemaValidation {
+interface DomainSchemaValidation {
     readonly context: DomainResolutionContext;
     readonly analysis: DefinitionAnalysisResult;
     readonly diagnostics: readonly SchemaDiagnostic[];
 }
 export declare function validateDomainSchemaSemantics(schema: DomainSchemaIR, lookup: DomainSchemaLookup): DomainSchemaValidation;
+export {};

package/dist/v1/schema/validation/domain.structure.d.ts

@@ -1,4 +1,2 @@
-import { type ZodType } from 'zod';
 import type { DomainSchemaIR } from '../model/schema.js';
-export declare const domainSchemaStructuralSchema: ZodType<DomainSchemaIR>;
 export declare function parseDomainSchemaStructure(input: unknown): DomainSchemaIR;

package/dist/v1/schema/validation/domain.structure.js

@@ -17,6 +17,10 @@ const descriptionSchema = string()
     .min(metadata.description.minLength)
     .max(metadata.description.maxLength);
 const iconSchema = string().min(metadata.icon.minLength).max(metadata.icon.maxLength);
+const domainNameSchema = string()
+    .min(metadata.name.minLength)
+    .max(metadata.name.maxLength)
+    .refine(metadata.isDomainNameText, 'Expected one trimmed line of text.');
 const jsonValueSchema = lazy(() => union([
     nullSchema(),
     boolean(),
@@ -43,6 +47,7 @@ const propertyDefinitionSchema = strictObject({
         on: uniqueArray(enumeration(['create', 'update'])).min(1),
         set: literal('instant'),
     }).optional(),
+    immutable: enumeration(['create', 'once']).optional(),
     description: descriptionSchema.optional(),
     state: stateTopologySchema.optional(),
 });
@@ -291,13 +296,7 @@ const policyDefinitionSchema = strictObject({
     expression: policyExpressionSchema,
     description: descriptionSchema.optional(),
 });
-const viewTargetSchema = discriminatedUnion('kind', [
-    strictObject({ kind: literal('domain') }),
-    strictObject({
-        kind: literal('definition'),
-        definitions: uniqueArray(classRefSchema).min(1),
-    }),
-]);
+const viewTargetSchema = strictObject({ kind: literal('domain') });
 const viewDefinitionSchema = strictObject({
     ref: viewRefSchema,
     description: descriptionSchema.optional(),
@@ -322,6 +321,8 @@ const structuralSchema = strictObject({
     format: literal(DOMAIN_FORMAT),
     version: literal(DOMAIN_VERSION),
     origin: originSchema,
+    name: domainNameSchema,
+    entrypoint: viewRefSchema.optional(),
     dependencies: record(dependencyAliasSchema, domainDependencySchema),
     classes: record(memberNameSchema, classDeclarationSchema),
     functions: record(memberNameSchema, functionDefinitionSchema),
@@ -329,7 +330,7 @@ const structuralSchema = strictObject({
     views: record(memberNameSchema, viewDefinitionSchema),
     core: coreSchema,
 });
-export const domainSchemaStructuralSchema = structuralSchema;
+const domainSchemaStructuralSchema = structuralSchema;
 export function parseDomainSchemaStructure(input) {
     const result = domainSchemaStructuralSchema.safeParse(input);
     if (result.success)

package/dist/v1/schema/validation/policy/context.js

@@ -1,5 +1,6 @@
 import { Key } from '../../../addressing/index.js';
 import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { classSatisfies } from '../../../language/class/inheritance.js';
 import { diagnostic } from '../../diagnostic.js';
 const formatDefinitionRef = Key.of;
 export class PolicyValidationContext {
@@ -63,22 +64,10 @@ export class PolicyValidationContext {
     }
     /** Return true when candidate is the required Class or a same-kind descendant. */
     classExtends(candidate, required) {
-        if (definitionRefIndex(candidate) === definitionRefIndex(required))
-            return true;
-        const visited = new Set();
-        const visit = (ref) => {
-            const key = definitionRefIndex(ref);
-            if (key === definitionRefIndex(required))
-                return true;
-            if (visited.has(key))
-                return false;
-            visited.add(key);
-            const resolved = this.environment.resolveAny(ref);
-            if (resolved === undefined || resolved.ref.kind !== 'class')
-                return false;
-            return resolved.declaration.extends.some(visit);
-        };
-        return visit(candidate);
+        const resolve = (ref) => this.environment.resolveAny(ref)?.declaration;
+        const actual = resolve(candidate);
+        const target = resolve(required);
+        return actual !== undefined && target !== undefined && classSatisfies(actual, target, resolve);
     }
     add(code, pointer, message, ref) {
         this.diagnostics.push(diagnostic(code, pointer, message, ref));

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

@@ -9,21 +9,26 @@ export function validateViews(environment) {
         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));
-        }
     }
+    validateEntrypoint(environment, diagnostics);
     return Object.freeze(diagnostics);
 }
+/** The entrypoint names one View this Domain declares for itself. */
+function validateEntrypoint(environment, diagnostics) {
+    const { entrypoint, origin, views } = environment.candidate;
+    if (entrypoint === undefined)
+        return;
+    // An own member only: a name such as `constructor` must not resolve on the prototype.
+    const view = entrypoint.origin === origin && Object.hasOwn(views, entrypoint.name)
+        ? views[entrypoint.name]
+        : undefined;
+    if (view === undefined) {
+        diagnostics.push(diagnostic('DV_ENTRYPOINT', '/entrypoint', `Entrypoint ${formatDefinitionRef(entrypoint)} is not a Domain-targeted View of ${origin}.`, formatDefinitionRef(entrypoint)));
+    }
+}
 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/value/accept.d.ts

@@ -6,7 +6,7 @@ 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;
-/** Admit unknown data into a deeply immutable snapshot; owned subtrees may be shared. */
+/** Admit a canonically byte-bounded 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;

package/dist/value/accept.js

@@ -1,7 +1,7 @@
 import { BoundaryError } from './error.js';
 import { includeSnapshot, retainImmutableSnapshot, reusableSnapshot, } from './immutable.optimization.js';
 import { limitsFor } from './limits.js';
-import { assertHostString } from './unicode.js';
+import { assertHostString, canonicalPrimitiveBytes } from './unicode.js';
 /**
  * Admit an unknown host value and return a detached portable snapshot.
  *
@@ -10,7 +10,7 @@ import { assertHostString } from './unicode.js';
 export function accept(input, options) {
     return snapshot(input, options, 'copy');
 }
-/** Admit unknown data into a deeply immutable snapshot; owned subtrees may be shared. */
+/** Admit a canonically byte-bounded immutable snapshot; owned subtrees may be shared. */
 export function acceptImmutable(input, options) {
     const captured = { propertyRoots: false };
     const value = snapshot(input, options, 'immutable', captured);
@@ -35,9 +35,10 @@ function snapshot(input, options, mode, captured) {
         active: new WeakSet(),
         limits: limitsFor(options),
         members: 0,
+        bytes: mode === 'immutable' && !captured?.propertyRoots ? 0 : undefined,
         mode,
         summary: mode === 'immutable' && !captured?.propertyRoots
-            ? { members: 0, depth: 0, stringBytes: 0 }
+            ? { members: 0, depth: 0, stringBytes: 0, canonicalBytes: 0 }
             : undefined,
         summaryDepth: 0,
         propertyRoots: captured?.propertyRoots ?? false,
@@ -55,8 +56,10 @@ function snapshot(input, options, mode, captured) {
     }
 }
 function admit(input, pointer, depth, state) {
-    if (input === null || typeof input === 'boolean')
+    if (input === null || typeof input === 'boolean') {
+        addCanonicalBytes(state, input === false ? 5 : 4, pointer);
         return input;
+    }
     if (typeof input === 'number') {
         if (!Number.isFinite(input)) {
             throw new BoundaryError('VALUE_NUMBER', 'Expected a finite IEEE-754 binary64 number', pointer);
@@ -64,6 +67,8 @@ function admit(input, pointer, depth, state) {
         if (Object.is(input, -0)) {
             throw new BoundaryError('VALUE_NUMBER', 'Negative zero is outside portable JSON', pointer);
         }
+        if (state.summary !== undefined || state.bytes !== undefined)
+            addCanonicalBytes(state, canonicalPrimitiveBytes(input), pointer);
         return input;
     }
     if (typeof input === 'string') {
@@ -74,9 +79,10 @@ function admit(input, pointer, depth, state) {
         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);
+        const summary = reusableSnapshot(input, state.limits, depth, state.members, state.bytes);
         if (summary !== undefined) {
             state.members += summary.members;
+            chargeCanonicalBytes(state, summary.canonicalBytes, pointer);
             includeSnapshot(state.summary, summary, depth - state.summaryDepth);
             return input;
         }
@@ -92,7 +98,7 @@ function admit(input, pointer, depth, state) {
     const parentDepth = state.summaryDepth;
     const propertyRoot = state.mode === 'immutable' && state.propertyRoots && depth === 1;
     if (propertyRoot) {
-        state.summary = { members: 0, depth: 0, stringBytes: 0 };
+        state.summary = { members: 0, depth: 0, stringBytes: 0, canonicalBytes: 0 };
         state.summaryDepth = depth;
     }
     if (state.summary !== undefined) {
@@ -129,6 +135,9 @@ function admitArray(input, pointer, depth, state) {
     if (keys.length !== size + 1 || keys.some((key) => typeof key === 'symbol')) {
         throw new BoundaryError('VALUE_ARRAY', 'Expected a dense Array with no symbol or non-index properties', pointer);
     }
+    // Every portable item needs at least one byte; refuse before the detached Array allocation.
+    requireCanonicalRoom(state, size === 0 ? 2 : size * 2 + 1, pointer);
+    addCanonicalBytes(state, 2 + Math.max(0, size - 1), pointer);
     const output = Array.from({ length: size }, () => null);
     for (let index = 0; index < size; index += 1) {
         const name = String(index);
@@ -151,6 +160,7 @@ function admitObject(input, pointer, depth, state) {
     const descriptors = reflect(() => Object.getOwnPropertyDescriptors(input), pointer, 'Cannot snapshot Object descriptors');
     const keys = Reflect.ownKeys(descriptors);
     addMembers(state, keys.length, pointer);
+    addCanonicalBytes(state, 2 + Math.max(0, keys.length - 1) + keys.length, pointer);
     const output = {};
     for (const key of keys) {
         if (typeof key === 'symbol') {
@@ -191,6 +201,22 @@ function admitString(value, pointer, state) {
     if (state.summary !== undefined) {
         state.summary.stringBytes = Math.max(state.summary.stringBytes, bytes);
     }
+    if (state.summary !== undefined || state.bytes !== undefined)
+        addCanonicalBytes(state, canonicalPrimitiveBytes(value), pointer);
+}
+function requireCanonicalRoom(state, bytes, pointer) {
+    if (state.bytes !== undefined && bytes > state.limits.maxBytes - state.bytes)
+        throw new BoundaryError('VALUE_LIMIT', `Canonical JSON exceeds the ${state.limits.maxBytes}-byte limit`, pointer);
+}
+function chargeCanonicalBytes(state, bytes, pointer) {
+    requireCanonicalRoom(state, bytes, pointer);
+    if (state.bytes !== undefined)
+        state.bytes += bytes;
+}
+function addCanonicalBytes(state, bytes, pointer) {
+    chargeCanonicalBytes(state, bytes, pointer);
+    if (state.summary !== undefined)
+        state.summary.canonicalBytes += bytes;
 }
 function reflect(operation, pointer, message) {
     try {

package/dist/value/canonical.js

@@ -1,7 +1,8 @@
 import { acceptForRead } from './accept.js';
 import { BoundaryError } from './error.js';
+import { immutableSnapshotBytes } from './immutable.optimization.js';
 import { defaultLimits, limitsFor } from './limits.js';
-import { utf8Length } from './unicode.js';
+import { canonicalPrimitiveBytes, utf8Length } from './unicode.js';
 const encoder = new TextEncoder();
 /** RFC 8785 canonical JSON for one admitted portable snapshot. */
 export function serialize(input, options) {
@@ -13,9 +14,16 @@ export function serializeAdmitted(input) {
     return serializeSnapshot(input, defaultLimits.maxBytes);
 }
 function serializeSnapshot(input, maxBytes) {
+    const bytes = input !== null && typeof input === 'object'
+        ? immutableSnapshotBytes(input)
+        : canonicalPrimitiveBytes(input);
+    if (bytes !== undefined && bytes > maxBytes)
+        throw new BoundaryError('VALUE_LIMIT', `Canonical JSON exceeds the ${maxBytes}-byte limit`);
     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) {
+    if (bytes === undefined &&
+        output.length > maxBytes / 3 &&
+        utf8Length(output, maxBytes) > maxBytes) {
         throw new BoundaryError('VALUE_LIMIT', `Canonical JSON exceeds the ${maxBytes}-byte limit`);
     }
     return output;

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

@@ -3,10 +3,13 @@ export interface SnapshotSummary {
     members: number;
     depth: number;
     stringBytes: number;
+    canonicalBytes: number;
 }
 export declare function isImmutableSnapshot(value: object): boolean;
+/** Exact complete representation size, only for roots retained by this admission owner. */
+export declare function immutableSnapshotBytes(value: object): number | undefined;
 /** 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;
+export declare function reusableSnapshot(value: object, limits: Limits, depth: number, members: number, bytes: number | undefined): SnapshotSummary | undefined;

package/dist/value/immutable.optimization.js

@@ -4,6 +4,10 @@ const snapshots = new WeakMap();
 export function isImmutableSnapshot(value) {
     return snapshots.has(value);
 }
+/** Exact complete representation size, only for roots retained by this admission owner. */
+export function immutableSnapshotBytes(value) {
+    return snapshots.get(value)?.canonicalBytes;
+}
 /** Called only after admission has constructed and deeply frozen this container. */
 export function retainImmutableSnapshot(value, summary) {
     if (!snapshots.has(value))
@@ -15,14 +19,16 @@ export function includeSnapshot(parent, child, depth) {
     parent.members += child.members;
     parent.depth = Math.max(parent.depth, depth + child.depth);
     parent.stringBytes = Math.max(parent.stringBytes, child.stringBytes);
+    parent.canonicalBytes += child.canonicalBytes;
 }
 /** A failed fit must use normal admission, preserving its exact error pointer. */
-export function reusableSnapshot(value, limits, depth, members) {
+export function reusableSnapshot(value, limits, depth, members, bytes) {
     const summary = snapshots.get(value);
     if (summary === undefined ||
         summary.members > limits.maxMembers - members ||
         summary.depth > limits.maxDepth - depth ||
-        summary.stringBytes > limits.maxStringBytes)
+        summary.stringBytes > limits.maxStringBytes ||
+        (bytes !== undefined && summary.canonicalBytes > limits.maxBytes - bytes))
         return undefined;
     return summary;
 }

package/dist/value/limits.d.ts

@@ -1,5 +1,5 @@
 export interface Limits {
-    /** Maximum UTF-8 size accepted from or emitted to a wire boundary. */
+    /** Maximum wire UTF-8 size, also bounding the complete canonical immutable capture. */
     readonly maxBytes: number;
     /** Maximum number of nested Array/Object containers, with a root container at depth one. */
     readonly maxDepth: number;

package/dist/value/unicode.d.ts

@@ -1,3 +1,6 @@
+import type { Primitive } from './types.js';
+/** Exact canonical scalar spelling after the same owner has established portable input. */
+export declare function canonicalPrimitiveBytes(value: Primitive): number;
 export declare function utf8Length(value: string, max?: number): number;
 export declare function assertHostString(value: string, pointer: string, maxBytes: number): number;
 export declare function assertDecodedString(value: string, offset: number, maxBytes: number): void;

package/dist/value/unicode.js

@@ -1,4 +1,31 @@
 import { BoundaryError, DecodeError } from './error.js';
+/** Exact canonical scalar spelling after the same owner has established portable input. */
+export function canonicalPrimitiveBytes(value) {
+    if (typeof value !== 'string') {
+        if (typeof value === 'number')
+            return JSON.stringify(value).length;
+        return value === false ? 5 : 4;
+    }
+    let bytes = 2;
+    for (let index = 0; index < value.length; index += 1) {
+        const unit = value.charCodeAt(index);
+        if (unit < 0x20)
+            bytes += unit === 8 || unit === 9 || unit === 10 || unit === 12 || unit === 13 ? 2 : 6;
+        else if (unit === 0x22 || unit === 0x5c)
+            bytes += 2;
+        else if (unit <= 0x7f)
+            bytes += 1;
+        else if (unit <= 0x7ff)
+            bytes += 2;
+        else if (isHighSurrogate(unit)) {
+            bytes += 4;
+            index += 1;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
 export function utf8Length(value, max = Number.MAX_SAFE_INTEGER) {
     let bytes = 0;
     for (let index = 0; index < value.length; index += 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.46",
+  "version": "0.2.0-beta.48",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {