@mida-context/sdk 0.1.0

package/dist/types/mida-context-sdk/local.d.ts

@@ -0,0 +1,40 @@
+import type { ContextInput, ContextResult, HandoffAnswer, RememberInput, RememberResult, RequestAccessResult, StatusAnswer, Transport, VerifyResult, WhatsNewAnswer } from "./transport.js";
+import type { ContextItem } from "./transport.js";
+/**
+ * The default transport: every call goes to the Mida service (midad) over this machine's private
+ * Unix socket, so the daemon's gates — grants, revocation, the save lanes, the verified reads —
+ * decide every answer. The SDK holds no chain keys and signs nothing itself; `requestAccess` and
+ * `verify` are the exceptions, which read the agent's own identity files from the Mida home
+ * through `@mida/sdk`, exactly as the CLI does.
+ */
+export declare class LocalTransport implements Transport {
+    #private;
+    constructor(options: {
+        agent: string;
+        home: string;
+        project: string;
+        task?: string;
+    });
+    context(input: ContextInput): Promise<ContextResult>;
+    remember(input: RememberInput): Promise<RememberResult>;
+    /**
+     * Files the access request where `mida approve <agent>` looks for it — `pending-request.json`
+     * plus the request store — through the same `connectAgent` path the CLI uses. The agent cannot
+     * approve itself: approval is the owner's terminal step, and this SDK carries no approve call.
+     */
+    requestAccess(): Promise<RequestAccessResult>;
+    /**
+     * Checks one item against the chain — not against the store or the payload. `commitment` asks
+     * whether the registry's record carries exactly this manifest; `author` whether the chain
+     * recorded this author; `grant-at-write` whether a record exists at all — the registry only
+     * anchors writes made under a live grant, so anchoring is the grant-at-write proof.
+     */
+    verify(item: ContextItem): Promise<VerifyResult>;
+    handoff(): Promise<HandoffAnswer>;
+    whatsNew(): Promise<WhatsNewAnswer>;
+    /**
+     * `/health` plus the same `/handoff` probe `mida_status` runs per agent — the verdict line says
+     * what that probe answered, word for word the adapter's line.
+     */
+    status(): Promise<StatusAnswer>;
+}

package/dist/types/mida-context-sdk/mida.d.ts

@@ -0,0 +1,65 @@
+import type { ContextInput, ContextResult, HandoffAnswer, RememberInput, RememberResult, RequestAccessResult, StatusAnswer, VerifyResult, WhatsNewAnswer } from "./transport.js";
+import type { ContextItem } from "./transport.js";
+/** The transports this version speaks. `direct` is a named promise for phase 2. */
+export type TransportKind = "local" | "direct";
+export interface MidaOptions {
+    /** The agent name this app was provisioned as — the name `mida approve` signed for. */
+    agent: string;
+    /** How to reach Mida. Default and only option today is `"local"` — this machine's Mida service. */
+    transport?: TransportKind;
+    /** The folder this agent works in — what counts as "this project". Default: process.cwd(). */
+    project?: string;
+    /** The named task this agent is doing; scopes handoff()/whatsNew()/status() and the checkpoint records context() returns. */
+    task?: string;
+    /** The Mida home — the folder `mida init` made. Default: $MIDA_HOME, else ~/.mida. */
+    home?: string;
+}
+/**
+ * An app's handle on this user's Mida context. Every method asks the same question Mida itself
+ * would — the Mida service decides what this agent may see, sign and remember — so an SDK app
+ * can never see more than the grants the owner signed allow.
+ */
+export declare class Mida {
+    #private;
+    /** The agent name, as the owner approved it. */
+    readonly agent: string;
+    /** The project folder `context()`/handoff calls answer for. */
+    readonly project: string;
+    /** The named task this handle is doing, when one was given. */
+    readonly task: string | undefined;
+    /** Which transport this handle uses. */
+    readonly transportKind: TransportKind;
+    constructor(options: MidaOptions);
+    /**
+     * Read this user's context in the areas this agent's grants cover — most-recently-anchored
+     * first, byte-budgeted, whole records only. In `projects.current`, checkpoint records are
+     * scoped to this handle's task (the same task `handoff()` resolves); the result's
+     * `otherTasks` names the project's other active tasks without their content. Throws the
+     * refusal's code (`not-approved`, `revoked`, `rate-limited`…) when the service refuses;
+     * `service-unavailable` when midad isn't answering.
+     */
+    context(input: ContextInput): Promise<ContextResult>;
+    /**
+     * Write one memory: a note, a finding, a decision. Always recorded as AGENT_INFERRED — the
+     * provenance is the service's to stamp, never the caller's. Returns the record's id and
+     * whether it is already anchored (`anchored`) or accepted onto the batching lane (`pending`).
+     */
+    remember(input: RememberInput): Promise<RememberResult>;
+    /**
+     * File a request asking the owner for this agent's grants. The agent can never approve itself:
+     * approval is the owner's terminal step — `mida approve <agent>` — and nothing in this SDK
+     * performs it.
+     */
+    requestAccess(): Promise<RequestAccessResult>;
+    /** Check one item against the chain: its commitment, its author, and the grant it was written under. */
+    verify(item: ContextItem): Promise<VerifyResult>;
+    /** The session-start text `mida_handoff` would inject for this agent and folder. */
+    handoff(): Promise<HandoffAnswer>;
+    /** What's new for this agent and folder — the same answer `mida_whats_new` gives. */
+    whatsNew(): Promise<WhatsNewAnswer>;
+    /**
+     * Is the Mida service up, and what would this agent get here — approved, revoked, or
+     * never asked. Always answers; `up: false` when midad is not answering.
+     */
+    status(): Promise<StatusAnswer>;
+}

package/dist/types/mida-context-sdk/transport.d.ts

@@ -0,0 +1,137 @@
+import type { ContextKind, Hex, RecordReference } from "../protocol/index.js";
+/**
+ * One memory record as the SDK reports it. `author` and `writtenAt` come from the chain (or the
+ * store's received stamp while a save is pending) — never from the record's own content.
+ */
+export interface ContextItem {
+    /** The record's contextId. */
+    id: Hex;
+    namespace: string;
+    kind: ContextKind;
+    /** The decrypted payload value — the record's content, never a whole payload envelope. */
+    content: string | Record<string, unknown>;
+    /** The author the chain recorded; `name` resolves through the home's identity files, null when unknown. */
+    author: {
+        name: string | null;
+        id: Hex;
+    };
+    /** The provenance source the chain recorded — agent writes are always "AGENT_INFERRED". */
+    source: string;
+    /** ISO-8601. Anchored records carry the chain's stamp; pending ones the store's received stamp. */
+    writtenAt: string;
+    /** "pending" = the batching lane accepted the save but Monad has not anchored it yet. */
+    state: "anchored" | "pending";
+    superseded: false;
+    references: RecordReference[];
+    /** The on-chain proof of this record: its manifestHash and the record id to verify against. */
+    proof: {
+        manifestHash: Hex;
+        recordId: Hex;
+    };
+    /**
+     * Checkpoint records only: the task the record belongs to. Workflow memory is task-scoped —
+     * `context()` returns only the resolved task's checkpoint records, so on a checkpoint item
+     * this always equals that task ("main" when the handle named none). Absent on every
+     * non-checkpoint record, which is durable memory and never task-filtered.
+     */
+    task?: string;
+}
+export interface ContextInput {
+    /** One namespace — e.g. "projects.current". With `namespaces` unset, this is the whole read. */
+    namespace?: string;
+    /** Several namespaces read together; there is no ranking, the merged order is the chain's. */
+    namespaces?: string[];
+    /** The byte budget, counted over each item's content. A single record larger than `limit` is
+     *  returned alone with `overLimit` set — never hidden, never truncated. */
+    limit: number;
+    /** ISO-8601 — only items whose effective stamp is strictly newer are returned. */
+    since?: string;
+    /** A cursor from an earlier `context()` result — resumes strictly after it. */
+    cursor?: string;
+}
+export interface ContextResult {
+    items: ContextItem[];
+    /** Non-null while more items remain beyond this page — pass it back as `cursor`. */
+    cursor: string | null;
+    /**
+     * The project's other active tasks — name, who last saved, when — the same entries the
+     * handoff prints as "Other active tasks". Awareness only: no content, no record ids; a
+     * task's own thread is a deliberate `mida task show <name>` away. Empty when the read did
+     * not touch `projects.current` or no other task saved recently.
+     */
+    otherTasks: {
+        name: string;
+        savedBy: string;
+        savedAt: string;
+    }[];
+    /** Set when a single record larger than `limit` was returned alone. */
+    overLimit?: true;
+    /** Set when the store's list was incomplete — the items shown verified, but the list may not be whole. */
+    partial?: true;
+}
+export interface RememberInput {
+    /** Required — the area the record lands in (e.g. "projects.current"). There is no `auto`. */
+    namespace: string;
+    content: string | Record<string, unknown>;
+    /** Defaults to "INFERENCE" — the record is always written as AGENT_INFERRED. */
+    kind?: ContextKind;
+    references?: RecordReference[];
+    /** An earlier record of this agent's own lineage this one replaces — the SUPERSEDE_OWN path. */
+    supersedes?: Hex;
+}
+export interface RememberResult {
+    id: Hex;
+    /** "anchored" on the direct lane; "pending" until the batching lane's save anchors. */
+    state: "anchored" | "pending";
+}
+export interface RequestAccessResult {
+    requestId: Hex;
+    /** The owner-side step nothing else can substitute for. */
+    nextStep: string;
+}
+export interface VerifyCheck {
+    name: "commitment" | "author" | "grant-at-write";
+    ok: boolean;
+    detail: string;
+}
+export interface VerifyResult {
+    valid: boolean;
+    checks: VerifyCheck[];
+}
+/** The session-start text `mida_handoff` would inject. Refusals throw — they never come back as text. */
+export interface HandoffAnswer {
+    kind: "handoff" | "empty";
+    text: string;
+}
+export interface WhatsNewAnswer {
+    kind: "updates" | "none";
+    text: string;
+}
+export interface StatusAnswer {
+    /** Whether the Mida service answered at all. */
+    up: boolean;
+    /** The same lines `mida_status` prints — the service line, then this agent's verdict. */
+    text: string;
+    service?: {
+        pid: number | null;
+        startedAt: string | null;
+        queueDepth: number | null;
+    };
+    agent?: {
+        name: string;
+        verdict: "approved" | "not-approved" | "revoked" | "general-assistance" | "unknown";
+    };
+}
+/**
+ * The seven calls every transport answers. `local` talks to the Mida service over this machine's
+ * private socket; `direct` arrives in phase 2 with Sign in with Mida.
+ */
+export interface Transport {
+    context(input: ContextInput): Promise<ContextResult>;
+    remember(input: RememberInput): Promise<RememberResult>;
+    requestAccess(): Promise<RequestAccessResult>;
+    verify(item: ContextItem): Promise<VerifyResult>;
+    handoff(): Promise<HandoffAnswer>;
+    whatsNew(): Promise<WhatsNewAnswer>;
+    status(): Promise<StatusAnswer>;
+}

