@astrale-os/kernel-dsl 0.2.0-beta.47 → 0.2.0-beta.49

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.47",
+  "version": "0.2.0-beta.49",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {