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

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

@@ -0,0 +1,258 @@
+import { Key } from '../../../addressing/index.js';
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { normalizePolicyChecks } from '../../../language/policy/normalization/normalize.js';
+import { GRAPH_NODE_PATH_SCHEMA_ID } from '../../../language/value/syntax/node-path/schema.js';
+import { MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, measureChecks } from './budgets.js';
+import { escapePointer } from './context.js';
+import { contractOfNodeDefinition } from './typing.js';
+const formatDefinitionRef = Key.of;
+const KERNEL_ORIGIN = 'kernel.astrale.ai';
+const PROJECTION_CLASS = nodeClassRef('Class');
+const PROJECTION_FUNCTION = nodeClassRef('Function');
+const PROJECTION_POLICY = nodeClassRef('Policy');
+const PROJECTION_VIEW = nodeClassRef('View');
+export function validateReadUses(context, typing) {
+    for (const [name, declaration] of Object.entries(context.environment.candidate.classes)) {
+        if (declaration.kind !== 'node' || declaration.policies.read === undefined) {
+            continue;
+        }
+        const pointer = `/classes/${escapePointer(name)}/policies/read`;
+        const ref = declaration.policies.read;
+        if (!context.resolvePolicy(ref, pointer))
+            continue;
+        const object = {
+            kind: 'exact',
+            ref: { origin: context.environment.candidate.origin, kind: 'class', name },
+        };
+        if (!typing.policyAccepts(ref.name, object)) {
+            context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every normalized branch of protected Class ${name}.`, formatDefinitionRef(ref));
+        }
+    }
+}
+export function validateTraverseUses(context, typing) {
+    for (const [name, declaration] of Object.entries(context.environment.candidate.classes)) {
+        const ref = declaration.policies.traverse;
+        if (ref === undefined)
+            continue;
+        const pointer = `/classes/${escapePointer(name)}/policies/traverse`;
+        if (!context.resolvePolicy(ref, pointer))
+            continue;
+        if (declaration.kind === 'node') {
+            const object = {
+                kind: 'exact',
+                ref: { origin: context.environment.candidate.origin, kind: 'class', name },
+            };
+            if (!typing.policyAccepts(ref.name, object)) {
+                context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every normalized branch of traversed Node Class ${name}.`, formatDefinitionRef(ref));
+            }
+            continue;
+        }
+        const endpoints = declaration.orientation === 'directed'
+            ? [declaration.endpoints.source, declaration.endpoints.target]
+            : declaration.endpoints;
+        const sources = typing.concreteEndpointClasses(endpoints[0].accepts);
+        const targets = typing.concreteEndpointClasses(endpoints[1].accepts);
+        let accepted = true;
+        for (const source of sources) {
+            for (const target of targets) {
+                if (!typing.policyAcceptsEdge(ref.name, { kind: 'exact', ref: source }, { kind: 'exact', ref: target })) {
+                    accepted = false;
+                    break;
+                }
+            }
+            if (!accepted)
+                break;
+        }
+        if (!accepted) {
+            context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every concrete source/target pair of traversed Edge Class ${name}.`, formatDefinitionRef(ref));
+        }
+    }
+}
+export function validateCallableUses(context, typing) {
+    for (const [name, declaration] of Object.entries(context.environment.candidate.functions)) {
+        if (declaration.policy === undefined)
+            continue;
+        validateChecks(context, typing, declaration.policy, {
+            pointer: `/functions/${escapePointer(name)}/policy`,
+            input: declaration.input,
+            instanceMethod: false,
+        });
+    }
+    for (const [name, declaration] of Object.entries(context.environment.candidate.classes)) {
+        if (declaration.kind !== 'node')
+            continue;
+        validateDeclaredMethods(context, typing, 'classes', name, declaration.methods, {
+            origin: context.environment.candidate.origin,
+            kind: 'class',
+            name,
+        });
+    }
+}
+function validateDeclaredMethods(context, typing, namespace, name, methods, receiver) {
+    const ownerAnalysis = context.analysis.definitions.get(definitionRefIndex(receiver));
+    for (const [methodName, method] of Object.entries(methods)) {
+        if (method.policy === undefined)
+            continue;
+        // Definition analysis is the authority for the effective callable. A
+        // missing entry is already a definition diagnostic, so avoid inventing a
+        // second Policy interpretation for it.
+        if (ownerAnalysis !== undefined && !ownerAnalysis.methods.has(methodName))
+            continue;
+        validateChecks(context, typing, method.policy, {
+            pointer: `/${namespace}/${escapePointer(name)}/methods/${escapePointer(methodName)}/policy`,
+            input: method.input,
+            receiver,
+            instanceMethod: !method.static,
+        });
+    }
+}
+function validateChecks(validation, typing, expression, context) {
+    const normalized = normalizePolicyChecks(expression);
+    const measure = measureChecks(normalized);
+    if (measure.depth > MAX_CHECK_DEPTH ||
+        measure.branches > MAX_BRANCHES ||
+        measure.leaves > MAX_CHECK_LEAVES) {
+        validation.add('PL_BUDGET', context.pointer, `Callable checks require depth <= ${MAX_CHECK_DEPTH}, branches <= ${MAX_BRANCHES}, and leaves <= ${MAX_CHECK_LEAVES}; got ${measure.depth}, ${measure.branches}, ${measure.leaves}.`);
+    }
+    visitChecks(validation, typing, normalized, context, context.pointer);
+}
+function visitChecks(validation, typing, expression, context, pointer) {
+    if ('check' in expression) {
+        if (!validation.resolvePolicy(expression.check, `${pointer}/check`))
+            return;
+        const objectPointer = `${pointer}/object`;
+        const contracts = expression.object.kind === 'self'
+            ? selfContracts(validation, context, objectPointer)
+            : expression.object.kind === 'input'
+                ? inputContracts(validation, context, expression.object.field, objectPointer)
+                : referenceContracts(validation, expression.object.ref, objectPointer);
+        if (contracts === undefined)
+            return;
+        for (const contract of contracts) {
+            if (!typing.policyAccepts(expression.check.name, contract)) {
+                validation.add('PL_USE', pointer, `${formatDefinitionRef(expression.check)} is incompatible with the callable object contract.`, formatDefinitionRef(expression.check));
+                break;
+            }
+        }
+        return;
+    }
+    const { key, values } = checkOperands(expression);
+    if (values.length === 0) {
+        validation.add('PL_COMPOSITION', `${pointer}/${key}`, `${key} must be non-empty.`);
+    }
+    values.forEach((child, index) => visitChecks(validation, typing, child, context, `${pointer}/${key}/${index}`));
+}
+function referenceContracts(validation, ref, pointer) {
+    const candidate = validation.environment.candidate;
+    if (ref.origin !== candidate.origin)
+        return invalidPolicyObjectRef(validation, ref, pointer);
+    switch (ref.kind) {
+        case 'class': {
+            const resolved = validation.environment.resolve(ref);
+            return resolved?.ref.kind === ref.kind
+                ? [{ kind: 'exact', ref: PROJECTION_CLASS }]
+                : invalidPolicyObjectRef(validation, ref, pointer);
+        }
+        case 'function':
+            return candidate.functions[ref.name] === undefined
+                ? invalidPolicyObjectRef(validation, ref, pointer)
+                : [{ kind: 'exact', ref: PROJECTION_FUNCTION }];
+        case 'policy':
+            return candidate.policies[ref.name] === undefined
+                ? invalidPolicyObjectRef(validation, ref, pointer)
+                : [{ kind: 'exact', ref: PROJECTION_POLICY }];
+        case 'view':
+            return candidate.views[ref.name] === undefined
+                ? invalidPolicyObjectRef(validation, ref, pointer)
+                : [{ kind: 'exact', ref: PROJECTION_VIEW }];
+        case 'core': {
+            const node = candidate.core.nodes[ref.name];
+            if (node === undefined)
+                return invalidPolicyObjectRef(validation, ref, pointer);
+            const resolved = validation.environment.resolve(node.class);
+            const analyzed = validation.analysis.definitions.get(definitionRefIndex(node.class));
+            // Core validation owns invalid Core Class diagnostics. Avoid adding Policy noise for
+            // a Node that cannot materialize in the first place.
+            if (node.class.origin !== candidate.origin ||
+                resolved?.ref.kind !== 'class' ||
+                resolved.kind !== 'node' ||
+                analyzed === undefined) {
+                return undefined;
+            }
+            return [contractOfNodeDefinition(node.class)];
+        }
+    }
+    return invalidPolicyObjectRef(validation, ref, pointer);
+}
+function invalidPolicyObjectRef(validation, ref, pointer) {
+    validation.add('PL_REF', `${pointer}/ref`, `${formatDefinitionRef(ref)} is not an exact local projected Policy object.`, formatDefinitionRef(ref));
+    return undefined;
+}
+function selfContracts(validation, context, pointer) {
+    if (!context.instanceMethod || context.receiver === undefined) {
+        validation.add('PL_USE', pointer, 'self is valid only for a Node instance Method.');
+        return undefined;
+    }
+    return [contractOfNodeDefinition(context.receiver)];
+}
+function inputContracts(validation, context, field, pointer) {
+    const input = asRecord(context.input);
+    const properties = asRecord(input?.properties);
+    const fieldSchema = asRecord(properties?.[field]);
+    const required = input?.required;
+    const rootValid = input?.type === 'object' &&
+        properties !== undefined &&
+        Array.isArray(required) &&
+        required.includes(field) &&
+        input.additionalProperties === false &&
+        !hasCombinator(input);
+    const annotation = asRecord(fieldSchema?.['x-astrale-path']);
+    const fieldValid = rootValid &&
+        fieldSchema?.$ref === GRAPH_NODE_PATH_SCHEMA_ID &&
+        !hasCombinator(fieldSchema) &&
+        annotation?.target === 'node' &&
+        annotation.cardinality === 'one' &&
+        Array.isArray(annotation.accepts) &&
+        annotation.accepts.length > 0;
+    if (!fieldValid) {
+        validation.add('PL_USE', pointer, `input.${field} must be one direct required single-Node x-astrale-path field of a closed object input.`);
+        return undefined;
+    }
+    const contracts = [];
+    for (const ref of annotation.accepts) {
+        if (!isDefinitionRef(ref)) {
+            validation.add('PL_USE', pointer, `input.${field} has a non-Node acceptance ref.`);
+            return undefined;
+        }
+        const resolved = validation.environment.resolve(ref);
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'node') {
+            validation.add('PL_USE', pointer, `input.${field} ref ${formatDefinitionRef(ref)} does not resolve as an allowed Node Definition.`, formatDefinitionRef(ref));
+            return undefined;
+        }
+        contracts.push(contractOfNodeDefinition(ref));
+    }
+    return contracts;
+}
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function hasCombinator(value) {
+    return ['allOf', 'anyOf', 'oneOf', 'not', 'if', 'then', 'else'].some((key) => Object.hasOwn(value, key));
+}
+function isDefinitionRef(value) {
+    const record = asRecord(value);
+    return (record !== undefined &&
+        typeof record.origin === 'string' &&
+        record.kind === 'class' &&
+        typeof record.name === 'string');
+}
+function checkOperands(value) {
+    return 'allOf' in value
+        ? { key: 'allOf', values: value.allOf }
+        : { key: 'anyOf', values: value.anyOf };
+}
+function nodeClassRef(name) {
+    return { origin: KERNEL_ORIGIN, kind: 'class', name };
+}

package/dist/v1/schema/validation/policy/validate.d.ts

@@ -0,0 +1,11 @@
+import type { DefinitionAnalysisResult } from '../../analysis/class.js';
+import type { SchemaDiagnostic } from '../../diagnostic.js';
+import type { DomainResolutionContext } from '../../resolution/context.js';
+/**
+ * Validates the closed V1 Policy language after structural parsing.
+ *
+ * This pass is deliberately backend-independent and never throws for semantic
+ * failure. Environment and definition diagnostics are owned by their respective
+ * validators and are therefore not repeated here.
+ */
+export declare function validatePolicies(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult): readonly SchemaDiagnostic[];

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

@@ -0,0 +1,23 @@
+import { validatePolicyBudgets } from './budgets.js';
+import { PolicyValidationContext } from './context.js';
+import { validatePolicyReferences } from './references.js';
+import { PolicyTyping } from './typing.js';
+import { validateCallableUses, validateReadUses, validateTraverseUses } from './uses.js';
+/**
+ * Validates the closed V1 Policy language after structural parsing.
+ *
+ * This pass is deliberately backend-independent and never throws for semantic
+ * failure. Environment and definition diagnostics are owned by their respective
+ * validators and are therefore not repeated here.
+ */
+export function validatePolicies(environment, analysis) {
+    const context = new PolicyValidationContext(environment, analysis);
+    validatePolicyReferences(context);
+    validatePolicyBudgets(context);
+    const typing = new PolicyTyping(context);
+    typing.validatePolicies();
+    validateReadUses(context, typing);
+    validateTraverseUses(context, typing);
+    validateCallableUses(context, typing);
+    return Object.freeze(context.diagnostics);
+}

package/dist/v1/schema/validation/value-api.d.ts

@@ -0,0 +1,13 @@
+/** The exact V1 value-schema grammar embedded in DomainSchema declarations. */
+import type { Diagnostic } from '../../language/validation/diagnostic.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { OrderingKind } from '../../language/value/ordering.js';
+import type { DomainSchema } from '../model/schema.js';
+export { VALUE_SCHEMA_DIALECT as DIALECT, VALUE_SCHEMA_VOCABULARY as VOCABULARY, } from '../../language/value/model/schema.js';
+export type { JsonSchema as Schema, JsonSchemaObject as SchemaObject, PathAnnotation, PropertyObjectSchema as PropertySchema, ValueSchemaContext as Context, } from '../../language/value/model/schema.js';
+export { instant } from '../../language/value/model/instant.js';
+export type { OrderingKind } from '../../language/value/ordering.js';
+/** Validate one complete JSON value under the exact accepted schema that owns the contract. */
+export declare function validate(owner: DomainSchema, contract: JsonSchema, input: unknown, pointer?: string): readonly Diagnostic[];
+/** Return the one portable scalar ordering domain admitted by a property schema, if any. */
+export declare function classifyOrdering(owner: DomainSchema, contract: JsonSchema): OrderingKind | undefined;

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

@@ -0,0 +1,23 @@
+/** The exact V1 value-schema grammar embedded in DomainSchema declarations. */
+import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
+import { classifyOrdering as classifyOrderingWithRegistry } from '../../language/value/ordering.js';
+import { createDomainValueSchemaRegistry } from '../resolution/value.registry.js';
+const registries = new WeakMap();
+export { VALUE_SCHEMA_DIALECT as DIALECT, VALUE_SCHEMA_VOCABULARY as VOCABULARY, } from '../../language/value/model/schema.js';
+export { instant } from '../../language/value/model/instant.js';
+/** Validate one complete JSON value under the exact accepted schema that owns the contract. */
+export function validate(owner, contract, input, pointer = '') {
+    return validateJsonInstance(contract, input, registryFor(owner), pointer);
+}
+/** Return the one portable scalar ordering domain admitted by a property schema, if any. */
+export function classifyOrdering(owner, contract) {
+    return classifyOrderingWithRegistry(contract, registryFor(owner));
+}
+function registryFor(owner) {
+    let registry = registries.get(owner);
+    if (registry === undefined) {
+        registry = createDomainValueSchemaRegistry(owner);
+        registries.set(owner, registry);
+    }
+    return registry;
+}

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

@@ -0,0 +1,4 @@
+import type { ValueSchemaRegistry } from '../../language/value/reference/registry.js';
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainSchemaIR } from '../model/schema.js';
+export declare function validateEmbeddedValueSchemas(schema: DomainSchemaIR, registry: ValueSchemaRegistry): readonly SchemaDiagnostic[];

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

@@ -0,0 +1,39 @@
+import { validateValueSchema } from '../../language/value/profile/validate.js';
+import { diagnostic } from '../diagnostic.js';
+export function validateEmbeddedValueSchemas(schema, registry) {
+    const diagnostics = [];
+    for (const [name, declaration] of Object.entries(schema.classes)) {
+        validateDefinition(declaration, `/classes/${escapePointer(name)}`, registry, diagnostics);
+    }
+    for (const [name, declaration] of Object.entries(schema.functions)) {
+        validateCallable(declaration, `/functions/${escapePointer(name)}`, registry, diagnostics);
+    }
+    return Object.freeze(diagnostics);
+}
+function validateDefinition(declaration, pointer, 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);
+        }
+    }
+}
+function validateCallable(declaration, pointer, registry, diagnostics) {
+    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);
+    }
+    else if (declaration.output.mode === 'stream') {
+        validate(declaration.output.item, 'callable-output', `${pointer}/output/item`, registry, diagnostics);
+    }
+}
+function validate(schema, context, pointer, registry, diagnostics) {
+    for (const failure of validateValueSchema(schema, context, registry, pointer)) {
+        diagnostics.push(diagnostic('DV_VALUE_SCHEMA', failure.pointer, `[${failure.code}] ${failure.message}`, failure.ref));
+    }
+}
+function escapePointer(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

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

@@ -0,0 +1,2 @@
+/** Source facade for the governing V1 module. */
+export * from './v1/index.js';

package/dist/v1.js

@@ -0,0 +1,2 @@
+/** Source facade for the governing V1 module. */
+export * from './v1/index.js';

package/dist/value/accept.d.ts

@@ -0,0 +1,8 @@
+import type { Value } from './types.js';
+import { type Options } from './limits.js';
+/**
+ * Admit an unknown host value and return a detached portable snapshot.
+ *
+ * Every source property is obtained from one descriptor snapshot. Accessors are never invoked.
+ */
+export declare function accept(input: unknown, options?: Options): Value;

package/dist/value/accept.js

@@ -0,0 +1,132 @@
+import { BoundaryError } from './error.js';
+import { limitsFor } from './limits.js';
+import { assertHostString } from './unicode.js';
+/**
+ * Admit an unknown host value and return a detached portable snapshot.
+ *
+ * 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 };
+    try {
+        return admit(input, '', 0, state);
+    }
+    catch (error) {
+        if (error instanceof BoundaryError)
+            throw error;
+        throw new BoundaryError('VALUE_REFLECTION', 'Host reflection failed while admitting a portable value', '', { cause: error });
+    }
+}
+function admit(input, pointer, depth, state) {
+    if (input === null || typeof input === 'boolean')
+        return input;
+    if (typeof input === 'number') {
+        if (!Number.isFinite(input)) {
+            throw new BoundaryError('VALUE_NUMBER', 'Expected a finite IEEE-754 binary64 number', pointer);
+        }
+        if (Object.is(input, -0)) {
+            throw new BoundaryError('VALUE_NUMBER', 'Negative zero is outside portable JSON', pointer);
+        }
+        return input;
+    }
+    if (typeof input === 'string') {
+        assertHostString(input, pointer, state.limits.maxStringBytes);
+        return input;
+    }
+    if (typeof input !== 'object') {
+        throw new BoundaryError('VALUE_TYPE', 'Expected a portable value', pointer);
+    }
+    if (state.active.has(input)) {
+        throw new BoundaryError('VALUE_CYCLE', 'Cyclic object graphs are not portable values', pointer);
+    }
+    if (depth >= state.limits.maxDepth) {
+        throw new BoundaryError('VALUE_LIMIT', `Container depth exceeds the ${state.limits.maxDepth}-level limit`, pointer);
+    }
+    state.active.add(input);
+    try {
+        return reflect(() => Array.isArray(input), pointer, 'Cannot inspect the host value brand')
+            ? admitArray(input, pointer, depth + 1, state)
+            : admitObject(input, pointer, depth + 1, state);
+    }
+    finally {
+        state.active.delete(input);
+    }
+}
+function admitArray(input, pointer, depth, state) {
+    const descriptors = reflect(() => Object.getOwnPropertyDescriptors(input), pointer, 'Cannot snapshot Array descriptors');
+    const keys = Reflect.ownKeys(descriptors);
+    const length = descriptorValue(descriptors, 'length');
+    if (!Number.isSafeInteger(length) || length < 0) {
+        throw new BoundaryError('VALUE_ARRAY', 'Expected a valid Array length', pointer);
+    }
+    const size = length;
+    addMembers(state, size, pointer);
+    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);
+    }
+    const output = Array.from({ length: size }, () => null);
+    for (let index = 0; index < size; index += 1) {
+        const name = String(index);
+        const descriptor = ownDescriptor(descriptors, name);
+        if (descriptor === undefined || !descriptor.enumerable || !('value' in descriptor)) {
+            throw new BoundaryError('VALUE_ARRAY', 'Array elements must be enumerable data properties', child(pointer, name));
+        }
+        output[index] = admit(descriptor.value, child(pointer, name), depth, state);
+    }
+    return output;
+}
+function admitObject(input, pointer, depth, state) {
+    const prototype = reflect(() => Object.getPrototypeOf(input), pointer, 'Cannot inspect Object prototype');
+    if (prototype !== null) {
+        const parent = reflect(() => Object.getPrototypeOf(prototype), pointer, 'Cannot inspect Object prototype chain');
+        if (parent !== null) {
+            throw new BoundaryError('VALUE_OBJECT', 'Expected a plain record-like Object', pointer);
+        }
+    }
+    const descriptors = reflect(() => Object.getOwnPropertyDescriptors(input), pointer, 'Cannot snapshot Object descriptors');
+    const keys = Reflect.ownKeys(descriptors);
+    addMembers(state, keys.length, pointer);
+    const output = {};
+    for (const key of keys) {
+        if (typeof key === 'symbol') {
+            throw new BoundaryError('VALUE_OBJECT', 'Portable Objects cannot have symbol members', pointer);
+        }
+        const memberPointer = child(pointer, key);
+        assertHostString(key, memberPointer, state.limits.maxStringBytes);
+        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);
+        }
+        Object.defineProperty(output, key, {
+            configurable: true,
+            enumerable: true,
+            value: admit(descriptor.value, memberPointer, depth, state),
+            writable: true,
+        });
+    }
+    return output;
+}
+function descriptorValue(descriptors, name) {
+    return ownDescriptor(descriptors, name)?.value;
+}
+function ownDescriptor(descriptors, name) {
+    const holder = Object.getOwnPropertyDescriptor(descriptors, name);
+    return holder?.value;
+}
+function addMembers(state, count, pointer) {
+    state.members += count;
+    if (state.members > state.limits.maxMembers) {
+        throw new BoundaryError('VALUE_LIMIT', `Value exceeds the ${state.limits.maxMembers}-member limit`, pointer);
+    }
+}
+function reflect(operation, pointer, message) {
+    try {
+        return operation();
+    }
+    catch (error) {
+        throw new BoundaryError('VALUE_REFLECTION', message, pointer, { cause: error });
+    }
+}
+function child(pointer, token) {
+    return `${pointer}/${token.replaceAll('~', '~0').replaceAll('/', '~1')}`;
+}

package/dist/value/canonical.d.ts

@@ -0,0 +1,4 @@
+import { type Options } from './limits.js';
+/** RFC 8785 canonical JSON for one admitted portable snapshot. */
+export declare function serialize(input: unknown, options?: Options): string;
+export declare function encode(input: unknown, options?: Options): Uint8Array;

package/dist/value/canonical.js

@@ -0,0 +1,41 @@
+import { accept } from './accept.js';
+import { BoundaryError } from './error.js';
+import { 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 output;
+}
+export function encode(input, options) {
+    return encoder.encode(serialize(input, options));
+}
+function serializeValue(value) {
+    if (value === null)
+        return 'null';
+    switch (typeof value) {
+        case 'boolean':
+            return value ? 'true' : 'false';
+        case 'number':
+        case 'string':
+            return JSON.stringify(value);
+        case 'object':
+            return Array.isArray(value)
+                ? `[${value.map(serializeValue).join(',')}]`
+                : serializeObject(value);
+    }
+}
+function serializeObject(value) {
+    return `{${Object.keys(value)
+        .sort(compareUtf16)
+        .map((key) => `${JSON.stringify(key)}:${serializeValue(value[key])}`)
+        .join(',')}}`;
+}
+function compareUtf16(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/value/decode.d.ts

@@ -0,0 +1,4 @@
+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;