package/dist/types/protocol/batch.d.ts

@@ -0,0 +1,161 @@
+import type { Address, Hex } from "./types.js";
+/** Why the contract skipped a save (SaveRejected.reason). Mirrors BatchAnchor.sol. */
+export declare const BATCH_REJECT: {
+    readonly BAD_SIGNER: 1;
+    readonly BAD_SHAPE: 2;
+    readonly BAD_AREA: 3;
+    readonly BAD_EPOCH: 4;
+    readonly NO_AUTHORITY: 5;
+    readonly ALREADY_ANCHORED: 6;
+    readonly STALE_PARENT: 7;
+};
+export type BatchRejectReason = keyof typeof BATCH_REJECT;
+export declare const BATCH_ANCHOR_DOMAIN_NAME = "Mida Batch Anchor";
+export declare const BATCH_SAVE_TYPES: {
+    readonly MidaBatchSaveV1: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "namespaceId";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "objectNonce";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "lineageId";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "parentId";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "parentVersion";
+        readonly type: "uint32";
+    }, {
+        readonly name: "rootAuthor";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "manifestHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "ciphertextCommitment";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "readEpoch";
+        readonly type: "uint64";
+    }, {
+        readonly name: "expiresAt";
+        readonly type: "uint64";
+    }, {
+        readonly name: "kind";
+        readonly type: "uint8";
+    }, {
+        readonly name: "provenanceSource";
+        readonly type: "uint8";
+    }];
+};
+/** What an agent signs for one batched save. A new lineage has lineageId = parentId = rootAuthor = 0, parentVersion = 0. */
+export interface BatchSaveMessage {
+    owner: Address;
+    namespaceId: Hex;
+    objectNonce: Hex;
+    lineageId: Hex;
+    parentId: Hex;
+    parentVersion: number;
+    rootAuthor: Hex;
+    manifestHash: Hex;
+    ciphertextCommitment: Hex;
+    readEpoch: bigint;
+    expiresAt: bigint;
+    kind: number;
+    provenanceSource: number;
+}
+export declare function batchSaveTypedData(input: {
+    chainId: bigint;
+    batchAnchor: Address;
+    message: BatchSaveMessage;
+}): {
+    domain: {
+        name: string;
+        version: string;
+        chainId: bigint;
+        verifyingContract: `0x${string}`;
+    };
+    types: {
+        readonly MidaBatchSaveV1: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "namespaceId";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "objectNonce";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "lineageId";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "parentId";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "parentVersion";
+            readonly type: "uint32";
+        }, {
+            readonly name: "rootAuthor";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "manifestHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "ciphertextCommitment";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "readEpoch";
+            readonly type: "uint64";
+        }, {
+            readonly name: "expiresAt";
+            readonly type: "uint64";
+        }, {
+            readonly name: "kind";
+            readonly type: "uint8";
+        }, {
+            readonly name: "provenanceSource";
+            readonly type: "uint8";
+        }];
+    };
+    primaryType: "MidaBatchSaveV1";
+    message: BatchSaveMessage;
+};
+export declare function batchSaveDigest(input: {
+    chainId: bigint;
+    batchAnchor: Address;
+    message: BatchSaveMessage;
+}): Hex;
+export declare const BATCH_SAVE_TYPEHASH: `0x${string}`;
+/** The EIP-712 struct hash (not the digest); it is what the leaf binds. */
+export declare function batchSaveStructHash(m: BatchSaveMessage): Hex;
+export declare function batchContextId(i: {
+    chainId: bigint;
+    batchAnchor: Address;
+    owner: Address;
+    agentId: Hex;
+    namespaceId: Hex;
+    parentId: Hex;
+    objectNonce: Hex;
+}): Hex;
+export declare function batchLeafHash(i: {
+    contextId: Hex;
+    agentId: Hex;
+    lineageId: Hex;
+    version: number;
+    structHash: Hex;
+}): Hex;
+export declare function headCommit(i: {
+    contextId: Hex;
+    owner: Address;
+    namespaceId: Hex;
+    rootAuthor: Hex;
+    version: number;
+}): Hex;
+export declare function merkleRoot(leaves: readonly Hex[]): Hex;
+export declare function merkleProof(leaves: readonly Hex[], index: number): Hex[];
+export declare function verifyMerkleProof(leaf: Hex, proof: readonly Hex[], root: Hex): boolean;

