@astrale-os/kernel-core 0.9.0-beta.9 → 1.0.0-beta.2

package/dist/auth/register/fingerprint/index.d.ts

@@ -0,0 +1,2 @@
+export { fingerprint } from './fingerprint.js';
+export type { RegisterFingerprint, RegisterFingerprintIdentity, RegisterFingerprintInput, } from './fingerprint.js';

package/dist/auth/register/index.d.ts

@@ -0,0 +1,5 @@
+export { fingerprint } from './fingerprint/index.js';
+export type { RegisterFingerprint, RegisterFingerprintIdentity, RegisterFingerprintInput, } from './fingerprint/index.js';
+export { accept, isSelfIssuer, selfIssuer } from './request/index.js';
+export type { IdentityRegistration, RegisterRequest } from './request/index.js';
+export type { RegisteredIdentity, RegisterResult } from './result/index.js';

package/dist/auth/register/request/admission.d.ts

@@ -0,0 +1,3 @@
+import type { RegisterRequest } from './request.js';
+/** Admit unknown input into the exact immutable existing-target Register language. */
+export declare function accept(input: unknown): RegisterRequest;

package/dist/auth/register/request/admission.js

@@ -0,0 +1,103 @@
+import { NodeId } from '../../../graph/node/index.js';
+import { AuthValueError } from '../../error.js';
+import { acceptPublic } from '../../jwk/index.js';
+import { REGISTER_REQUEST_LIMITS } from './limits.js';
+const textEncoder = new TextEncoder();
+/** Admit unknown input into the exact immutable existing-target Register language. */
+export function accept(input) {
+    if (!isRecord(input))
+        invalid('', 'Expected a Register request object');
+    exact(input, ['idempotencyKey', 'identities'], '');
+    if (typeof input.idempotencyKey !== 'string' ||
+        input.idempotencyKey.length === 0 ||
+        input.idempotencyKey.length > REGISTER_REQUEST_LIMITS.idempotencyKeyCharacters ||
+        textEncoder.encode(input.idempotencyKey).byteLength >
+            REGISTER_REQUEST_LIMITS.idempotencyKeyBytes) {
+        invalid('/idempotencyKey', 'Expected a bounded non-empty idempotency key');
+    }
+    if (!Array.isArray(input.identities) ||
+        input.identities.length === 0 ||
+        input.identities.length > REGISTER_REQUEST_LIMITS.identities) {
+        invalid('/identities', 'Expected a bounded non-empty Identity register array');
+    }
+    const identities = input.identities
+        .map((candidate, index) => identityInput(candidate, `/identities/${index}`))
+        .sort((left, right) => compare(left.id, right.id));
+    for (let index = 1; index < identities.length; index += 1) {
+        if (identities[index - 1].id === identities[index].id) {
+            invalid(`/identities/${index}/id`, 'Duplicate Identity target');
+        }
+    }
+    return Object.freeze({
+        idempotencyKey: input.idempotencyKey,
+        identities: Object.freeze(identities),
+    });
+}
+function identityInput(input, path) {
+    if (!isRecord(input))
+        invalid(path, 'Expected an Identity register object');
+    if (input.mode !== 'external' && input.mode !== 'self') {
+        invalid(`${path}/mode`, 'Expected external or self');
+    }
+    exact(input, input.mode === 'self'
+        ? ['credential', 'id', 'mode', 'publicKey']
+        : ['credential', 'id', 'mode'], path);
+    let id;
+    try {
+        if (typeof input.id !== 'string')
+            throw new TypeError('IdentityId must be text.');
+        id = NodeId(input.id);
+    }
+    catch (cause) {
+        invalid(`${path}/id`, 'Expected an IdentityId', cause);
+    }
+    const credential = credentialInput(input.credential, `${path}/credential`);
+    if (input.mode === 'external') {
+        return Object.freeze({ id, mode: 'external', credential });
+    }
+    return Object.freeze({
+        id,
+        mode: 'self',
+        publicKey: publicJwk(input.publicKey, `${path}/publicKey`),
+        credential,
+    });
+}
+function credentialInput(input, path) {
+    if (typeof input === 'string') {
+        const bytes = textEncoder.encode(input).byteLength;
+        if (bytes === 0 || bytes > REGISTER_REQUEST_LIMITS.credentialBytes) {
+            invalid(path, `Credential must contain 1-${REGISTER_REQUEST_LIMITS.credentialBytes} bytes`);
+        }
+        return input;
+    }
+    if (!(input instanceof Uint8Array) ||
+        input.byteLength === 0 ||
+        input.byteLength > REGISTER_REQUEST_LIMITS.credentialBytes) {
+        invalid(path, `Credential must contain 1-${REGISTER_REQUEST_LIMITS.credentialBytes} bytes`);
+    }
+    return input.slice();
+}
+function publicJwk(input, path) {
+    try {
+        return acceptPublic(input);
+    }
+    catch (cause) {
+        invalid(path, 'Expected a thumbprintable public JWK', cause);
+    }
+}
+function exact(input, expected, path) {
+    const actual = Object.keys(input).sort(compare);
+    const wanted = [...expected].sort(compare);
+    if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index])) {
+        invalid(path, `Expected exactly ${expected.join(', ')}`);
+    }
+}
+function isRecord(input) {
+    return input !== null && typeof input === 'object' && !Array.isArray(input);
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function invalid(path, message, cause) {
+    throw new AuthValueError('AUTH_REGISTER_REQUEST_INVALID', message, path, cause === undefined ? undefined : { cause });
+}

package/dist/auth/register/request/index.d.ts

@@ -0,0 +1,3 @@
+export { accept } from './admission.js';
+export { isSelfIssuer, selfIssuer } from './self-issuer.js';
+export type { IdentityRegistration, RegisterRequest } from './request.js';

package/dist/auth/register/request/limits.d.ts

@@ -0,0 +1,6 @@
+export declare const REGISTER_REQUEST_LIMITS: Readonly<{
+    credentialBytes: number;
+    idempotencyKeyBytes: 1024;
+    idempotencyKeyCharacters: 256;
+    identities: 256;
+}>;

package/dist/auth/register/request/limits.js

@@ -0,0 +1,6 @@
+export const REGISTER_REQUEST_LIMITS = Object.freeze({
+    credentialBytes: 64 * 1024,
+    idempotencyKeyBytes: 1_024,
+    idempotencyKeyCharacters: 256,
+    identities: 256,
+});

package/dist/auth/register/request/request.d.ts

@@ -0,0 +1,19 @@
+import type { CredentialInput } from '../../credential/input/index.js';
+import type { IdentityId } from '../../identity/index.js';
+import type { JsonWebKey } from '../../jwk/index.js';
+export type IdentityRegistration = {
+    readonly id: IdentityId;
+    readonly mode: 'external';
+    readonly credential: CredentialInput;
+    readonly publicKey?: never;
+} | {
+    readonly id: IdentityId;
+    readonly mode: 'self';
+    readonly publicKey: JsonWebKey;
+    readonly credential: CredentialInput;
+};
+/** Claim credential-evidenced Authentication for existing Identity-bearing Nodes. */
+export interface RegisterRequest {
+    readonly idempotencyKey: string;
+    readonly identities: readonly [IdentityRegistration, ...IdentityRegistration[]];
+}

package/dist/auth/{provision → register}/request/self-issuer.d.ts

@@ -1,6 +1,6 @@
 import type { IssuerId } from '../../issuer/index.js';
 import type { JsonWebKey } from '../../jwk/index.js';
-/** Build the hosted issuer controlled by one self-provisioned public key. */
+/** Build the hosted issuer controlled by one self-registered public key. */
 export declare function selfIssuer(kernel: IssuerId, publicKey: JsonWebKey): Promise<IssuerId>;
 /** Whether an issuer is one exact key-bound issuer hosted by this Kernel. */
 export declare function isSelfIssuer(kernel: IssuerId, candidate: IssuerId): boolean;

package/dist/auth/{provision → register}/request/self-issuer.js

@@ -1,6 +1,6 @@
 import { accept as acceptIssuer } from '../../issuer/index.js';
 import { thumbprint } from '../../jwk/index.js';
-/** Build the hosted issuer controlled by one self-provisioned public key. */
+/** Build the hosted issuer controlled by one self-registered public key. */
 export async function selfIssuer(kernel, publicKey) {
     const base = String(kernel).replace(/\/+$/u, '');
     return acceptIssuer(`${base}/iss/${await thumbprint(publicKey)}`);

package/dist/auth/register/result/index.d.ts

@@ -0,0 +1 @@
+export type { RegisteredIdentity, RegisterResult } from './result.js';

package/dist/auth/register/result/result.d.ts

@@ -0,0 +1,10 @@
+import type { IdentityId, Subject } from '../../identity/index.js';
+import type { IssuerId } from '../../issuer/index.js';
+export interface RegisteredIdentity {
+    readonly id: IdentityId;
+    readonly iss: IssuerId;
+    readonly sub: Subject;
+}
+export interface RegisterResult {
+    readonly identities: readonly [RegisteredIdentity, ...RegisteredIdentity[]];
+}

package/dist/auth/register/result/result.js

@@ -0,0 +1 @@
+export {};

package/dist/callable/contract/body.d.ts

@@ -0,0 +1,10 @@
+/** One root invocation's already bounded, single-consumer binary request body. */
+export interface BinaryRequestBody {
+    readonly body: ReadableStream<Uint8Array>;
+    readonly length: number;
+}
+/** The streamed request ended early or exceeded its declared Content-Length. */
+export declare class BinaryBodyLengthError extends Error {
+    readonly name = "BinaryBodyLengthError";
+    constructor();
+}

package/dist/callable/contract/body.js

@@ -0,0 +1,7 @@
+/** The streamed request ended early or exceeded its declared Content-Length. */
+export class BinaryBodyLengthError extends Error {
+    name = 'BinaryBodyLengthError';
+    constructor() {
+        super('Binary request length mismatch.');
+    }
+}

package/dist/callable/contract/index.d.ts

@@ -1,5 +1,6 @@
 export type { CallOf } from './call.js';
+export { BinaryBodyLengthError, type BinaryRequestBody } from './body.js';
 export type { InputOf } from './input.js';
-export type { BinaryResult, OutputContractOf, OutputOf, TypedCallableOutput } from './output.js';
+export type { BinaryOutput, BinaryDeliveryBudget, BufferedBinaryResult, OutputContractOf, OutputOf, StreamingBinaryResult, TypedCallableOutput, } from './output.js';
 export type { CallableSignature } from './signature.js';
 export type { Callable, SignatureOf } from './witness.js';

package/dist/callable/contract/index.js

@@ -1 +1 @@
-export {};
+export { BinaryBodyLengthError } from './body.js';

package/dist/callable/contract/output.d.ts

@@ -1,9 +1,25 @@
 import type { SignatureOf } from './witness.js';
-export interface BinaryResult {
+/** Optional owner-selected lifetime for a large HTTP binary result. */
+export interface BinaryDeliveryBudget {
+    readonly maximumDurationMs: number;
+    readonly idleTimeoutMs: number;
+}
+export interface BufferedBinaryResult {
     readonly body: Uint8Array;
     readonly mediaType: string;
+    readonly status?: number;
+    readonly headers?: Readonly<Record<string, string>>;
+}
+export interface StreamingBinaryResult {
+    readonly body: AsyncIterable<Uint8Array>;
+    /** Exact byte length; HTTP aborts delivery if the stream differs. */
+    readonly length?: number;
+    readonly delivery?: BinaryDeliveryBudget;
+    readonly mediaType: string;
+    readonly status?: number;
     readonly headers?: Readonly<Record<string, string>>;
 }
+export type BinaryOutput = BufferedBinaryResult | StreamingBinaryResult;
 /** Output modes retained by a rich callable declaration. */
 export type TypedCallableOutput = {
     readonly mode: 'value';
@@ -24,4 +40,4 @@ export type OutputOf<Value> = OutputContractOf<Value> extends infer Output exten
     readonly item: infer Item;
 } ? AsyncIterable<Item> : Output extends {
     readonly mode: 'binary';
-} ? BinaryResult : never : never;
+} ? BinaryOutput : never : never;

package/dist/callable/index.d.ts

@@ -1,2 +1,3 @@
-export type { BinaryResult, Callable, CallableSignature, CallOf, InputOf, OutputContractOf, OutputOf, SignatureOf, TypedCallableOutput, } from './contract/index.js';
-export type { Call, CallableResult } from './invocation/index.js';
+export { BinaryBodyLengthError } from './contract/index.js';
+export type { BinaryOutput, BinaryDeliveryBudget, BinaryRequestBody, BufferedBinaryResult, Callable, CallableSignature, CallOf, InputOf, OutputContractOf, OutputOf, SignatureOf, StreamingBinaryResult, TypedCallableOutput, } from './contract/index.js';
+export { Target, targetPath, type Call, type CallableResult } from './invocation/index.js';

package/dist/callable/index.js

@@ -1 +1,2 @@
-export {};
+export { BinaryBodyLengthError } from './contract/index.js';
+export { Target, targetPath } from './invocation/index.js';

package/dist/callable/invocation/call.d.ts

@@ -1,7 +1,21 @@
-import type { NodePath } from '@astrale-os/kernel-core/path';
+import type { Key } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Value } from '@astrale-os/kernel-dsl/value';
+import { type NodePath } from '@astrale-os/kernel-core/path';
+/**
+ * One declaration, optionally bound to an instance and to the caller's expectation of it: the
+ * fingerprint of the callable meaning it compiled against.
+ */
+export type Target = {
+    readonly callable: Key.Callable;
+    readonly instance?: NodePath;
+    readonly fingerprint?: `sha256:${string}`;
+};
+/** Capture a structured invocation target at a representation boundary. */
+export declare function Target(input: Target): Target;
+/** Project an admitted target to its canonical graph path without discarding the original Call. */
+export declare function targetPath(target: NodePath | Target): NodePath;
 /** One canonical callable invocation meaning, independent of its carrier. */
 export interface Call {
-    readonly target: NodePath;
+    readonly target: NodePath | Target;
     readonly input: Value;
 }

package/dist/callable/invocation/call.js

@@ -1 +1,41 @@
-export {};
+import { Path } from '@astrale-os/kernel-core/path';
+import { callableAddress } from '@astrale-os/kernel-dsl/v1/addressing';
+const FINGERPRINT_PATTERN = /^sha256:[0-9a-f]{64}$/u;
+/** Capture a structured invocation target at a representation boundary. */
+export function Target(input) {
+    if (input === null ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        Reflect.ownKeys(input).some((field) => !['callable', 'instance', 'fingerprint'].includes(String(field)))) {
+        throw new TypeError('Invocation Target must contain only callable, instance and fingerprint.');
+    }
+    const callable = input.callable;
+    const coordinate = callableAddress(callable);
+    const fingerprint = input.fingerprint;
+    if (fingerprint !== undefined &&
+        (typeof fingerprint !== 'string' || !FINGERPRINT_PATTERN.test(fingerprint))) {
+        throw new TypeError('Invocation Target fingerprint is invalid.');
+    }
+    const suppliedInstance = input.instance;
+    const instance = suppliedInstance === undefined ? undefined : Path.parse(suppliedInstance);
+    if (instance !== undefined &&
+        (coordinate.kind !== 'method' || instance.ast.steps.at(-1)?.kind === 'method')) {
+        throw new TypeError('Only an instance Method target can carry a node instance path.');
+    }
+    return Object.freeze({
+        callable,
+        ...(instance === undefined ? {} : { instance: instance.raw }),
+        ...(fingerprint === undefined ? {} : { fingerprint }),
+    });
+}
+/** Project an admitted target to its canonical graph path without discarding the original Call. */
+export function targetPath(target) {
+    if (typeof target === 'string')
+        return target;
+    const coordinate = callableAddress(target.callable);
+    if (coordinate.kind === 'function')
+        return Path.project(coordinate).raw;
+    return target.instance === undefined
+        ? Path.staticMethod(Path.project(coordinate.owner), coordinate.name).raw
+        : Path.instanceMethod(Path.parse(target.instance), target.callable).raw;
+}

package/dist/callable/invocation/index.d.ts

@@ -1,2 +1,2 @@
-export type { Call } from './call.js';
+export { Target, targetPath, type Call } from './call.js';
 export type { CallableResult } from './result.js';

package/dist/callable/invocation/index.js

@@ -1 +1 @@
-export {};
+export { Target, targetPath } from './call.js';

package/dist/callable/invocation/result.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryResult } from '../contract/index.js';
+import type { BinaryOutput } from '../contract/index.js';
 /** Successful callable output modes parameterized by the owner's stream capability. */
 export type CallableResult<Output, Stream extends AsyncIterable<Output>> = {
     readonly kind: 'value';
@@ -8,5 +8,5 @@ export type CallableResult<Output, Stream extends AsyncIterable<Output>> = {
     readonly stream: Stream;
 } | {
     readonly kind: 'binary';
-    readonly value: BinaryResult;
+    readonly value: BinaryOutput;
 };

package/dist/dns-label.d.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 /**
  * Canonical RFC 1035 §2.3.4 DNS label: lowercase alphanumeric + hyphen, no
  * leading/trailing hyphen, 1–63 characters.
@@ -22,4 +21,4 @@ export declare function assertDnsLabel(value: string, name: string): void;
  * instance id / public slug so non-DNS-safe values are rejected at parse time
  * (the `.max(63)`/`.min(1)` give clear length errors before the regex check).
  */
-export declare const dnsLabelSchema: z.ZodString;
+export declare const dnsLabelSchema: import("zod").ZodString;

package/dist/dns-label.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { string } from 'zod';
 /**
  * Canonical RFC 1035 §2.3.4 DNS label: lowercase alphanumeric + hyphen, no
  * leading/trailing hyphen, 1–63 characters.
@@ -28,8 +28,7 @@ export function assertDnsLabel(value, name) {
  * instance id / public slug so non-DNS-safe values are rejected at parse time
  * (the `.max(63)`/`.min(1)` give clear length errors before the regex check).
  */
-export const dnsLabelSchema = z
-    .string()
+export const dnsLabelSchema = string()
     .min(1)
     .max(63)
     .regex(DNS_LABEL_RE, 'must be a lowercase DNS label [a-z0-9-], ≤63 chars, no leading/trailing hyphen');

package/dist/graph/graph/graph.d.ts

@@ -1,18 +1,15 @@
-import type { Node } from '../node/index.js';
-import type { PathLike } from '../path/index.js';
 import type { GraphAdmissionContext } from './admission/index.js';
 import type { Delta, DeltaResult } from './delta/index.js';
 import type { GraphEdges, GraphNodes } from './indexes/index.js';
 import type { MergeResult } from './merge/index.js';
 import type { GraphData } from './model/index.js';
-import type { GraphPathWalker } from './navigation/index.js';
 /** Immutable indexed behavioral view over exactly one admitted GraphData value. */
 export declare class Graph {
     #private;
     readonly nodes: GraphNodes;
     readonly edges: GraphEdges;
     private constructor();
-    static admit(data: GraphData, context: GraphAdmissionContext, walker?: GraphPathWalker): Graph;
+    static admit(data: GraphData, context: GraphAdmissionContext): Graph;
     static empty(): Graph;
     /** Compare reference-open observations without deriving deletion from absence. */
     static delta(left: Graph, right: Graph): DeltaResult;
@@ -22,7 +19,6 @@ export declare class Graph {
     static merge(base: Graph, current: Graph, target: Graph): MergeResult;
     /** Apply the same exact merge rule to canonical finite values without schema re-admission. */
     static mergeData(base: GraphData, current: GraphData, target: GraphData): MergeResult;
-    walk(path: PathLike): Node | undefined;
     toData(): GraphData;
     equals(other: Graph): boolean;
 }

package/dist/graph/graph/graph.js

@@ -1,11 +1,9 @@
 import { edgeKeyOf } from '../edge/index.js';
-import { Path } from '../path/index.js';
 import { equal as equalProperties } from '../properties/index.js';
 import { admitGraphData } from './admission/index.js';
 import { apply as applyDelta, delta as graphDelta } from './delta/index.js';
 import { buildIndexes, createCollections } from './indexes/index.js';
 import { mergeData as mergeGraphData } from './merge/index.js';
-import { GraphPathWalkerRequiredError } from './navigation/index.js';
 const EMPTY_DATA = Object.freeze({
     nodes: Object.freeze([]),
     edges: Object.freeze([]),
@@ -17,30 +15,17 @@ export class Graph {
     nodes;
     edges;
     #data;
-    #indexes;
-    #walker;
-    #pathContext;
-    constructor(data, indexes, walker) {
+    constructor(data, indexes) {
         this.#data = data;
-        this.#indexes = indexes;
-        this.#walker = walker;
         const collections = createCollections(data.nodes, data.edges, indexes);
         this.nodes = collections.nodes;
         this.edges = collections.edges;
-        this.#pathContext = Object.freeze({
-            nodes: this.nodes,
-            edges: this.edges,
-            orientation: (classKey) => {
-                const info = this.#indexes.classes.byKey.get(classKey);
-                return info?.kind === 'edge' ? info.orientation : undefined;
-            },
-        });
         Object.freeze(this);
     }
-    static admit(data, context, walker) {
+    static admit(data, context) {
         const admitted = admitGraphData(data, context);
         const indexes = buildIndexes(admitted.data.nodes, admitted.data.edges, admitted.classes);
-        return new Graph(admitted.data, indexes, walker);
+        return new Graph(admitted.data, indexes);
     }
     static empty() {
         return Graph.#EMPTY;
@@ -61,15 +46,6 @@ export class Graph {
     static mergeData(base, current, target) {
         return mergeGraphData(base, current, target);
     }
-    walk(path) {
-        const value = Path.from(path);
-        if (this.#walker !== undefined)
-            return this.#walker.walk(value, this.#pathContext);
-        if (value.ast.anchor.kind === 'id' && value.ast.steps.length === 0) {
-            return this.#indexes.nodes.byId.get(value.ast.anchor.id);
-        }
-        throw new GraphPathWalkerRequiredError(value.raw);
-    }
     toData() {
         return this.#data;
     }

package/dist/graph/graph/index.d.ts

@@ -1,12 +1,10 @@
-/** Stable aggregate facade over Graph model, admission, indexes, navigation, delta, and merge. */
+/** Stable aggregate facade over Graph model, admission, indexes, delta, and merge. */
 export { Graph } from './graph.js';
 export type { Delta, DeltaConflict, DeltaResult } from './delta/index.js';
 export type { MergeConflict, MergeResult } from './merge/index.js';
 export { GraphData, GraphDataDecodeError, GraphSpec, GraphSpecDecodeError } from './model/index.js';
 export type { AnonymousNodeSpec, GraphDataJson, GraphSpecEdge, GraphSpecEndpoint, GraphSpecJson, GraphSpecNode, } from './model/index.js';
-export { LocalBinding, isLocalBinding } from './model/index.js';
+export { LocalAlias, isLocalAlias } from './model/index.js';
 export type { GraphAdmissionContext, GraphClassInfo, GraphDiagnostic } from './admission/index.js';
 export { GraphAdmissionError } from './admission/index.js';
 export type { GraphEdges, GraphNodes } from './indexes/index.js';
-export type { GraphPathContext, GraphPathWalker } from './navigation/index.js';
-export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './navigation/index.js';

package/dist/graph/graph/index.js

@@ -1,6 +1,5 @@
-/** Stable aggregate facade over Graph model, admission, indexes, navigation, delta, and merge. */
+/** Stable aggregate facade over Graph model, admission, indexes, delta, and merge. */
 export { Graph } from './graph.js';
 export { GraphData, GraphDataDecodeError, GraphSpec, GraphSpecDecodeError } from './model/index.js';
-export { LocalBinding, isLocalBinding } from './model/index.js';
+export { LocalAlias, isLocalAlias } from './model/index.js';
 export { GraphAdmissionError } from './admission/index.js';
-export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './navigation/index.js';

package/dist/graph/graph/model/codec.js

@@ -5,7 +5,7 @@ import { node as constructNode, NodeId } from '../../node/index.js';
 import { NodePath } from '../../path/index.js';
 import { normalizeProperties } from '../../properties/index.js';
 import { decodeWire } from '../../wire.js';
-import { isLocalBinding, LocalBinding } from './model.js';
+import { isLocalAlias, LocalAlias } from './model.js';
 import { graphSpecSchema } from './wire.js';
 export class GraphDataDecodeError extends TypeError {
     path;
@@ -28,7 +28,7 @@ export class GraphSpecDecodeError extends TypeError {
 /** Strengthen unknown JSON into detached immutable structural graph values. */
 export function decodeGraphSpec(input) {
     try {
-        const value = decodeWire(graphSpecSchema, portable.accept(input), specInvalid);
+        const value = decodeWire(graphSpecSchema, portable.acceptForRead(input), specInvalid);
         const nodes = value.nodes.map((node, index) => decodeSpecNode(node, `/nodes/${index}`));
         const edges = value.edges.map((edge, index) => decodeSpecEdge(edge, `/edges/${index}`));
         validateGraphSpec(nodes, edges);
@@ -124,10 +124,10 @@ function decodeEndpoint(input, path) {
     return Object.freeze({ created: binding(input.created, `${path}/created`) });
 }
 function binding(input, path) {
-    if (!isLocalBinding(input)) {
+    if (!isLocalAlias(input)) {
         specInvalid(path, 'Expected a local binding name of at most 64 characters');
     }
-    return LocalBinding(input);
+    return LocalAlias(input);
 }
 function validateGraphSpec(nodes, edges) {
     const ids = new Set();

package/dist/graph/graph/model/index.d.ts

@@ -13,5 +13,5 @@ export declare const GraphSpec: {
     encode(spec: GraphSpecValue): GraphSpecJson;
 };
 export type { AnonymousNodeSpec, GraphSpecEdge, GraphSpecEndpoint, GraphSpecJson, GraphSpecNode, } from './model.js';
-export { LocalBinding, isLocalBinding } from './model.js';
+export { LocalAlias, isLocalAlias } from './model.js';
 export { GraphSpecDecodeError } from './codec.js';

package/dist/graph/graph/model/index.js

@@ -2,5 +2,5 @@ import { decodeGraphData, decodeGraphSpec, encodeGraphData, encodeGraphSpec } fr
 export const GraphData = Object.freeze({ decode: decodeGraphData, encode: encodeGraphData });
 export { GraphDataDecodeError } from './codec.js';
 export const GraphSpec = Object.freeze({ decode: decodeGraphSpec, encode: encodeGraphSpec });
-export { LocalBinding, isLocalBinding } from './model.js';
+export { LocalAlias, isLocalAlias } from './model.js';
 export { GraphSpecDecodeError } from './codec.js';

package/dist/graph/graph/model/model.d.ts

@@ -2,21 +2,21 @@ import type { EdgeSpec } from '../../edge/index.js';
 import type { Node, NodeId, NodeSpec } from '../../node/index.js';
 import type { NodePath } from '../../path/index.js';
 import type { Properties } from '../../properties/index.js';
-declare const LOCAL_BINDING_BRAND: unique symbol;
+declare const LOCAL_ALIAS_BRAND: unique symbol;
 /** A graph-local lexical name. It is never Node identity. */
-export type LocalBinding = string & {
-    readonly [LOCAL_BINDING_BRAND]: true;
+export type LocalAlias = string & {
+    readonly [LOCAL_ALIAS_BRAND]: true;
 };
-export declare function LocalBinding(input: string): LocalBinding;
-export declare function isLocalBinding(input: unknown): input is LocalBinding;
+export declare function LocalAlias(input: string): LocalAlias;
+export declare function isLocalAlias(input: unknown): input is LocalAlias;
 export interface AnonymousNodeSpec extends NodeSpec {
-    readonly as: LocalBinding;
+    readonly as: LocalAlias;
 }
 export type GraphSpecNode = Node | AnonymousNodeSpec;
 export type GraphSpecEndpoint = NodeId | {
     readonly path: NodePath;
 } | {
-    readonly created: LocalBinding;
+    readonly created: LocalAlias;
 };
 export type GraphSpecEdge = EdgeSpec<GraphSpecEndpoint>;
 /** Detached structural graph values, including graph-local anonymous Nodes. */

package/dist/graph/graph/model/model.js

@@ -1,10 +1,10 @@
-const LOCAL_BINDING_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/u;
-export function LocalBinding(input) {
-    if (!isLocalBinding(input)) {
-        throw new TypeError(`Invalid local binding ${JSON.stringify(input)}.`);
+const LOCAL_ALIAS_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/u;
+export function LocalAlias(input) {
+    if (!isLocalAlias(input)) {
+        throw new TypeError(`Invalid local alias ${JSON.stringify(input)}.`);
     }
     return input;
 }
-export function isLocalBinding(input) {
-    return typeof input === 'string' && LOCAL_BINDING_PATTERN.test(input);
+export function isLocalAlias(input) {
+    return typeof input === 'string' && LOCAL_ALIAS_PATTERN.test(input);
 }