@mida-context/sdk 0.1.0

package/dist/types/chain/writes.d.ts

@@ -0,0 +1,165 @@
+import type { Address, Hex } from "../protocol/index.js";
+import type { Abi, Account, LocalAccount, TransactionReceipt, WalletClient } from "viem";
+import type { Deployment } from "./deployment.js";
+import type { TxKind } from "./gas.js";
+import type { ChainContext } from "./registry.js";
+import type { SponsoredSender } from "./sponsored.js";
+/**
+ * The fee fields a send carries — the answer of `estimateFeesPerGas`, forwarded verbatim into
+ * the transaction so the number the balance guard checked is the number the node checks (R5-9).
+ * An EIP-1559 chain sets `maxFeePerGas`/`maxPriorityFeePerGas`; a legacy chain sets `gasPrice`.
+ */
+export interface SendFee {
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    gasPrice?: bigint;
+}
+/** What a send is about to cost the payer, handed to `beforeSend` after the estimates. */
+export interface SendCost {
+    payer: Address;
+    gasLimit: bigint;
+    /**
+     * The exact fee values the transaction goes out with. The node verifies the payer against
+     * `gasLimit × maxFeePerGas` — checking a fresh (cheaper) gas price instead let a wallet
+     * through that the send itself then refused (R5-9).
+     */
+    fee: SendFee;
+    /** A plain transfer's moved value — part of the payer's total exposure, absent on contract calls. */
+    value?: bigint;
+    /**
+     * Set when `gasLimit` is a bound, not a measured estimate: the node's own `eth_estimateGas`
+     * refused to run, so the send was priced at the kind's ceiling. A balance guard phrases the
+     * refusal "needs up to X MON" rather than claiming a precision the bound does not have (M3-D6).
+     */
+    upperBound?: boolean;
+}
+export interface WriteContext extends ChainContext {
+    walletClient: WalletClient;
+    account: Account;
+    /**
+     * Runs between the gas estimate and the send: the payer's balance can be checked against the
+     * estimated cost and topped up, or the send refused before a transaction the wallet cannot
+     * pay for goes out (R4-4). Only the owner's context wires this; agent signers keep the bare
+     * node error, exactly as before. On the sponsored path it never runs — the user pays nothing.
+     * The `gate` it is handed is THIS send's abandonment gate: a guard that sends a transaction
+     * of its own (an owner top-up) must pass it down, so the nested send stops too when the
+     * outer send's cap already fired (in-18 S4).
+     */
+    beforeSend?: (cost: SendCost, gate: SendGate) => Promise<void>;
+    /**
+     * When set, `sendContract` asks this sender to pay the gas first (the user still signs; the
+     * sponsor pays). A SponsorDidNotPay falls back to the self-paid path — or refuses, when
+     * SPONSOR_FALLBACK_TO_SELF_PAY is off. Any other error (an included-but-reverted operation
+     * among them) propagates untouched: the sponsor did pay and the call itself failed.
+     */
+    sponsor?: SponsoredSender;
+    /**
+     * One plain line while a slow step runs — where the sponsor fallback explains itself. Wired by
+     * the runtime to its own progress channel; unset means silent code paths stay silent.
+     */
+    progress?: (line: string) => void;
+    /**
+     * The bounded wait every send runs under (in-15 J-4): while the chain stays silent a
+     * "still waiting for Monad (N s)…" line ticks on `progress` every `everyMs`, and once `capMs`
+     * passes the send throws SEND_TIMEOUT — the error says whether a transaction hash exists, so
+     * "sent but unconfirmed" and "nothing left the process" are never the same line. Timer
+     * callbacks are injectable so a test runs the clock; defaults below.
+     */
+    sendWatch?: {
+        everyMs?: number;
+        capMs?: number;
+        setTimeout?: (fn: () => void, ms: number) => unknown;
+        clearTimeout?: (timer: unknown) => void;
+    };
+}
+/** A write context whose account can sign typed data locally (operators, owners and agent signers in tests and the CLI). */
+export interface LocalWriteContext extends WriteContext {
+    account: LocalAccount;
+}
+export declare function createWriteContext(input: {
+    rpcUrl: string;
+    deployment: Deployment;
+    account: LocalAccount;
+}): LocalWriteContext;
+/** A mined receipt plus the gas limit the transaction was actually sent with — the number Monad bills. */
+export type SentReceipt = TransactionReceipt & {
+    gasLimit: bigint;
+};
+/**
+ * `sent === false` on a thrown error marks a failure from BEFORE any transaction left the
+ * process — simulation, gas estimation, the fee estimate, the balance guard. A caller that
+ * requeues work on failure (the batcher) reads it here to tell "nothing was sent", a plain
+ * size or availability signal that is safe to resubmit, from "the send's answer was lost",
+ * where the transaction may already have landed. A failure thrown after `writeContract` —
+ * including the sponsor's own send, whose operation may still be in flight — is never marked.
+ */
+export declare function failedBeforeSend(error: unknown): boolean;
+/** A "still waiting for Monad" line ticks this often while a send is in flight (in-15 J-4). */
+export declare const SEND_PROGRESS_EVERY_MS = 15000;
+/** The most a send waits on Monad before reporting what it honestly knows (in-15 J-4). */
+export declare const SEND_CAP_MS = 120000;
+/**
+ * The gate a send checks in the same synchronous stretch as every broadcast point — once the
+ * watchdog's cap has fired, a slow pre-send step (a simulate, an estimate, a top-up's own
+ * receipt wait) resolving late must not turn the refusal the caller already saw into a real
+ * send (in-16 K-1). The check and the send call sit back to back so no timer can run between
+ * them; after it throws, the abandoned work promise unwinds without broadcasting.
+ */
+export interface SendGate {
+    checkAbandoned(): void;
+}
+/**
+ * Whether a sponsor failure falls back to paying gas from the user's own wallet. The testnet
+ * probe's step f (docs/evidence/m3-sponsor-probe.json, Sep 21) measured that a 7702-delegated
+ * address holding under 10 MON CAN still pay its own gas, so the fallback is safe — the
+ * reviewer flips this constant if a later probe or a Monad change breaks that finding, and the
+ * fallback message becomes a refusal with instructions instead.
+ */
+export declare const SPONSOR_FALLBACK_TO_SELF_PAY = true;
+/**
+ * Simulates first so a revert surfaces as a named contract error mapped to a protocol code. The
+ * simulate is an `eth_call` carrying no gas field — it runs from a wallet holding nothing, which
+ * is exactly why it may stay on the sponsored path (M3-D3). With a sponsor set the sponsor is
+ * asked next, with NO owner-side `estimateContractGas`: that estimate is `eth_estimateGas` with
+ * the owner as sender, which Monad refuses for a wallet that cannot afford the worst case — the
+ * very wallet a sponsor exists for. The bundler estimates the operation instead, and the kind's
+ * ceiling is checked inside the sponsored sender against the bundler's own `callGasLimit`.
+ *
+ * Only the self-paid path — no sponsor, or a sponsor that refused before accepting — runs the
+ * estimate, the ceiling check and the balance guard: the send is refused above the kind's
+ * ceiling (Monad bills the limit, not the usage), and within it goes out with `gas` set
+ * explicitly to the estimate — no padding. A receipt with status "reverted" (for example a
+ * Monad reserve-balance revert after inclusion) is an error, never a silent success.
+ */
+export declare function sendContract(context: WriteContext, call: {
+    address: Address;
+    abi: Abi;
+    functionName: string;
+    args: readonly unknown[];
+}, kind: TxKind, 
+/** A nested send inherits the outer send's abandonment through this — see watchSend. */
+outerGate?: SendGate): Promise<SentReceipt>;
+/**
+ * A plain value transfer under the same ceiling rule: the node's estimate is the explicit `gas`
+ * on the send, refused above the kind's ceiling. Used for environment funding (R3-1).
+ */
+export declare function sendValue(context: WriteContext, transfer: {
+    to: Address;
+    value: bigint;
+}, kind: TxKind, 
+/** A nested send inherits the outer send's abandonment through this — see watchSend. */
+outerGate?: SendGate): Promise<SentReceipt>;
+/**
+ * Operator-side agent registration (§4.3). The proposed signer signs MidaAgentRegistrationV1 over every field;
+ * the contract fixes encryptionKeyVersion and capabilityManifestVersion at 1.
+ */
+export declare function registerAgent(context: WriteContext, input: {
+    agentSalt: Hex;
+    signer: LocalAccount;
+    encryptionPublicKey: Hex;
+    callbackOrigin: string;
+    capabilityManifestHash: Hex;
+}): Promise<{
+    agentId: Hex;
+    receipt: TransactionReceipt;
+}>;

