@maiaos/sdk 0.1.0-canary.2

package/README.md

@@ -0,0 +1,177 @@
+# `@maiaos/sdk`
+
+[![npm canary](https://img.shields.io/npm/v/@maiaos/sdk/canary?label=npm%20canary)](https://www.npmjs.com/package/@maiaos/sdk)
+
+The TypeScript SDK for Maia Node: typed, validated calls to create and start
+AI coding agent Sessions (Claude Code, Codex), send turns, wait for results,
+read receipts and observe events, from any Node.js tool or Maia client.
+
+`@maiaos/sdk` is the only supported request boundary between product clients
+and Maia Node. The `maia` CLI, the `maia mcp` MCP server and the Desktop and
+Expo clients all use it. Use it when you build your own tool or orchestrator on
+top of a local Node; it transports typed operations but never owns business
+authority.
+
+## Install
+
+```sh
+pnpm add @maiaos/sdk@canary
+```
+
+Only `canary` builds are published. They are not release-qualified and can lag
+the source in this repository; npm's automatic `latest` tag also points at a
+canary build. A Node must be running locally (see the
+[quick start](../../README.md#quick-start)).
+
+## Example
+
+```ts
+import { connectNodeApi } from "@maiaos/sdk/node";
+
+const { client, status } = await connectNodeApi({ profile: "default" });
+console.log(status.lifecycle); // "ready"
+
+const projects = await client.listProjects(
+  { afterCursor: "0", limit: 20 },
+  { messageId: "request_projects_1" },
+);
+for (const project of projects.items) console.log(project.id, project.name);
+```
+
+`connectNodeApi` finds the profile's private connection descriptor, reads its
+credential and proves the Node's identity with an authenticated `node.status`
+before it returns the client.
+
+## Key concepts
+
+- **One typed client.** `LocalNodeClient` has one method per operation, for
+  example `createSession`, `startSession`, `sendTurn`, `waitTurns`,
+  `observeSessions`, `stopSession`, `resumeSession`, `diffSession`,
+  `archiveSession`, `getReceipt`,
+  `listConnections` and `showConnectionUsage`. Parameters and results are the
+  `@maiaos/protocol` types, validated on both sides. Human-only methods such as
+  `previewHoldPlace`, `confirmHoldPlace`, `previewHoldRelease`,
+  `confirmHoldRelease` and `listHolds` check that the Node echoes the exact
+  binding they sent.
+- **Typed call.** `call(method, parameters, options)` serves every operation
+  whose feature descriptor binds `sdk.operation: "call"` (today
+  `reference.resolve` and `session.rename`; `LOCAL_NODE_CALL_METHODS` lists
+  them from a static table the type checker holds to the descriptors, so a
+  client does not bundle the feature registry): parameters and results are
+  typed from the protocol unions, the payload is validated before sending,
+  and the answer must name the method and, for a command, carry a receipt
+  with the command ID sent. An unconfirmed command fails `outcome_unknown`.
+  Such an operation has no method of its own.
+- **Request options.** Every call takes `{ messageId, signal? }`. The
+  `AbortSignal` cancels the request; a mutation cancelled after dispatch
+  reports `outcome_unknown` instead of guessing.
+- **Errors.** Failures are `MaiaClientError` values with a stable code
+  (`transport_failure`, `cancelled`, `outcome_unknown`, `remote_error`, ...)
+  and, for Node rejections, the protocol error. Reconcile an unknown outcome
+  with `getReceipt` and the same command ID; never retry with a new one.
+- **Errors as one value.** `classifyClientError` turns any failure into a
+  `MaiaError` (`_tag: "MaiaError"`); `mutation: true` marks a request that may
+  have changed Node state. Its `kind` is `cancelled`, `conflict`, `declined` (a person declined the
+  native confirmation; nothing was sent), `denied`, `invalid`, `not_found`,
+  `offline`, `outcome_unknown` (a mutation's answer never arrived), `refused`
+  or `unavailable`, plus the Node's `code` and `retryable`. The CLI and
+  clients act on `kind`, never on a code string.
+- **Session tasks.** `planSessionCreation` splits text into tasks (one per
+  line, or the whole text; at most 32 of at most 16 KiB each), picks the
+  Workspace (a Project's ready Workspaces, its main checkout first, through
+  `orderExecutionWorkspaces`; a choice for the caller, which the Node still
+  validates) and mints every command ID once. `createSessions` runs each
+  item, four at a time: `session.create`, `session.start`,
+  `awaitSessionRunning`, then the task as the first `turn.send`. Each item
+  ends `sent` (or `started` without a task), `refused` with its `MaiaError`,
+  or `unknown`. Each outcome has a required `receipts` field with the Node's
+  receipt of every step that committed (`create`, `start`, `send`; `{}`
+  before any). When `session.create`, `session.start` or `turn.send` fails,
+  refused or unknown, the error carries that step's `commandId`; only an
+  `unknown` one needs reconciling with `receipt.get`. A `session.show`
+  failure has none. A caller passing hand-built `previous` outcomes adds
+  `receipts: {}`. Called again with `previous` outcomes, it replays only the
+  unsettled items with the same command IDs and request bodies, so the Node
+  answers with the original Sessions and turns and no turn is sent twice.
+  The SDK composes existing operations here and owns no authority.
+  `@maiaos/sdk/node/effect` has the same as `planSessionCreationEffect`,
+  `createSessionsEffect` and `awaitSessionRunningEffect`.
+- **Node changes.** `watchNodeChanges(relay, { instanceId, newId })` builds
+  each `observe.events` subscribe message, checks every frame's size, schema
+  and correlation, and yields `records` and `resync` changes; when the
+  platform `StreamRelay` closes it resubscribes from the last cursor, and a
+  gap or reset yields a `resync`. `reduceNodeChanges` is the pure frame
+  step.
+- **Session attach (S12b).** `attachSession` (`@maiaos/sdk/node`) yields one
+  Session's `session.attach` frames; `attachSessionEffect`
+  (`@maiaos/sdk/node/effect`) discovers the Node first. The pure
+  `reduceSessionAttach` reducer in the root entry folds frames into the view
+  every client renders, with `sessionAttachCursor` for a reattach.
+- **Transport limits.** The Node.js adapter accepts only the exact
+  `127.0.0.1` origin, bounds bodies to 1 MiB, admits eight concurrent
+  requests per transport and applies a five-second deadline.
+
+| Entry point                      | Contents                                                                                                                                                                                                                                                                                                             |
+| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@maiaos/sdk`                    | Platform-neutral `LocalNodeClient`, request options, errors, attach reducer                                                                                                                                                                                                                                          |
+| `@maiaos/sdk/node`               | `connectNodeApi`, `createNodeApiClient` and WebSocket observations (Node.js)                                                                                                                                                                                                                                         |
+| `@maiaos/sdk/node/effect`        | The same discovery and client as Effect values, for Effect programs (Node.js); `connectSessionNodeApiEffect` connects as one executor Session from its launch environment; `openNodeBridge` speaks the SSH stdio bridge over a process the caller spawned, with `sshCommandArguments` and `bridgeScript` to build it |
+| `@maiaos/sdk/voice-orchestrator` | Voice orchestrator prompt and tool schemas for Realtime clients                                                                                                                                                                                                                                                      |
+| `@maiaos/sdk/voice-pi-relay`     | Voice-to-Pi relay contracts                                                                                                                                                                                                                                                                                          |
+
+Browser and mobile bundles import only the root entry, so they never receive
+Node.js filesystem modules or the profile credential.
+
+## Status
+
+Source-implemented candidate. Methods mirror the registered operations; many
+are release-disabled at the Node. The SDK never starts or stops a Node, reads
+Node storage or supervises processes.
+
+### Target observation client
+
+Planned, not exported: one aggregate, transport-neutral observation client
+generated from the protocol.
+
+```ts
+client.observations.snapshot(query, options);
+client.observations.subscribe(query, { after, signal });
+client.observations.session({ agentSessionId, includeContent }, options);
+client.observations.pipeline({ processorId, partitionId }, options);
+```
+
+`subscribe` opens one authorized feed for any number of Projects and Sessions
+with a signed, resumable cursor; slow consumers get typed gap and reset
+results rather than backpressuring workers. A generated, reflective operation
+catalog (`client.operations.list`, `show`, `invoke`) is also planned.
+
+## How it fits in Maia
+
+```text
+product client ──► @maiaos/sdk ── authenticated loopback HTTP ──► Maia Node
+                        │
+                        └── types and schemas from @maiaos/protocol
+```
+
+See [`ARCHITECTURE.md`](../../ARCHITECTURE.md) and the
+[Node README](../../services/node/README.md).
+
+## Development
+
+```sh
+pnpm --filter @maiaos/sdk build
+pnpm --filter @maiaos/sdk lint
+pnpm --filter @maiaos/sdk typecheck
+pnpm --filter @maiaos/sdk test
+```
+
+## Documentation
+
+- [Normative contracts](../../docs/reference/contracts.md)
+- [CLI reference](../../docs/reference/cli.md) for the JSON projections of the
+  same operations
+- [`@maiaos/protocol`](../protocol/README.md)
+
+## License
+
+No license has been published yet. All rights reserved.

package/dist/agent-permission/agent-permission.d.ts

@@ -0,0 +1,9 @@
+import type { AgentPermissionConfirmParameters, AgentPermissionConfirmResult, AgentPermissionPreviewParameters, AgentPermissionPreviewResult } from "@maiaos/protocol";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+export declare const makeAgentPermissionClient: (request: LocalNodeRequester) => AgentPermissionClient;
+export type AgentPermissionClient = {
+    readonly confirmAgentPermission: (parameters: AgentPermissionConfirmParameters, options: LocalNodeRequestOptions) => Promise<AgentPermissionConfirmResult>;
+    readonly previewAgentPermission: (parameters: AgentPermissionPreviewParameters, options: LocalNodeRequestOptions) => Promise<AgentPermissionPreviewResult>;
+};
+export { type AgentPermissionConfirmParameters, agentPermissionConfirmParametersSchema, type AgentPermissionConfirmResult, type AgentPermissionPreviewParameters, agentPermissionPreviewParametersSchema, type AgentPermissionPreviewResult, } from "@maiaos/protocol";
+//# sourceMappingURL=agent-permission.d.ts.map

package/dist/agent-permission/agent-permission.js

@@ -0,0 +1,5 @@
+import { fromPromiseRequester, toPromiseClient } from "../request/effect.js";
+import { makeAgentPermissionOperations } from "./effect.js";
+export const makeAgentPermissionClient = (request) => toPromiseClient(makeAgentPermissionOperations(fromPromiseRequester(request)));
+export { agentPermissionConfirmParametersSchema, agentPermissionPreviewParametersSchema, } from "@maiaos/protocol";
+//# sourceMappingURL=agent-permission.js.map

package/dist/agent-permission/effect.d.ts

@@ -0,0 +1,4 @@
+import type { EffectClient, LocalNodeEffectRequester } from "../request/effect.js";
+import type { AgentPermissionClient } from "./agent-permission.js";
+export declare const makeAgentPermissionOperations: <TError>(request: LocalNodeEffectRequester<TError>) => EffectClient<AgentPermissionClient, TError>;
+//# sourceMappingURL=effect.d.ts.map

package/dist/agent-permission/effect.js

@@ -0,0 +1,34 @@
+import { agentPermissionConfirmResultSchema, agentPermissionPreviewResultSchema, } from "@maiaos/protocol";
+import { MaiaClientError } from "../request/index.js";
+const requireBinding = (result, parameters) => {
+    const operations = [...new Set(parameters.operationIds)].sort();
+    if (result.commandId !== parameters.commandId ||
+        result.sessionId !== parameters.sessionId ||
+        result.workspaceId !== parameters.workspaceId ||
+        result.expectedSessionRevision !== parameters.expectedSessionRevision ||
+        result.expectedWorkspaceRevision !== parameters.expectedWorkspaceRevision ||
+        result.definitionRef.key !== parameters.definitionRef.key ||
+        result.definitionRef.version !== parameters.definitionRef.version ||
+        result.definitionRef.contentDigest !==
+            parameters.definitionRef.contentDigest ||
+        result.operationIds.length !== operations.length ||
+        result.operationIds.some((id, index) => id !== operations[index]))
+        throw new MaiaClientError("invalid_response", "The Agent permission response did not match the request.");
+    return result;
+};
+const parseConfirmation = (value, parameters) => {
+    const result = agentPermissionConfirmResultSchema.parse(value);
+    requireBinding(result.grant, parameters);
+    if (result.grant.inputDigest !== parameters.inputDigest)
+        throw new MaiaClientError("invalid_response", "The Agent permission digest did not match the request.");
+    return result;
+};
+export const makeAgentPermissionOperations = (request) => ({
+    confirmAgentPermission: (parameters, options) => request({ method: "session.agent-permission.confirm", parameters }, {
+        parse: (value) => parseConfirmation(value, parameters),
+    }, options),
+    previewAgentPermission: (parameters, options) => request({ method: "session.agent-permission.preview", parameters }, {
+        parse: (value) => requireBinding(agentPermissionPreviewResultSchema.parse(value), parameters),
+    }, options),
+});
+//# sourceMappingURL=effect.js.map

package/dist/agent-permission/index.d.ts

@@ -0,0 +1,2 @@
+export { type AgentPermissionClient, type AgentPermissionConfirmParameters, agentPermissionConfirmParametersSchema, type AgentPermissionConfirmResult, type AgentPermissionPreviewParameters, agentPermissionPreviewParametersSchema, type AgentPermissionPreviewResult, makeAgentPermissionClient, } from "./agent-permission.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/agent-permission/index.js

@@ -0,0 +1,2 @@
+export { agentPermissionConfirmParametersSchema, agentPermissionPreviewParametersSchema, makeAgentPermissionClient, } from "./agent-permission.js";
+//# sourceMappingURL=index.js.map

package/dist/approval/approval.d.ts

@@ -0,0 +1,10 @@
+import type { ApprovalListParameters, ApprovalListResult, ApprovalRespondParameters, ApprovalRespondResult, ApprovalShowParameters, ApprovalShowResult } from "@maiaos/protocol";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+export type ApprovalClient = {
+    readonly listApprovals: (parameters: ApprovalListParameters, options: LocalNodeRequestOptions) => Promise<ApprovalListResult>;
+    readonly respondToApproval: (parameters: ApprovalRespondParameters, options: LocalNodeRequestOptions) => Promise<ApprovalRespondResult>;
+    readonly showApproval: (parameters: ApprovalShowParameters, options: LocalNodeRequestOptions) => Promise<ApprovalShowResult>;
+};
+export declare const makeApprovalClient: (request: LocalNodeRequester) => ApprovalClient;
+export { type Approval, APPROVAL_ERROR_CODES, APPROVAL_SCHEMA_VERSION, APPROVAL_TTL_MILLISECONDS, type ApprovalErrorCode, type ApprovalListParameters, approvalListParametersSchema, type ApprovalListResult, approvalListResultSchema, type ApprovalRespondParameters, approvalRespondParametersSchema, type ApprovalRespondResult, approvalRespondResultSchema, approvalSchema, type ApprovalShowParameters, approvalShowParametersSchema, type ApprovalShowResult, approvalShowResultSchema, MAX_APPROVAL_PAGE_SIZE, } from "@maiaos/protocol";
+//# sourceMappingURL=approval.d.ts.map

package/dist/approval/approval.js

@@ -0,0 +1,5 @@
+import { fromPromiseRequester, toPromiseClient } from "../request/effect.js";
+import { makeApprovalOperations } from "./effect.js";
+export const makeApprovalClient = (request) => toPromiseClient(makeApprovalOperations(fromPromiseRequester(request)));
+export { APPROVAL_ERROR_CODES, APPROVAL_SCHEMA_VERSION, APPROVAL_TTL_MILLISECONDS, approvalListParametersSchema, approvalListResultSchema, approvalRespondParametersSchema, approvalRespondResultSchema, approvalSchema, approvalShowParametersSchema, approvalShowResultSchema, MAX_APPROVAL_PAGE_SIZE, } from "@maiaos/protocol";
+//# sourceMappingURL=approval.js.map

package/dist/approval/effect.d.ts

@@ -0,0 +1,5 @@
+import { type EffectClient, type LocalNodeEffectRequester } from "../request/effect.js";
+import { MaiaClientError } from "../request/index.js";
+import type { ApprovalClient } from "./approval.js";
+export declare const makeApprovalOperations: <TError>(request: LocalNodeEffectRequester<TError>) => EffectClient<ApprovalClient, MaiaClientError | TError>;
+//# sourceMappingURL=effect.d.ts.map

package/dist/approval/effect.js

@@ -0,0 +1,43 @@
+import { approvalListResultSchema, approvalRespondResultSchema, approvalShowResultSchema, } from "@maiaos/protocol";
+import { verifiedMutation, } from "../request/effect.js";
+import { MaiaClientError } from "../request/index.js";
+const requireMatch = (matches) => {
+    if (!matches)
+        throw new MaiaClientError("invalid_response", "The approval response did not match the request.");
+};
+const parseList = (value, input) => {
+    const result = approvalListResultSchema.parse(value);
+    requireMatch(result.items.length <= input.limit &&
+        result.items.every((item) => (input.sessionId === undefined ||
+            item.sessionId === input.sessionId) &&
+            (input.pendingOnly === false || item.status === "pending")));
+    return result;
+};
+const parseShow = (value, input) => {
+    const result = approvalShowResultSchema.parse(value);
+    requireMatch(result.approval.approvalId === input.approvalId);
+    return result;
+};
+const decided = (status, input, forSession) => {
+    if (input.decision === "answer")
+        return status === "answered";
+    if (input.decision === "deny")
+        return status === "denied";
+    return (status === "approved" &&
+        forSession === (input.decision === "approve_for_session"));
+};
+const parseRespond = (value, input) => {
+    const result = approvalRespondResultSchema.parse(value);
+    const { approval, commandId } = result;
+    requireMatch(commandId === input.commandId &&
+        approval.approvalId === input.approvalId &&
+        approval.requestDigest === input.requestDigest &&
+        decided(approval.status, input, approval.resolution?.forSession === true));
+    return result;
+};
+export const makeApprovalOperations = (request) => ({
+    listApprovals: (parameters, options) => request({ method: "approval.list", parameters }, { parse: (value) => parseList(value, parameters) }, options),
+    respondToApproval: (parameters, options) => verifiedMutation(request({ method: "approval.respond", parameters }, { parse: (value) => parseRespond(value, parameters) }, options), options),
+    showApproval: (parameters, options) => request({ method: "approval.show", parameters }, { parse: (value) => parseShow(value, parameters) }, options),
+});
+//# sourceMappingURL=effect.js.map

package/dist/approval/index.d.ts

@@ -0,0 +1,2 @@
+export { type Approval, APPROVAL_ERROR_CODES, APPROVAL_SCHEMA_VERSION, APPROVAL_TTL_MILLISECONDS, type ApprovalClient, type ApprovalErrorCode, type ApprovalListParameters, approvalListParametersSchema, type ApprovalListResult, approvalListResultSchema, type ApprovalRespondParameters, approvalRespondParametersSchema, type ApprovalRespondResult, approvalRespondResultSchema, approvalSchema, type ApprovalShowParameters, approvalShowParametersSchema, type ApprovalShowResult, approvalShowResultSchema, makeApprovalClient, MAX_APPROVAL_PAGE_SIZE, } from "./approval.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/approval/index.js

@@ -0,0 +1,2 @@
+export { APPROVAL_ERROR_CODES, APPROVAL_SCHEMA_VERSION, APPROVAL_TTL_MILLISECONDS, approvalListParametersSchema, approvalListResultSchema, approvalRespondParametersSchema, approvalRespondResultSchema, approvalSchema, approvalShowParametersSchema, approvalShowResultSchema, makeApprovalClient, MAX_APPROVAL_PAGE_SIZE, } from "./approval.js";
+//# sourceMappingURL=index.js.map

package/dist/call/call.d.ts

@@ -0,0 +1,26 @@
+import type { LocalNodeRequestPayload, LocalNodeSuccessResult } from "@maiaos/protocol";
+import type { MaiaRegisteredFeatureOperation } from "@maiaos/protocol/feature-registry";
+import type * as Effect from "effect/Effect";
+import type { LocalNodeRequestOptions } from "../request/index.js";
+type CallBoundOperation = Extract<MaiaRegisteredFeatureOperation, {
+    readonly sdk: {
+        readonly operation: "call";
+    };
+}>;
+export type LocalNodeCallMethod = CallBoundOperation["method"];
+export declare const LOCAL_NODE_CALL_ENTRIES: readonly [readonly ["session.rename", "command-id"], readonly ["reference.resolve", "none"]];
+export declare const LOCAL_NODE_CALL_METHODS: readonly LocalNodeCallMethod[];
+export type LocalNodeCallParameters<TMethod extends LocalNodeCallMethod> = Extract<LocalNodeRequestPayload, {
+    readonly method: TMethod;
+}>["parameters"];
+export type LocalNodeCallResult<TMethod extends LocalNodeCallMethod> = Extract<LocalNodeSuccessResult, {
+    readonly method: TMethod;
+}>;
+export type LocalNodeCallClient = {
+    readonly call: <TMethod extends LocalNodeCallMethod>(method: TMethod, parameters: LocalNodeCallParameters<TMethod>, options: LocalNodeRequestOptions) => Promise<LocalNodeCallResult<TMethod>>;
+};
+export type LocalNodeEffectCallClient<TError> = {
+    readonly call: <TMethod extends LocalNodeCallMethod>(method: TMethod, parameters: LocalNodeCallParameters<TMethod>, options: LocalNodeRequestOptions) => Effect.Effect<LocalNodeCallResult<TMethod>, TError>;
+};
+export {};
+//# sourceMappingURL=call.d.ts.map

package/dist/call/call.js

@@ -0,0 +1,6 @@
+export const LOCAL_NODE_CALL_ENTRIES = [
+    ["session.rename", "command-id"],
+    ["reference.resolve", "none"],
+];
+export const LOCAL_NODE_CALL_METHODS = LOCAL_NODE_CALL_ENTRIES.map(([method]) => method);
+//# sourceMappingURL=call.js.map

package/dist/call/effect.d.ts

@@ -0,0 +1,5 @@
+import { type LocalNodeEffectRequester } from "../request/effect.js";
+import { MaiaClientError } from "../request/index.js";
+import { type LocalNodeEffectCallClient } from "./call.js";
+export declare const makeCallOperation: <TError>(request: LocalNodeEffectRequester<TError>) => LocalNodeEffectCallClient<MaiaClientError | TError>;
+//# sourceMappingURL=effect.d.ts.map

package/dist/call/effect.js

@@ -0,0 +1,46 @@
+import { localNodeRequestPayloadSchema, localNodeSuccessResultSchema, } from "@maiaos/protocol";
+import * as Effect from "effect/Effect";
+import { verifiedMutation, } from "../request/effect.js";
+import { MaiaClientError } from "../request/index.js";
+import { LOCAL_NODE_CALL_ENTRIES, } from "./call.js";
+const isCallResult = (result, method) => result.method === method;
+const field = (value, name) => typeof value === "object" && value !== null
+    ? Reflect.get(value, name)
+    : undefined;
+const receiptMatches = (parameters, receipt) => {
+    const commandId = field(parameters, "commandId");
+    if (commandId === undefined)
+        return true;
+    const target = field(receipt, "target");
+    const type = field(target, "type");
+    const named = typeof type === "string" ? field(parameters, `${type}Id`) : undefined;
+    return (field(receipt, "commandId") === commandId &&
+        typeof named === "string" &&
+        field(target, "id") === named);
+};
+const parseCallResult = (method, parameters, value) => {
+    const result = localNodeSuccessResultSchema.parse(value);
+    if (isCallResult(result, method) &&
+        receiptMatches(parameters, field(result, "receipt")))
+        return result;
+    throw new MaiaClientError("invalid_response", `The ${method} response did not match the request.`);
+};
+const invalidCall = (method, cause) => new MaiaClientError("invalid_request", `The Maia request for ${method} failed runtime validation.`, { cause });
+export const makeCallOperation = (request) => ({
+    call: (method, parameters, options) => {
+        const idempotency = LOCAL_NODE_CALL_ENTRIES.find(([bound]) => bound === method)?.[1];
+        const payload = localNodeRequestPayloadSchema.safeParse({
+            method,
+            parameters,
+        });
+        if (!payload.success)
+            return Effect.fail(invalidCall(method, payload.error));
+        if (idempotency === undefined)
+            return Effect.fail(invalidCall(method));
+        const effect = request(payload.data, { parse: (value) => parseCallResult(method, parameters, value) }, options);
+        return idempotency === "command-id"
+            ? verifiedMutation(effect, options)
+            : effect;
+    },
+});
+//# sourceMappingURL=effect.js.map

package/dist/call/index.d.ts

@@ -0,0 +1,2 @@
+export { LOCAL_NODE_CALL_METHODS, type LocalNodeCallClient, type LocalNodeCallMethod, type LocalNodeCallParameters, type LocalNodeCallResult, type LocalNodeEffectCallClient, } from "./call.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/call/index.js

@@ -0,0 +1,2 @@
+export { LOCAL_NODE_CALL_METHODS, } from "./call.js";
+//# sourceMappingURL=index.js.map

package/dist/client/effect.d.ts

@@ -0,0 +1,8 @@
+import type { LocalNodeEffectCallClient } from "../call/index.js";
+import { type EffectClient, type LocalNodeEffectRequester } from "../request/effect.js";
+import { MaiaClientError, type MaiaTransport } from "../request/index.js";
+import type { LocalNodeClient } from "./local-node-client.js";
+export type LocalNodeEffectClient = EffectClient<Omit<LocalNodeClient, "call">> & LocalNodeEffectCallClient<MaiaClientError>;
+export declare const makeLocalNodeEffectClient: (request: LocalNodeEffectRequester) => LocalNodeEffectClient;
+export declare const createLocalNodeEffectClient: (transport: MaiaTransport) => LocalNodeEffectClient;
+//# sourceMappingURL=effect.d.ts.map