package/dist/types/protocol/constants.d.ts

@@ -0,0 +1,56 @@
+export declare const PERMISSION: {
+    readonly READ: 1;
+    readonly CREATE: 2;
+    readonly SUPERSEDE_OWN: 4;
+    readonly SUPERSEDE_ANY: 8;
+};
+export type Permission = keyof typeof PERMISSION;
+export declare const KNOWN_PERMISSION_BITS = 15;
+export declare const PROVENANCE_POLICY: {
+    readonly ALLOW_INFERENCE: 1;
+    readonly ALLOW_IMPORTED: 2;
+    readonly ALLOW_EXTERNAL_ATTESTATION: 4;
+};
+export type ProvenancePolicy = keyof typeof PROVENANCE_POLICY;
+export declare const KNOWN_PROVENANCE_BITS = 7;
+export declare const RECORD_TYPE: {
+    readonly CONTEXT: 0;
+    readonly EVIDENCE: 1;
+};
+export type RecordType = keyof typeof RECORD_TYPE;
+export declare const LINEAGE_POLICY: {
+    readonly STANDARD: 0;
+    readonly OWNER_CONTROLLED: 1;
+};
+export type LineagePolicy = keyof typeof LINEAGE_POLICY;
+export declare const CONTEXT_KIND: {
+    readonly NONE: 0;
+    readonly FACT: 1;
+    readonly PREFERENCE: 2;
+    readonly GOAL: 3;
+    readonly DECISION: 4;
+    readonly EPISODE: 5;
+    readonly INFERENCE: 6;
+    readonly CREDENTIAL: 7;
+    readonly OPEN_LOOP: 8;
+};
+export type ContextKind = keyof typeof CONTEXT_KIND;
+export declare const PROVENANCE_SOURCE: {
+    readonly NONE: 0;
+    readonly USER_ASSERTED: 1;
+    readonly USER_CONFIRMED: 2;
+    readonly AGENT_INFERRED: 3;
+    readonly IMPORTED: 4;
+    readonly EXTERNAL_ATTESTATION: 5;
+};
+export type ProvenanceSource = keyof typeof PROVENANCE_SOURCE;
+export declare const RECORD_RELATION_CODE: {
+    readonly supports: 1;
+    readonly derived_from: 2;
+    readonly confirmed_from: 3;
+};
+export type RecordRelation = keyof typeof RECORD_RELATION_CODE;
+export declare const POLICY_VERSION: "mida-grant-policy-v1";
+export declare const NAMESPACE_TREE_VERSION: "mida-namespace-tree-v1";
+export declare const CRYPTO_VERSION: "mida-crypto-v1";
+export declare const MAX_PAYLOAD_BYTES = 65536;