package/dist/types/crypto/aead.d.ts

@@ -0,0 +1,5 @@
+export declare const KEY_BYTES = 32;
+export declare const NONCE_BYTES = 24;
+export declare const TAG_BYTES = 16;
+export declare function seal(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, plaintext: Uint8Array): Uint8Array;
+export declare function open(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, ciphertext: Uint8Array): Uint8Array;

package/dist/types/crypto/bytes.d.ts

@@ -0,0 +1,4 @@
+import type { Hex } from "../protocol/index.js";
+export declare function hexOf(bytes: Uint8Array): Hex;
+export declare function bytesOf(hex: string, byteLength: number): Uint8Array;
+export declare function assertNonZeroKey(bytes: Uint8Array, label: string): void;

package/dist/types/crypto/derive.d.ts

@@ -0,0 +1,20 @@
+import type { Hex, IsolationDomain } from "../protocol/index.js";
+export declare const ISOLATION_DOMAINS: readonly IsolationDomain[];
+/** §6.1: SHA256(UTF8("mida/context/prf/<domain>/v1")). */
+export declare function prfSalt(domain: IsolationDomain): Uint8Array;
+/** §6.2: HKDF-SHA256(ikm = PRF_D, salt = namespaceId, info, 32). */
+export declare function deriveNamespaceSecret(domainPrfOutput: Uint8Array, namespaceId: Hex): Uint8Array;
+export declare function uint64be(value: bigint): Uint8Array;
+export interface X25519KeyPair {
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+}
+export interface EpochKeyPair extends X25519KeyPair {
+    readEpoch: bigint;
+}
+/** §7.1: epochSeed = HKDF-SHA256(namespaceSecret, uint64be(readEpoch), info, 32); noble clamps the scalar. */
+export declare function deriveEpochKeyPair(namespaceSecret: Uint8Array, readEpoch: bigint): EpochKeyPair;
+export declare function x25519PublicKey(privateKey: Uint8Array): Uint8Array;
+export declare function generateX25519KeyPair(): X25519KeyPair;
+/** §7.1: reject an all-zero public key or shared secret before any HKDF. */
+export declare function x25519SharedSecret(privateKey: Uint8Array, publicKey: Uint8Array): Uint8Array;

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

@@ -0,0 +1,6 @@
+export * from "./bytes.js";
+export * from "./derive.js";
+export * from "./aead.js";
+export * from "./payload.js";
+export * from "./wraps.js";
+export * from "./object.js";

package/dist/types/crypto/object.d.ts

@@ -0,0 +1,42 @@
+import type { ContextPayload, EpochDEKWrap, Hex, ObjectManifest } from "../protocol/index.js";
+import type { ObjectBinding } from "./payload.js";
+/** §9.1: ciphertextHash = SHA256(ciphertextBytes). */
+export declare function ciphertextHash(ciphertext: Uint8Array): Hex;
+/** §9.1: manifestHash = keccak256(RFC 8785 canonical manifest bytes). */
+export declare function manifestHash(manifest: ObjectManifest): Hex;
+export declare function buildObjectManifest(input: {
+    contextId: Hex;
+    ciphertext: Uint8Array;
+    payloadNonce: Uint8Array;
+    readEpoch: bigint;
+    epochDekWrap: EpochDEKWrap;
+}): ObjectManifest;
+/**
+ * Checks, in order: the manifest matches its on-chain commitment, its embedded wrap belongs to the same
+ * object and epoch, and the ciphertext bytes match the committed hash and size. Runs before any decryption.
+ */
+export declare function verifyObjectManifest(input: {
+    manifest: ObjectManifest;
+    expectedManifestHash: Hex;
+    ciphertext: Uint8Array;
+}): void;
+export interface SealedContextObject {
+    ciphertext: Uint8Array;
+    manifest: ObjectManifest;
+    manifestHash: Hex;
+    ciphertextCommitment: Hex;
+}
+/** Encrypts a payload and wraps its DEK to the epoch public key. Needs only the public key (§7.1 CREATE). */
+export declare function sealContextObject(input: {
+    payload: ContextPayload;
+    binding: ObjectBinding;
+    epochPublicKey: Uint8Array;
+}): SealedContextObject;
+/** Verifies commitments, unwraps the DEK with the epoch private key, and decrypts (§7.1 READ). */
+export declare function openContextObject(input: {
+    manifest: ObjectManifest;
+    expectedManifestHash: Hex;
+    ciphertext: Uint8Array;
+    epochPrivateKey: Uint8Array;
+    binding: ObjectBinding;
+}): ContextPayload;