package/dist/types/protocol/errors.d.ts

@@ -0,0 +1,15 @@
+/** §12.6 typed failures, §14.8 advisor hard failures, then plan decision 3 implementation codes. */
+export declare const MIDA_ERROR_CODES: readonly ["CAPABILITY_DENIED", "CAPABILITY_EXPIRED", "CAPABILITY_REVOKED", "EPOCH_ROTATION_REQUIRED", "EPOCH_STALE", "NO_EPOCH_WRAP", "WRAP_KEY_VERSION_MISMATCH", "MANIFEST_MISMATCH", "CONTENT_HASH_MISMATCH", "COMMITMENT_MISMATCH", "DECRYPT_FAILED", "INVALID_NAMESPACE", "STALE_PARENT", "EVIDENCE_IMMUTABLE", "PROVENANCE_FORBIDDEN", "ANCHOR_OWNER_ONLY", "MANIFEST_NOT_FOUND", "MANIFEST_HASH_MISMATCH", "MANIFEST_SIGNATURE_INVALID", "MANIFEST_STALE", "AGENT_ID_MISMATCH", "PURPOSE_UNKNOWN", "REQUEST_SIGNATURE_INVALID", "NAMESPACE_TREE_VERSION_UNSUPPORTED", "POLICY_VERSION_UNSUPPORTED", "INVALID_WIRE", "PAYLOAD_TOO_LARGE", "ZERO_KEY", "AUTH_INVALID", "REPLAY", "REQUEST_EXPIRED", "REQUEST_CONSUMED", "RESPONSE_MISMATCH", "NOT_FOUND", "GAS_CEILING_EXCEEDED", "OWNER_WALLET_LOW", "PARTIAL_READ", "SPONSOR_FAILED", "SPONSOR_PENDING", "SEND_TIMEOUT", "WRITE_DENIED", "CHAIN_UNAVAILABLE", "CHAIN_MISCONFIGURED", "RPC_AUTH_REJECTED", "INTERNAL_ERROR"];
+export type MidaErrorCode = (typeof MIDA_ERROR_CODES)[number];
+export declare class MidaError extends Error {
+    readonly code: MidaErrorCode;
+    /**
+     * GAS_CEILING_EXCEEDED only: the estimate that was refused and the ceiling it was compared
+     * against. A caller that re-sizes — the batcher shrinking a refused take — reads the numbers
+     * here rather than parsing them back out of the message text.
+     */
+    estimate?: bigint;
+    ceiling?: bigint;
+    constructor(code: MidaErrorCode, detail?: string);
+}
+export declare function isMidaError(value: unknown, code?: MidaErrorCode): value is MidaError;