package/dist/types/crypto/payload.d.ts

@@ -0,0 +1,21 @@
+import type { Address, ContextPayload, Hex } from "../protocol/index.js";
+/** Values every object-level AAD binds (§8.2, §8.3). */
+export interface ObjectBinding {
+    chainId: bigint;
+    contextRegistry: Address;
+    contextId: Hex;
+    namespaceId: Hex;
+    readEpoch: bigint;
+}
+export declare function payloadAad(binding: ObjectBinding): Uint8Array;
+export declare function epochDekWrapAad(binding: ObjectBinding): Uint8Array;
+export declare function encodePayload(payload: ContextPayload): Uint8Array;
+export declare function decodePayload(bytes: Uint8Array): ContextPayload;
+export interface EncryptedPayload {
+    ciphertext: Uint8Array;
+    nonce: Uint8Array;
+    dek: Uint8Array;
+}
+/** §8.2: fresh random DEK and nonce for every object. */
+export declare function encryptPayload(payload: ContextPayload, binding: ObjectBinding): EncryptedPayload;
+export declare function decryptPayload(encrypted: EncryptedPayload, binding: ObjectBinding): ContextPayload;

package/dist/types/crypto/wraps.d.ts

@@ -0,0 +1,36 @@
+import type { Address, EpochDEKWrap, Hex, ReaderEpochWrap } from "../protocol/index.js";
+import type { ObjectBinding } from "./payload.js";
+/** §8.3: wrap an object DEK to the namespace epoch public key. */
+export declare function wrapDekToEpoch(input: {
+    dek: Uint8Array;
+    epochPublicKey: Uint8Array;
+    binding: ObjectBinding;
+}): EpochDEKWrap;
+export declare function unwrapDekFromEpoch(input: {
+    wrap: EpochDEKWrap;
+    epochPrivateKey: Uint8Array;
+    binding: ObjectBinding;
+}): Uint8Array;
+/** Values the reader-wrap AAD binds (§8.4). */
+export interface ReaderBinding {
+    chainId: bigint;
+    capabilityRegistry: Address;
+    owner: Address;
+    namespaceId: Hex;
+    readEpoch: bigint;
+    agentId: Hex;
+    agentKeyVersion: number;
+}
+export declare function readerEpochWrapAad(binding: ReaderBinding): Uint8Array;
+/** §8.4: wrap an epoch private key to one agent's registered X25519 key and version. */
+export declare function wrapEpochPrivateKeyToAgent(input: {
+    epochPrivateKey: Uint8Array;
+    agentEncryptionPublicKey: Uint8Array;
+    binding: ReaderBinding;
+    createdAt: bigint;
+}): ReaderEpochWrap;
+export declare function unwrapEpochPrivateKey(input: {
+    wrap: ReaderEpochWrap;
+    agentEncryptionPrivateKey: Uint8Array;
+    binding: ReaderBinding;
+}): Uint8Array;

package/dist/types/grant-advisor/advise.d.ts

@@ -0,0 +1,23 @@
+import type { AccessRequest, AgentRecord, GrantAdvice, OwnerAgentHistory, SignedAgentCapabilityManifest } from "../protocol/index.js";
+/** §14.5. There is deliberately no field for model output, explanations or reputation. */
+export interface GrantAdvisorInput {
+    request: AccessRequest;
+    manifest: SignedAgentCapabilityManifest;
+    agentRecord: AgentRecord;
+    ownerHistory: OwnerAgentHistory;
+    now: bigint;
+}
+export declare const MAX_REQUEST_WINDOW_SECONDS = 600n;
+/**
+ * The request's own validity window. It needs only the request and the chain's clock — one
+ * getBlock — so callers check it BEFORE paying for the agent-record and owner-history reads the
+ * full advisor needs: an expired request refuses cheaply, with the same REQUEST_EXPIRED the
+ * full check below would throw (in-15 J-2). assertRequestIsCurrent calls this too, so nothing
+ * that reaches the signature checks escapes it.
+ */
+export declare function assertRequestFresh(request: AccessRequest, now: bigint): void;
+/**
+ * §14.5 deterministic Grant Advisor. Pure and synchronous: identical input gives identical output.
+ * The recommendation is always a subset of the signed request; the function throws rather than return one that is not.
+ */
+export declare function adviseGrant(input: GrantAdvisorInput): GrantAdvice;

package/dist/types/grant-advisor/authority.d.ts

@@ -0,0 +1,44 @@
+import type { AccessGrantResponse, AccessRequest, EffectiveAuthority, GrantScope, RequestedScope } from "../protocol/index.js";
+export declare const HIGH_FINAL_SELECTION_CAP_SECONDS: bigint;
+/** Builder-facing scope: a namespace string (parent allowed) plus permission and provenance bits. */
+export interface ScopeInput {
+    namespace: string;
+    permissions: number;
+    provenancePolicy?: number;
+}
+/**
+ * §5.3: canonicalize every namespace, expand parents through frozen tree v1, merge bits per exact
+ * namespace, and return sorted canonical scopes. This is the only way builder input becomes signed authority.
+ */
+export declare function expandScopeInputs(inputs: readonly ScopeInput[]): RequestedScope[];
+/**
+ * §14.5 exact authority tuples: one per (namespace, permission), plus one per (namespace, permission, provenance policy).
+ * Tuple containment is equivalent to per-namespace bit containment; a property test proves it.
+ */
+export declare function effectiveAuthority(scopes: readonly RequestedScope[]): EffectiveAuthority[];
+export declare const authorityKey: (tuple: EffectiveAuthority) => string;
+export declare function isAuthoritySubset(candidate: readonly EffectiveAuthority[], requested: readonly EffectiveAuthority[]): boolean;
+/**
+ * Same rule the contract enforces in grantBatch: every candidate namespace is requested, with no extra bits.
+ * Out-of-range bit values on either side fail the bound check before any bitwise operator runs.
+ */
+export declare function isScopeSubset(candidate: readonly RequestedScope[], requested: readonly RequestedScope[]): boolean;
+/** A shorter expiry is narrower. Requested 0 means unbounded, so any value fits; a finite request never becomes unbounded. */
+export declare function isExpiryWithin(candidate: bigint, requested: bigint): boolean;
+/**
+ * The user's final choice (§14.5, §14.4, §10.4 rule 7). Used by FakeVault before signing and by the SDK on completion.
+ * The user may pick ELEVATED or undeclared authority, but never anything outside the signed request.
+ */
+export declare function assertFinalSelection(input: {
+    requestedScopes: readonly RequestedScope[];
+    requestedExpiresAt: bigint;
+    finalScopes: readonly GrantScope[];
+    finalExpiresAt: bigint;
+    now: bigint;
+}): void;
+/**
+ * §13.3 off-chain half of completeAccessRequest: the response must echo the original request and grant only a
+ * subset of it with one expiry. Returns the sorted final scopes. The SDK must still prove each capability exists
+ * and is currently valid on Monad (Task 25); this function never reads the chain.
+ */
+export declare function assertGrantResponseWithinRequest(request: AccessRequest, response: AccessGrantResponse, now: bigint): GrantScope[];

package/dist/types/grant-advisor/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./policy.js";
+export * from "./signatures.js";
+export * from "./manifest.js";
+export * from "./authority.js";
+export * from "./advise.js";

package/dist/types/grant-advisor/manifest.d.ts