package/dist/types/protocol/ids.d.ts

@@ -0,0 +1,72 @@
+import type { Address, Hex } from "viem";
+import type { GrantScope, RecordReference, RequestedScope } from "./types.js";
+export declare const OWNER_AUTHOR_ID: Hex;
+export declare const hashString: (value: string) => Hex;
+export declare const POLICY_VERSION_HASH: Hex;
+export declare const NAMESPACE_TREE_VERSION_HASH: Hex;
+export declare function agentId(input: {
+    chainId: bigint;
+    capabilityRegistry: Address;
+    operator: Address;
+    agentSalt: Hex;
+}): Hex;
+export declare function contextId(input: {
+    chainId: bigint;
+    contextRegistry: Address;
+    owner: Address;
+    authorId: Hex;
+    namespaceId: Hex;
+    objectNonce: Hex;
+}): Hex;
+export declare function sortScopes<T extends RequestedScope>(scopes: readonly T[]): T[];
+export declare function assertCanonicalScopes(scopes: readonly RequestedScope[]): void;
+/** Hashes in the order given. Call sortScopes and assertCanonicalScopes first. */
+export declare function scopesHash(scopes: readonly RequestedScope[]): Hex;
+export declare function capabilityId(input: {
+    owner: Address;
+    agentId: Hex;
+    grantNonce: bigint;
+    index: bigint;
+    namespaceId: Hex;
+    permissions: number;
+    provenancePolicy: number;
+    expiresAt: bigint;
+}): Hex;
+export declare function grantDigest(input: {
+    chainId: bigint;
+    capabilityRegistry: Address;
+    owner: Address;
+    agentId: Hex;
+    requestHash: Hex;
+    manifestHash: Hex;
+    manifestVersion: bigint;
+    finalScopes: readonly GrantScope[];
+    expiresAt: bigint;
+    grantNonce: bigint;
+}): Hex;
+export interface CanonicalReference {
+    relationCode: number;
+    recordId: Hex;
+}
+export declare function canonicalReferences(references: readonly RecordReference[]): CanonicalReference[];
+export declare function evidenceCommitment(references: readonly RecordReference[]): Hex;
+export declare function p256RotationDigest(input: {
+    chainId: bigint;
+    capabilityRegistry: Address;
+    owner: Address;
+    newQx: bigint;
+    newQy: bigint;
+    nonce: bigint;
+}): Hex;
+export declare function cancelFastRevokeDigest(input: {
+    chainId: bigint;
+    capabilityRegistry: Address;
+    owner: Address;
+    revocationIntentId: Hex;
+    apiCancellationNonce: bigint;
+    expiresAt: bigint;
+}): Hex;
+export declare function canonicalizeOrigin(input: string, options?: {
+    allowLocalhost?: boolean;
+}): string;
+export declare const originHash: (canonicalOrigin: string) => Hex;

package/dist/types/protocol/index.d.ts

@@ -0,0 +1,11 @@
+export declare const PROTOCOL_VERSION: "mida-protocol-v1";
+export * from "./errors.js";
+export * from "./constants.js";
+export * from "./types.js";
+export * from "./wire.js";
+export * from "./namespaces.js";
+export * from "./ids.js";
+export * from "./typed-data.js";
+export * from "./batch.js";
+export * from "./webauthn-assertion.js";
+export * from "./owner-link.js";

package/dist/types/protocol/namespaces.d.ts

@@ -0,0 +1,15 @@
+import type { Hex } from "viem";
+export type IsolationDomain = "general" | "financial" | "relationships" | "private";
+export interface NamespaceNode {
+    name: string;
+    parent: string | null;
+    domain: IsolationDomain;
+    id: Hex;
+}
+export declare function namespaceId(canonicalNamespace: string): Hex;
+export declare const NAMESPACE_TREE_V1: readonly NamespaceNode[];
+export declare function canonicalizeNamespace(input: string): string;
+export declare function namespaceById(id: Hex): NamespaceNode;
+/** Depth is at most two, so descendants are exactly the direct children. */
+export declare function expandNamespace(input: string): string[];
+export declare function domainOf(input: string): IsolationDomain;