@@ -0,0 +1,66 @@
+import type { AgentCapabilityManifestBody, AgentRecord, Address, Hex, SignedAgentCapabilityManifest } from "../protocol/index.js";
+export declare const MANIFEST_LIMITS: Readonly<{
+    nameBytes: 80;
+    textBytes: 280;
+    purposes: 8;
+    scopeDeclarations: 32;
+}>;
+export declare function normalizeManifestBody(body: AgentCapabilityManifestBody): AgentCapabilityManifestBody;
+/** Enforces every §14.1 structural rule and limit on the NFC-normalized body. Sensitivity claims are rejected as unknown keys. */
+export declare function validateManifestBody(input: unknown, now: bigint): asserts input is AgentCapabilityManifestBody;
+export declare function manifestBodyHash(body: AgentCapabilityManifestBody): Hex;
+export declare function manifestEnvelopeBytes(envelope: SignedAgentCapabilityManifest): Uint8Array;
+export declare function manifestEnvelopeHash(envelope: SignedAgentCapabilityManifest): Hex;
+export declare function manifestBindingFor(input: {
+    chainId: bigint;
+    capabilityRegistry: Address;
+    body: AgentCapabilityManifestBody;
+}): {
+    domain: {
+        name: string;
+        version: string;
+        chainId: bigint;
+        verifyingContract: `0x${string}`;
+    };
+    types: {
+        readonly ManifestBinding: readonly [{
+            readonly name: "bodyHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "agentId";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "manifestVersion";
+            readonly type: "uint64";
+        }];
+    };
+    primaryType: "ManifestBinding";
+    message: {
+        bodyHash: `0x${string}`;
+        agentId: `0x${string}`;
+        manifestVersion: bigint;
+    };
+};
+/**
+ * §14.1 currentness check. Order: structure, agent identity, version, body hash, operator signature.
+ * An envelope is current only when its body hash and version equal the on-chain AgentRecord.
+ */
+export declare function verifySignedManifest(input: {
+    envelope: SignedAgentCapabilityManifest;
+    agentRecord: AgentRecord;
+    chainId: bigint;
+    capabilityRegistry: Address;
+    now: bigint;
+}): {
+    bodyHash: Hex;
+    envelopeHash: Hex;
+};
+/**
+ * For GET /agent-manifests/:bodyHash (§14.1): stored bytes must hash to the indexed envelope hash, be canonical,
+ * and contain a body whose hash is the requested body hash. The signature is checked later by verifySignedManifest.
+ */
+export declare function parseManifestEnvelopeBytes(input: {
+    bytes: Uint8Array;
+    expectedEnvelopeHash: Hex;
+    expectedBodyHash: Hex;
+}): SignedAgentCapabilityManifest;

package/dist/types/grant-advisor/policy.d.ts

@@ -0,0 +1,91 @@
+import type { Hex, Permission, ProvenancePolicy, PurposeId } from "../protocol/index.js";
+export type Sensitivity = "LOW" | "MEDIUM" | "HIGH";
+export type Classification = "EXPECTED" | "ELEVATED" | "SUSPICIOUS" | "UNCLASSIFIED";
+export interface PolicyEntry {
+    readonly namespace: string;
+    readonly permissions: readonly Permission[];
+    readonly provenancePolicies: readonly ProvenancePolicy[];
+}
+export interface PurposePolicy {
+    readonly expected: readonly PolicyEntry[];
+    readonly elevated: readonly PolicyEntry[];
+    readonly suspicious: "ALL_HIGH";
+}
+export interface PurposeRule {
+    classification: Classification;
+    permissions: number;
+    provenancePolicy: number;
+}
+/**
+ * The canonical policy document for mida-grant-policy-v1 (§14.2–§14.4).
+ * Its RFC 8785 keccak256 hash is POLICY_HASH_V1, which Solidity mirrors as a constant (Task 14).
+ * Changing any byte here is a new policy version, never an edit.
+ */
+export declare const POLICY_DOCUMENT_V1: {
+    readonly v: 1;
+    readonly policyVersion: "mida-grant-policy-v1";
+    readonly namespaceTreeVersion: "mida-namespace-tree-v1";
+    readonly sensitivity: {
+        readonly LOW: readonly ["preferences", "preferences.communication", "preferences.tools", "preferences.work", "profile.skills", "projects.current"];
+        readonly MEDIUM: readonly ["profile", "profile.identity", "goals", "goals.career", "goals.learning", "goals.personal", "projects", "projects.past", "decisions", "decisions.career", "decisions.projects", "relationships"];
+        readonly HIGH: readonly ["credentials", "financial", "financial.preferences", "private"];
+    };
+    readonly consent: {
+        readonly LOW: "normal_approval";
+        readonly MEDIUM: "explicit_justification";
+        readonly HIGH: "warning_and_individual_selection";
+    };
+    readonly durationCapsSeconds: {
+        readonly LOW: 2592000;
+        readonly MEDIUM: 604800;
+        readonly HIGH: 86400;
+    };
+    readonly purposes: {
+        career_coaching: {
+            expected: PolicyEntry[];
+            elevated: PolicyEntry[];
+            suspicious: "ALL_HIGH";
+        };
+        general_assistance: {
+            expected: PolicyEntry[];
+            elevated: PolicyEntry[];
+            suspicious: "ALL_HIGH";
+        };
+        project_assistance: {
+            expected: PolicyEntry[];
+            elevated: PolicyEntry[];
+            suspicious: "ALL_HIGH";
+        };
+        travel_planning: {
+            expected: PolicyEntry[];
+            elevated: PolicyEntry[];
+            suspicious: "ALL_HIGH";
+        };
+    };
+    readonly rules: {
+        readonly neverDefault: readonly ["ELEVATED", "SUSPICIOUS", "UNCLASSIFIED", "UNDECLARED", "HIGH", "SUPERSEDE_ANY"];
+        readonly elevatedProvenancePolicies: readonly ["ALLOW_IMPORTED", "ALLOW_EXTERNAL_ATTESTATION"];
+        readonly inferenceRequiresManifestAndPurpose: true;
+        readonly provenanceRequiresWritePermission: true;
+        readonly broadParentScopeWarning: true;
+        readonly highFinalSelectionCapSeconds: 86400;
+        readonly singleExpiryPerBatch: true;
+        readonly selectAllExcludesHigh: true;
+    };
+};
+export declare const POLICY_HASH_V1: Hex;
+export declare const PURPOSE_IDS: readonly PurposeId[];
+export declare const DURATION_CAP_SECONDS: Readonly<Record<Sensitivity, bigint>>;
+export declare const ELEVATED_PROVENANCE_BITS: number;
+export declare const WRITE_PERMISSION_BITS: number;
+export declare function isPurposeId(value: string): value is PurposeId;
+export declare function stricterSensitivity(a: Sensitivity, b: Sensitivity): Sensitivity;
+/** A namespace's effective sensitivity is at least that of everything it expands to (§14.2). */
+export declare function sensitivityOf(namespace: string): Sensitivity;
+export declare function sensitivityOfId(namespaceId: Hex): Sensitivity;
+export declare function permissionBits(names: readonly Permission[]): number;
+export declare function provenancePolicyBits(names: readonly ProvenancePolicy[]): number;
+export declare function permissionNames(bits: number): Permission[];
+export declare function provenancePolicyNames(bits: number): ProvenancePolicy[];
+/** Exact (purpose, namespace) classification under §14.3. HIGH is always SUSPICIOUS. */
+export declare function classifyScope(purposeId: PurposeId, namespaceId: Hex): PurposeRule;

package/dist/types/grant-advisor/signatures.d.ts

@@ -0,0 +1,10 @@
+import type { AccessRequest, Address, Hex } from "../protocol/index.js";
+import type { TypedDataDefinition } from "viem";
+/**
+ * Synchronous EIP-712 signer recovery. viem's verifyTypedData is async, but adviseGrant is a pure
+ * synchronous function (§14.5), so recovery uses viem's hashTypedData plus ox's secp256k1 recovery.
+ * Tests cross-check the result against viem's verifyTypedData. EOA signers only; ERC-1271 is not supported.
+ */
+export declare function recoverTypedDataSigner(typedData: TypedDataDefinition, signature: Hex): Address | null;
+export declare function isTypedDataSignedBy(typedData: TypedDataDefinition, signature: Hex, expected: Address): boolean;
+export declare function assertAccessRequestSignature(request: AccessRequest, signer: Address): void;

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

@@ -0,0 +1,27 @@
+/**
+ * Where the Mida home lives for this SDK: the `home` option, then `$MIDA_HOME` (absolute, like
+ * the CLI insists), then `~/.mida`. The SDK never creates the folder — a home that does not
+ * exist simply means the service is not running.
+ */
+export declare function resolveMidaHome(home: string | undefined, env?: Record<string, string | undefined>): string;
+/**
+ * The same socket path the daemon computes: `<home>/midad.sock`, a pointer file
+ * (`midad.sock.path`) winning when present, and the per-user fallback folder
+ * `<base>/mida-<uid>/mida-<16 hex of sha256(home)>.sock` when the direct path is too long.
+ * Must stay byte-for-byte equivalent to control.ts's `socketPathFor` — the daemon writes the
+ * pointer for exactly the cases the computed path would miss.
+ */
+export declare function socketPathFor(home: string, base?: string): string;
+export interface DaemonReply {
+    /** 0 means no answer — no socket, refused connection, timeout, or a non-JSON body. */
+    status: number;
+    body: unknown;
+}
+/**
+ * One JSON call to the daemon over the private socket. Never throws and never hangs: any failure
+ * resolves to status 0, and the caller turns that into `service-unavailable`. A body of
+ * `undefined` sends GET; anything else is POSTed as JSON.
+ */
+export declare function callDaemon(home: string, path: string, body: unknown, options: {
+    timeoutMs: number;
+}): Promise<DaemonReply>;

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

@@ -0,0 +1,27 @@
+/**
+ * Every failure an SDK call can raise carries one of these codes. The SDK's own codes say why the
+ * call never left this machine (or never could); the rest are the Mida service's refusal reasons,
+ * passed through unchanged so a caller can key on exactly what the daemon said.
+ */
+export type MidaSdkErrorCode = "transport-unavailable" | "invalid-option" | "service-unavailable" | "service-refused" | "failed" | "bad-agent" | "bad-input" | "no-identity" | "identity-unreadable" | "general-assistance" | "not-a-project" | "folder-mismatch" | "list-tampered" | "list-unreadable" | "check-failed" | "already-approved" | "not-approved" | "revoked" | "revoke-pending" | "read-only" | "rate-limited" | "invalid-shape" | "invalid-content" | "invalid-namespace" | "too-large" | "not-found" | "partial-read" | "chain-busy" | "chain-misconfigured" | "rpc-auth" | "store-misconfigured" | "store-rpc-auth";
+/**
+ * The one error the SDK throws. `code` names the failure class; the message is one plain sentence
+ * that says what did NOT happen — no provider URL, key or raw upstream message ever reaches it.
+ */
+export declare class MidaSdkError extends Error {
+    readonly code: MidaSdkErrorCode;
+    /** The service's own refusal reason — present only when it is not the code itself. */
+    readonly serviceReason?: string;
+    /** Which save lane a `rate-limited` refusal names — set only on that code. */
+    readonly lane?: "direct" | "batched";
+    constructor(code: MidaSdkErrorCode, message: string, options?: {
+        cause?: unknown;
+        serviceReason?: string;
+        lane?: "direct" | "batched";
+    });
+}
+/** Maps the service's refusal reason onto an SDK code — verbatim when known, `service-refused` when not. */
+export declare function serviceRefusal(reason: string, text: string, options?: {
+    lane?: "direct" | "batched";
+}): MidaSdkError;
+export declare function isMidaSdkError(error: unknown, code?: MidaSdkErrorCode): error is MidaSdkError;

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

@@ -0,0 +1,5 @@
+export { Mida } from "./mida.js";
+export type { MidaOptions, TransportKind } from "./mida.js";
+export { MidaSdkError, isMidaSdkError, serviceRefusal } from "./errors.js";
+export type { MidaSdkErrorCode } from "./errors.js";
+export type { ContextInput, ContextItem, ContextResult, HandoffAnswer, RememberInput, RememberResult, RequestAccessResult, StatusAnswer, Transport, VerifyCheck, VerifyResult, WhatsNewAnswer, } from "./transport.js";