@maiaos/sdk 0.1.0-canary.2

package/dist/project-guard/project-guard.d.ts

@@ -0,0 +1,10 @@
+import type { ProjectGuardConfirmParameters, ProjectGuardConfirmResult, ProjectGuardPreviewParameters, ProjectGuardPreviewResult, ProjectGuardShowParameters, ProjectGuardShowResult } from "@maiaos/protocol";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+export type ProjectGuardClient = {
+    readonly confirmProjectGuard: (parameters: ProjectGuardConfirmParameters, options: LocalNodeRequestOptions) => Promise<ProjectGuardConfirmResult>;
+    readonly previewProjectGuard: (parameters: ProjectGuardPreviewParameters, options: LocalNodeRequestOptions) => Promise<ProjectGuardPreviewResult>;
+    readonly showProjectGuard: (parameters: ProjectGuardShowParameters, options: LocalNodeRequestOptions) => Promise<ProjectGuardShowResult>;
+};
+export declare const makeProjectGuardClient: (request: LocalNodeRequester) => ProjectGuardClient;
+export { DEFAULT_SESSION_GUARD_LIMITS, type ProjectGuard, type ProjectGuardConfirmParameters, projectGuardConfirmParametersSchema, type ProjectGuardConfirmResult, projectGuardConfirmResultSchema, type ProjectGuardPreviewParameters, projectGuardPreviewParametersSchema, type ProjectGuardPreviewResult, projectGuardPreviewResultSchema, type ProjectGuardShowParameters, projectGuardShowParametersSchema, type ProjectGuardShowResult, projectGuardShowResultSchema, SESSION_GUARD_BOUNDS, SESSION_GUARD_ERROR_CODES, SESSION_ROLE_DENIED_ERROR_CODE, type SessionGuardLimits, type SessionRole, } from "@maiaos/protocol";
+//# sourceMappingURL=project-guard.d.ts.map

package/dist/project-guard/project-guard.js

@@ -0,0 +1,5 @@
+import { fromPromiseRequester, toPromiseClient } from "../request/effect.js";
+import { makeProjectGuardOperations } from "./effect.js";
+export const makeProjectGuardClient = (request) => toPromiseClient(makeProjectGuardOperations(fromPromiseRequester(request)));
+export { DEFAULT_SESSION_GUARD_LIMITS, projectGuardConfirmParametersSchema, projectGuardConfirmResultSchema, projectGuardPreviewParametersSchema, projectGuardPreviewResultSchema, projectGuardShowParametersSchema, projectGuardShowResultSchema, SESSION_GUARD_BOUNDS, SESSION_GUARD_ERROR_CODES, SESSION_ROLE_DENIED_ERROR_CODE, } from "@maiaos/protocol";
+//# sourceMappingURL=project-guard.js.map

package/dist/project-workspace/effect.d.ts

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

package/dist/project-workspace/effect.js

@@ -0,0 +1,124 @@
+import { projectContextListResultSchema, projectContextRecordResultSchema, projectContextShowResultSchema, projectCreateConfirmResultSchema, projectCreatePreviewResultSchema, projectListResultSchema, projectRegisterResultSchema, projectRenameConfirmResultSchema, projectRenamePreviewResultSchema, projectShowResultSchema, workspaceContextShowResultSchema, workspaceListResultSchema, workspaceMembershipAttachResultSchema, workspaceRepositoryAttachResultSchema, workspaceSelectResultSchema, workspaceShowResultSchema, } from "@maiaos/protocol";
+import * as Effect from "effect/Effect";
+import { failInvalidResponse, verifiedMutation, } from "../request/effect.js";
+const matchedResult = (context, result, matches) => matches
+    ? Effect.succeed(result)
+    : failInvalidResponse(context.invalidResponse);
+const requestWorkspaceMembershipAttach = (context, parameters, options) => context
+    .request({ method: "workspace.membership.attach", parameters }, workspaceMembershipAttachResultSchema, options)
+    .pipe(Effect.flatMap((result) => matchedResult(context, result, result.receipt.commandId === parameters.commandId &&
+    result.workspace.id === parameters.workspaceId &&
+    result.membership.workspaceId === parameters.workspaceId &&
+    result.membership.projectId === parameters.projectId &&
+    result.membership.repositoryId === parameters.repositoryId)));
+const requestWorkspaceSelect = (context, parameters, options) => context
+    .request({ method: "workspace.select", parameters }, workspaceSelectResultSchema, options)
+    .pipe(Effect.flatMap((result) => matchedResult(context, result, result.receipt.commandId === parameters.commandId &&
+    result.workspace.id === parameters.workspaceId &&
+    result.context.systemPromptInput.focus.projectId ===
+        parameters.projectId &&
+    result.context.systemPromptInput.focus.repositoryId ===
+        parameters.repositoryId)));
+const requestProjectContextRecord = (context, parameters, options) => context
+    .request({ method: "project.context.record", parameters }, projectContextRecordResultSchema, options)
+    .pipe(Effect.flatMap((result) => matchedResult(context, result, result.receipt.commandId === parameters.commandId &&
+    result.note.body === parameters.body &&
+    result.note.projectId === parameters.projectId &&
+    result.note.attribution === parameters.attribution)));
+const makeProjectOperations = (context) => ({
+    listProjects: (parameters, options) => context.request({ method: "project.list", parameters }, projectListResultSchema, options),
+    registerProject: (parameters, options) => context.request({ method: "project.register", parameters }, projectRegisterResultSchema, options),
+    showProject: (parameters, options) => context.request({ method: "project.show", parameters }, projectShowResultSchema, options),
+});
+const makeProjectContextOperations = (context) => ({
+    listProjectContext: (parameters, options) => context.request({ method: "project.context.list", parameters }, projectContextListResultSchema, options),
+    recordProjectContext: (parameters, options) => requestProjectContextRecord(context, parameters, options),
+    showProjectContext: (parameters, options) => context.request({ method: "project.context.show", parameters }, projectContextShowResultSchema, options),
+});
+const makeWorkspaceReadOperations = (request) => ({
+    listWorkspaces: (parameters, options) => request({ method: "workspace.list", parameters }, workspaceListResultSchema, options),
+    showWorkspace: (parameters, options) => request({ method: "workspace.show", parameters }, workspaceShowResultSchema, options),
+    showWorkspaceContext: (parameters, options) => request({ method: "workspace.context.show", parameters }, workspaceContextShowResultSchema, options),
+});
+const makeWorkspaceMutationOperations = (context) => ({
+    attachWorkspaceMembership: (parameters, options) => requestWorkspaceMembershipAttach(context, parameters, options),
+    attachWorkspaceRepository: (parameters, options) => context.request({ method: "workspace.repository.attach", parameters }, workspaceRepositoryAttachResultSchema, options),
+    selectWorkspace: (parameters, options) => requestWorkspaceSelect(context, parameters, options),
+});
+const makeProjectCreatePreview = (context) => ({
+    previewProjectCreate: (parameters, options) => context.request({ method: "project.create.preview", parameters }, {
+        parse: (value) => {
+            const result = projectCreatePreviewResultSchema.parse(value);
+            return result.commandId === parameters.commandId &&
+                result.name === parameters.name.trim() &&
+                result.containerId === parameters.containerId &&
+                result.expectedContainerRevision ===
+                    parameters.expectedContainerRevision
+                ? result
+                : context.invalidResponse();
+        },
+    }, options),
+});
+const makeProjectRenamePreview = (context) => ({
+    previewProjectRename: (parameters, options) => context.request({ method: "project.rename.preview", parameters }, {
+        parse: (value) => {
+            const result = projectRenamePreviewResultSchema.parse(value);
+            return result.commandId === parameters.commandId &&
+                result.name === parameters.name.trim() &&
+                result.containerId === parameters.containerId &&
+                result.projectId === parameters.projectId &&
+                result.expectedRevision === parameters.expectedRevision
+                ? result
+                : context.invalidResponse();
+        },
+    }, options),
+});
+const makeProjectCreateConfirmation = (context) => ({
+    confirmProjectCreate: (parameters, options) => context.request({ method: "project.create.confirm", parameters }, {
+        parse: (value) => {
+            const result = projectCreateConfirmResultSchema.parse(value);
+            return result.commandId === parameters.commandId &&
+                result.project.name === parameters.name.trim() &&
+                result.inputDigest === parameters.inputDigest &&
+                result.containerId === parameters.containerId &&
+                result.expectedContainerRevision ===
+                    parameters.expectedContainerRevision
+                ? result
+                : context.invalidResponse();
+        },
+    }, options),
+});
+const makeProjectRenameConfirmation = (context) => ({
+    confirmProjectRename: (parameters, options) => context.request({ method: "project.rename.confirm", parameters }, {
+        parse: (value) => {
+            const result = projectRenameConfirmResultSchema.parse(value);
+            return result.commandId === parameters.commandId &&
+                result.project.name === parameters.name.trim() &&
+                result.inputDigest === parameters.inputDigest &&
+                result.containerId === parameters.containerId &&
+                result.project.id === parameters.projectId &&
+                result.expectedRevision === parameters.expectedRevision
+                ? result
+                : context.invalidResponse();
+        },
+    }, options),
+});
+const confirmationContextOf = (context) => ({
+    invalidResponse: context.invalidResponse,
+    request: (payload, output, options) => verifiedMutation(context.request(payload, output, options), options),
+});
+export const makeProjectWorkspaceOperations = (request, invalidResponse) => {
+    const context = { invalidResponse, request };
+    const confirmationContext = confirmationContextOf(context);
+    return {
+        ...makeProjectCreatePreview(context),
+        ...makeProjectRenamePreview(context),
+        ...makeProjectCreateConfirmation(confirmationContext),
+        ...makeProjectRenameConfirmation(confirmationContext),
+        ...makeProjectOperations(context),
+        ...makeProjectContextOperations(context),
+        ...makeWorkspaceReadOperations(request),
+        ...makeWorkspaceMutationOperations(context),
+    };
+};
+//# sourceMappingURL=effect.js.map

package/dist/project-workspace/index.d.ts

@@ -0,0 +1,2 @@
+export { type InvalidProjectWorkspaceResponse, makeProjectWorkspaceClient, type ProjectWorkspaceClient, } from "./project-workspace.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/project-workspace/index.js

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

package/dist/project-workspace/project-workspace.d.ts

@@ -0,0 +1,23 @@
+import type { ProjectContextListParameters, ProjectContextListResult, ProjectContextRecordParameters, ProjectContextRecordResult, ProjectContextShowParameters, ProjectContextShowResult, ProjectCreateConfirmParameters, ProjectCreateConfirmResult, ProjectCreatePreviewParameters, ProjectCreatePreviewResult, ProjectListParameters, ProjectListResult, ProjectRegisterParameters, ProjectRegisterResult, ProjectRenameConfirmParameters, ProjectRenameConfirmResult, ProjectRenamePreviewParameters, ProjectRenamePreviewResult, ProjectShowParameters, ProjectShowResult, WorkspaceContextShowParameters, WorkspaceContextShowResult, WorkspaceListParameters, WorkspaceListResult, WorkspaceMembershipAttachParameters, WorkspaceMembershipAttachResult, WorkspaceRepositoryAttachParameters, WorkspaceRepositoryAttachResult, WorkspaceSelectParameters, WorkspaceSelectResult, WorkspaceShowParameters, WorkspaceShowResult } from "@maiaos/protocol";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+export type ProjectWorkspaceClient = {
+    readonly attachWorkspaceMembership: (parameters: WorkspaceMembershipAttachParameters, options: LocalNodeRequestOptions) => Promise<WorkspaceMembershipAttachResult>;
+    readonly attachWorkspaceRepository: (parameters: WorkspaceRepositoryAttachParameters, options: LocalNodeRequestOptions) => Promise<WorkspaceRepositoryAttachResult>;
+    readonly confirmProjectCreate: (parameters: ProjectCreateConfirmParameters, options: LocalNodeRequestOptions) => Promise<ProjectCreateConfirmResult>;
+    readonly confirmProjectRename: (parameters: ProjectRenameConfirmParameters, options: LocalNodeRequestOptions) => Promise<ProjectRenameConfirmResult>;
+    readonly listProjectContext: (parameters: ProjectContextListParameters, options: LocalNodeRequestOptions) => Promise<ProjectContextListResult>;
+    readonly listProjects: (parameters: ProjectListParameters, options: LocalNodeRequestOptions) => Promise<ProjectListResult>;
+    readonly listWorkspaces: (parameters: WorkspaceListParameters, options: LocalNodeRequestOptions) => Promise<WorkspaceListResult>;
+    readonly previewProjectCreate: (parameters: ProjectCreatePreviewParameters, options: LocalNodeRequestOptions) => Promise<ProjectCreatePreviewResult>;
+    readonly previewProjectRename: (parameters: ProjectRenamePreviewParameters, options: LocalNodeRequestOptions) => Promise<ProjectRenamePreviewResult>;
+    readonly recordProjectContext: (parameters: ProjectContextRecordParameters, options: LocalNodeRequestOptions) => Promise<ProjectContextRecordResult>;
+    readonly registerProject: (parameters: ProjectRegisterParameters, options: LocalNodeRequestOptions) => Promise<ProjectRegisterResult>;
+    readonly selectWorkspace: (parameters: WorkspaceSelectParameters, options: LocalNodeRequestOptions) => Promise<WorkspaceSelectResult>;
+    readonly showProject: (parameters: ProjectShowParameters, options: LocalNodeRequestOptions) => Promise<ProjectShowResult>;
+    readonly showProjectContext: (parameters: ProjectContextShowParameters, options: LocalNodeRequestOptions) => Promise<ProjectContextShowResult>;
+    readonly showWorkspace: (parameters: WorkspaceShowParameters, options: LocalNodeRequestOptions) => Promise<WorkspaceShowResult>;
+    readonly showWorkspaceContext: (parameters: WorkspaceContextShowParameters, options: LocalNodeRequestOptions) => Promise<WorkspaceContextShowResult>;
+};
+export type InvalidProjectWorkspaceResponse = () => never;
+export declare const makeProjectWorkspaceClient: (request: LocalNodeRequester, invalidResponse: InvalidProjectWorkspaceResponse) => ProjectWorkspaceClient;
+//# sourceMappingURL=project-workspace.d.ts.map

package/dist/project-workspace/project-workspace.js

@@ -0,0 +1,4 @@
+import { fromPromiseRequester, toPromiseClient } from "../request/effect.js";
+import { makeProjectWorkspaceOperations } from "./effect.js";
+export const makeProjectWorkspaceClient = (request, invalidResponse) => toPromiseClient(makeProjectWorkspaceOperations(fromPromiseRequester(request), invalidResponse));
+//# sourceMappingURL=project-workspace.js.map

package/dist/provider-pool/effect.d.ts

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

package/dist/provider-pool/effect.js

@@ -0,0 +1,5 @@
+import { providerPoolListResultSchema } from "@maiaos/protocol";
+export const makeProviderPoolOperations = (request) => ({
+    listProviderPools: (parameters, options) => request({ method: "provider.pool.list", parameters }, providerPoolListResultSchema, options),
+});
+//# sourceMappingURL=effect.js.map

package/dist/provider-pool/index.d.ts

@@ -0,0 +1,2 @@
+export { makeProviderPoolClient, type ProviderPoolClient, } from "./provider-pool.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/provider-pool/index.js

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

package/dist/provider-pool/provider-pool.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderPoolListParameters, ProviderPoolListResult } from "@maiaos/protocol";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+export type ProviderPoolClient = {
+    readonly listProviderPools: (parameters: ProviderPoolListParameters, options: LocalNodeRequestOptions) => Promise<ProviderPoolListResult>;
+};
+export declare const makeProviderPoolClient: (request: LocalNodeRequester) => ProviderPoolClient;
+//# sourceMappingURL=provider-pool.d.ts.map

package/dist/provider-pool/provider-pool.js

@@ -0,0 +1,4 @@
+import { fromPromiseRequester, toPromiseClient } from "../request/effect.js";
+import { makeProviderPoolOperations } from "./effect.js";
+export const makeProviderPoolClient = (request) => toPromiseClient(makeProviderPoolOperations(fromPromiseRequester(request)));
+//# sourceMappingURL=provider-pool.js.map

package/dist/remote-node/effect.d.ts

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

package/dist/remote-node/effect.js

@@ -0,0 +1,57 @@
+import { remoteNodeInstallConfirmResultSchema, remoteNodeInstallPreviewResultSchema, remoteNodeListResultSchema, remoteNodeRemoveConfirmResultSchema, remoteNodeRemovePreviewResultSchema, } from "@maiaos/protocol";
+import { MaiaClientError } from "../request/index.js";
+const requireMatch = (matches) => {
+    if (!matches)
+        throw new MaiaClientError("invalid_response", "The remote Node response did not match the request.");
+};
+const parsePreview = (value, parameters) => {
+    const result = remoteNodeInstallPreviewResultSchema.parse(value);
+    requireMatch(result.commandId === parameters.commandId &&
+        (result.state !== "ready" ||
+            (result.name === parameters.name &&
+                result.plan.profile === parameters.profile &&
+                result.plan.keep === parameters.keep)));
+    return result;
+};
+const nodeMatches = (node, parameters) => node.name === parameters.name;
+const parseInstallConfirmation = (value, parameters) => {
+    const result = remoteNodeInstallConfirmResultSchema.parse(value);
+    requireMatch(result.commandId === parameters.commandId &&
+        result.inputDigest === parameters.inputDigest &&
+        nodeMatches(result.node, parameters) &&
+        result.node.host === parameters.host &&
+        result.node.profile === parameters.profile);
+    return result;
+};
+const parseRemovePreview = (value, parameters) => {
+    const result = remoteNodeRemovePreviewResultSchema.parse(value);
+    requireMatch(result.commandId === parameters.commandId &&
+        result.name === parameters.name &&
+        result.purge === parameters.purge &&
+        result.expectedRevision === parameters.expectedRevision);
+    return result;
+};
+const parseRemoveConfirmation = (value, parameters) => {
+    const result = remoteNodeRemoveConfirmResultSchema.parse(value);
+    requireMatch(result.commandId === parameters.commandId &&
+        result.inputDigest === parameters.inputDigest &&
+        nodeMatches(result.node, parameters));
+    return result;
+};
+const makeRemoteNodeReadOperations = (request) => ({
+    listRemoteNodes: (parameters, options) => request({ method: "node.remote.list", parameters }, remoteNodeListResultSchema, options),
+});
+const makeRemoteNodeInstallOperations = (request) => ({
+    confirmRemoteNodeInstall: (parameters, options) => request({ method: "node.remote.install.confirm", parameters }, { parse: (value) => parseInstallConfirmation(value, parameters) }, options),
+    previewRemoteNodeInstall: (parameters, options) => request({ method: "node.remote.install.preview", parameters }, { parse: (value) => parsePreview(value, parameters) }, options),
+});
+const makeRemoteNodeRemoveOperations = (request) => ({
+    confirmRemoteNodeRemove: (parameters, options) => request({ method: "node.remote.remove.confirm", parameters }, { parse: (value) => parseRemoveConfirmation(value, parameters) }, options),
+    previewRemoteNodeRemove: (parameters, options) => request({ method: "node.remote.remove.preview", parameters }, { parse: (value) => parseRemovePreview(value, parameters) }, options),
+});
+export const makeRemoteNodeOperations = (request) => ({
+    ...makeRemoteNodeReadOperations(request),
+    ...makeRemoteNodeInstallOperations(request),
+    ...makeRemoteNodeRemoveOperations(request),
+});
+//# sourceMappingURL=effect.js.map

package/dist/remote-node/index.d.ts

@@ -0,0 +1,2 @@
+export { makeRemoteNodeClient, type RemoteNodeClient, type RemoteNodeExecutor, type RemoteNodeInstallConfirmParameters, remoteNodeInstallConfirmParametersSchema, type RemoteNodeInstallConfirmResult, type RemoteNodeInstallPlan, type RemoteNodeInstallPreviewParameters, remoteNodeInstallPreviewParametersSchema, type RemoteNodeInstallPreviewResult, type RemoteNodeListParameters, remoteNodeListParametersSchema, type RemoteNodeListResult, type RemoteNodeRecord, type RemoteNodeRemoveConfirmParameters, remoteNodeRemoveConfirmParametersSchema, type RemoteNodeRemoveConfirmResult, type RemoteNodeRemovePreviewParameters, remoteNodeRemovePreviewParametersSchema, type RemoteNodeRemovePreviewResult, } from "./remote-node.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/remote-node/index.js

@@ -0,0 +1,2 @@
+export { makeRemoteNodeClient, remoteNodeInstallConfirmParametersSchema, remoteNodeInstallPreviewParametersSchema, remoteNodeListParametersSchema, remoteNodeRemoveConfirmParametersSchema, remoteNodeRemovePreviewParametersSchema, } from "./remote-node.js";
+//# sourceMappingURL=index.js.map

package/dist/remote-node/remote-node.d.ts

@@ -0,0 +1,12 @@
+import type { RemoteNodeInstallConfirmParameters, RemoteNodeInstallConfirmResult, RemoteNodeInstallPreviewParameters, RemoteNodeInstallPreviewResult, RemoteNodeListParameters, RemoteNodeListResult, RemoteNodeRemoveConfirmParameters, RemoteNodeRemoveConfirmResult, RemoteNodeRemovePreviewParameters, RemoteNodeRemovePreviewResult } from "@maiaos/protocol";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+export type RemoteNodeClient = {
+    readonly confirmRemoteNodeInstall: (parameters: RemoteNodeInstallConfirmParameters, options: LocalNodeRequestOptions) => Promise<RemoteNodeInstallConfirmResult>;
+    readonly confirmRemoteNodeRemove: (parameters: RemoteNodeRemoveConfirmParameters, options: LocalNodeRequestOptions) => Promise<RemoteNodeRemoveConfirmResult>;
+    readonly listRemoteNodes: (parameters: RemoteNodeListParameters, options: LocalNodeRequestOptions) => Promise<RemoteNodeListResult>;
+    readonly previewRemoteNodeInstall: (parameters: RemoteNodeInstallPreviewParameters, options: LocalNodeRequestOptions) => Promise<RemoteNodeInstallPreviewResult>;
+    readonly previewRemoteNodeRemove: (parameters: RemoteNodeRemovePreviewParameters, options: LocalNodeRequestOptions) => Promise<RemoteNodeRemovePreviewResult>;
+};
+export declare const makeRemoteNodeClient: (request: LocalNodeRequester) => RemoteNodeClient;
+export { type RemoteNodeExecutor, type RemoteNodeInstallConfirmParameters, remoteNodeInstallConfirmParametersSchema, type RemoteNodeInstallConfirmResult, type RemoteNodeInstallPlan, type RemoteNodeInstallPreviewParameters, remoteNodeInstallPreviewParametersSchema, type RemoteNodeInstallPreviewResult, type RemoteNodeListParameters, remoteNodeListParametersSchema, type RemoteNodeListResult, type RemoteNodeRecord, type RemoteNodeRemoveConfirmParameters, remoteNodeRemoveConfirmParametersSchema, type RemoteNodeRemoveConfirmResult, type RemoteNodeRemovePreviewParameters, remoteNodeRemovePreviewParametersSchema, type RemoteNodeRemovePreviewResult, } from "@maiaos/protocol";
+//# sourceMappingURL=remote-node.d.ts.map

package/dist/remote-node/remote-node.js

@@ -0,0 +1,5 @@
+import { fromPromiseRequester, toPromiseClient } from "../request/effect.js";
+import { makeRemoteNodeOperations } from "./effect.js";
+export const makeRemoteNodeClient = (request) => toPromiseClient(makeRemoteNodeOperations(fromPromiseRequester(request)));
+export { remoteNodeInstallConfirmParametersSchema, remoteNodeInstallPreviewParametersSchema, remoteNodeListParametersSchema, remoteNodeRemoveConfirmParametersSchema, remoteNodeRemovePreviewParametersSchema, } from "@maiaos/protocol";
+//# sourceMappingURL=remote-node.js.map

package/dist/request/classify.d.ts

@@ -0,0 +1,15 @@
+import { MaiaClientError } from "./client-error.js";
+export type MaiaErrorKind = "cancelled" | "conflict" | "declined" | "denied" | "invalid" | "not_found" | "offline" | "outcome_unknown" | "refused" | "unavailable";
+export type MaiaError = {
+    readonly _tag: "MaiaError";
+    readonly code?: string;
+    readonly kind: MaiaErrorKind;
+    readonly operationId?: string;
+    readonly retryable: boolean;
+};
+export declare const platformStoppedBeforeDispatch: (error: MaiaClientError) => boolean;
+export declare const classifyClientError: (error: unknown, options: {
+    readonly mutation: boolean;
+    readonly operationId?: string;
+}) => MaiaError;
+//# sourceMappingURL=classify.d.ts.map

package/dist/request/classify.js

@@ -0,0 +1,96 @@
+import { MaiaClientError } from "./client-error.js";
+const CONFLICT_CODES = new Set([
+    "port_lease_conflict",
+    "revision_conflict",
+    "storage_conflict",
+]);
+const NOT_FOUND_CODES = new Set(["port_lease_not_found", "resource_not_found"]);
+const DENIED_CODES = new Set([
+    "authentication_failed",
+    "authorization_failed",
+    "role_denied",
+]);
+const UNAVAILABLE_CODES = new Set([
+    "command_not_implemented",
+    "unsupported_method",
+]);
+const classified = (kind, retryable, code) => ({
+    ...(code === undefined ? {} : { code }),
+    kind,
+    retryable,
+});
+const platformReason = (error) => {
+    const cause = error.cause;
+    return cause !== null && typeof cause === "object"
+        ? Reflect.get(cause, "reason")
+        : undefined;
+};
+const fromPlatform = (reason) => {
+    if (reason === "cancelled_before_dispatch")
+        return classified("cancelled", true, reason);
+    if (reason === "deadline_before_dispatch")
+        return classified("offline", true, reason);
+    if (reason === "confirmation_declined")
+        return classified("declined", false, "confirmation_declined");
+    if (reason === "confirmation_unavailable")
+        return classified("refused", true, "confirmation_unavailable");
+    if (reason === "request_denied" || reason === "credential_invalid")
+        return classified("denied", false, reason);
+    return undefined;
+};
+export const platformStoppedBeforeDispatch = (error) => fromPlatform(platformReason(error)) !== undefined;
+const fromRemote = (remote) => {
+    if (remote.code === "outcome_unknown")
+        return classified("outcome_unknown", true, remote.code);
+    if (DENIED_CODES.has(remote.code))
+        return classified("denied", false, remote.code);
+    if (CONFLICT_CODES.has(remote.code))
+        return classified("conflict", false, remote.code);
+    if (NOT_FOUND_CODES.has(remote.code))
+        return classified("not_found", false, remote.code);
+    if (UNAVAILABLE_CODES.has(remote.code))
+        return classified("unavailable", false, remote.code);
+    return classified("refused", remote.retryable, remote.code);
+};
+const unanswered = (code, mutation) => mutation
+    ? classified("outcome_unknown", true, code)
+    : classified("offline", true, code);
+const fromClient = (error, mutation) => {
+    switch (error.code) {
+        case "cancelled":
+            return classified("cancelled", true, error.code);
+        case "correlation_mismatch":
+        case "invalid_response":
+            return mutation
+                ? classified("outcome_unknown", true, error.code)
+                : classified("invalid", false, error.code);
+        case "deadline_exceeded":
+        case "saturated":
+            return classified("offline", true, error.code);
+        case "invalid_request":
+            return classified("invalid", false, error.code);
+        case "outcome_unknown":
+            return classified("outcome_unknown", true, error.code);
+        case "remote_error":
+        case "transport_failure":
+            return unanswered(error.code, mutation);
+    }
+};
+const classify = (error, mutation) => {
+    if (!(error instanceof MaiaClientError))
+        return unanswered("transport_failure", mutation);
+    const platform = fromPlatform(platformReason(error));
+    if (platform !== undefined)
+        return platform;
+    return error.remoteError === undefined
+        ? fromClient(error, mutation)
+        : fromRemote(error.remoteError);
+};
+export const classifyClientError = (error, options) => ({
+    _tag: "MaiaError",
+    ...classify(error, options.mutation),
+    ...(options.operationId === undefined
+        ? {}
+        : { operationId: options.operationId }),
+});
+//# sourceMappingURL=classify.js.map

package/dist/request/client-error.d.ts

@@ -0,0 +1,10 @@
+import type { LocalNodeOperationErrorCode, ProtocolError } from "@maiaos/protocol";
+export type MaiaClientErrorCode = "cancelled" | "correlation_mismatch" | "invalid_request" | "invalid_response" | "remote_error" | "transport_failure" | LocalNodeOperationErrorCode;
+export declare class MaiaClientError extends Error {
+    readonly code: MaiaClientErrorCode;
+    readonly remoteError?: ProtocolError;
+    constructor(code: MaiaClientErrorCode, message: string, options?: ErrorOptions & {
+        readonly remoteError?: ProtocolError;
+    });
+}
+//# sourceMappingURL=client-error.d.ts.map

package/dist/request/client-error.js

@@ -0,0 +1,11 @@
+export class MaiaClientError extends Error {
+    code;
+    remoteError;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "MaiaClientError";
+        this.code = code;
+        this.remoteError = options?.remoteError;
+    }
+}
+//# sourceMappingURL=client-error.js.map

package/dist/request/effect.d.ts

@@ -0,0 +1,22 @@
+import { type LocalNodeRequestPayload, type ProtocolRequestEnvelope } from "@maiaos/protocol";
+import * as Effect from "effect/Effect";
+import { MaiaClientError } from "./client-error.js";
+import type { MaiaRequest, MaiaTransport, TransportRequestOptions } from "./maia-client.js";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "./options.js";
+export type MaiaEffectTransport = {
+    readonly request: (envelope: ProtocolRequestEnvelope<unknown>, options?: TransportRequestOptions) => Effect.Effect<unknown, MaiaClientError>;
+};
+export type LocalNodeEffectRequester<TError = MaiaClientError> = <TOutput>(payload: LocalNodeRequestPayload, outputSchema: {
+    readonly parse: (value: unknown) => TOutput;
+}, options: LocalNodeRequestOptions) => Effect.Effect<TOutput, TError>;
+export type EffectClient<TClient, TError = MaiaClientError> = {
+    readonly [TName in keyof TClient]: TClient[TName] extends (...arguments_: infer TArguments) => Promise<infer TResult> ? (...arguments_: TArguments) => Effect.Effect<TResult, TError> : never;
+};
+export declare const fromPromiseTransport: (transport: MaiaTransport) => MaiaEffectTransport;
+export declare const executeMaiaRequest: <TInput, TOutput>(transport: MaiaEffectTransport, request: MaiaRequest<TInput, TOutput>) => Effect.Effect<TOutput, MaiaClientError>;
+export declare const makeLocalNodeEffectRequester: (transport: MaiaEffectTransport, validatePayload?: boolean) => LocalNodeEffectRequester;
+export declare const fromPromiseRequester: (request: LocalNodeRequester) => LocalNodeEffectRequester<unknown>;
+export declare const verifiedMutation: <TResult, TError>(mutation: Effect.Effect<TResult, TError>, options: LocalNodeRequestOptions) => Effect.Effect<TResult, MaiaClientError | TError>;
+export declare const failInvalidResponse: (reject: () => never) => Effect.Effect<never, MaiaClientError>;
+export declare const toPromiseClient: <TClient>(client: EffectClient<TClient, unknown>) => TClient;
+//# sourceMappingURL=effect.d.ts.map

package/dist/request/effect.js

@@ -0,0 +1,104 @@
+import { localNodeOperationErrorCodeSchema, MAIA_PROTOCOL_VERSION, protocolErrorEnvelopeSchema, protocolRequestEnvelopeSchema, protocolSuccessEnvelopeSchema, } from "@maiaos/protocol";
+import * as Effect from "effect/Effect";
+import { platformStoppedBeforeDispatch } from "./classify.js";
+import { MaiaClientError } from "./client-error.js";
+import { localNodeRequestPayloadParser } from "./envelope-schema.js";
+const transportRequestError = (error, signal) => {
+    if (error instanceof MaiaClientError)
+        return error;
+    const cancelled = signal?.aborted ?? false;
+    return new MaiaClientError(cancelled ? "cancelled" : "transport_failure", cancelled
+        ? "The Maia request was cancelled."
+        : "The Maia transport request failed.", { cause: error });
+};
+export const fromPromiseTransport = (transport) => ({
+    request: (envelope, options) => Effect.tryPromise({
+        catch: (error) => transportRequestError(error, options?.signal),
+        try: () => transport.request(envelope, options),
+    }),
+});
+const createRequestEnvelope = (request) => Effect.try({
+    catch: (error) => new MaiaClientError("invalid_request", "The Maia request failed runtime validation.", { cause: error }),
+    try: () => {
+        const envelope = {
+            kind: "request",
+            messageId: request.messageId,
+            payload: request.inputSchema.parse(request.payload),
+            protocolVersion: MAIA_PROTOCOL_VERSION,
+        };
+        protocolRequestEnvelopeSchema.parse(envelope);
+        return envelope;
+    },
+});
+const requireCorrelation = (response, requestMessageId) => response.correlationId === requestMessageId
+    ? Effect.void
+    : Effect.fail(new MaiaClientError("correlation_mismatch", "The Maia response did not match the request message."));
+const rejectRemoteError = (rawResponse, requestMessageId) => {
+    const response = protocolErrorEnvelopeSchema.safeParse(rawResponse);
+    if (!response.success)
+        return Effect.void;
+    const { error } = response.data.payload;
+    return requireCorrelation(response.data, requestMessageId).pipe(Effect.andThen(Effect.suspend(() => {
+        const localCode = localNodeOperationErrorCodeSchema.safeParse(error.code);
+        return Effect.fail(new MaiaClientError(localCode.success ? localCode.data : "remote_error", error.message, { remoteError: error }));
+    })));
+};
+const parseSuccessResult = (rawResponse, requestMessageId) => Effect.try({
+    catch: (error) => new MaiaClientError("invalid_response", "The Maia response envelope failed runtime validation.", { cause: error }),
+    try: () => protocolSuccessEnvelopeSchema.parse(rawResponse),
+}).pipe(Effect.tap((response) => requireCorrelation(response, requestMessageId)), Effect.map((response) => response.payload.result));
+const parseOutput = (outputSchema, output) => Effect.try({
+    catch: (error) => new MaiaClientError("invalid_response", "The Maia response payload failed runtime validation.", { cause: error }),
+    try: () => outputSchema.parse(output),
+});
+const cancelledRequest = () => new MaiaClientError("cancelled", "The Maia request was cancelled.");
+export const executeMaiaRequest = (transport, request) => Effect.gen(function* () {
+    const envelope = yield* createRequestEnvelope(request);
+    const { messageId, outputSchema, signal } = request;
+    if (signal?.aborted === true)
+        return yield* Effect.fail(cancelledRequest());
+    const rawResponse = yield* transport.request(envelope, signal === undefined ? undefined : { signal });
+    yield* rejectRemoteError(rawResponse, messageId);
+    const output = yield* parseSuccessResult(rawResponse, messageId);
+    return yield* parseOutput(outputSchema, output);
+});
+export const makeLocalNodeEffectRequester = (transport, validatePayload = true) => (payload, outputSchema, { messageId, signal }) => executeMaiaRequest(transport, {
+    inputSchema: validatePayload
+        ? localNodeRequestPayloadParser
+        : { parse: () => payload },
+    messageId,
+    outputSchema,
+    payload,
+    signal,
+});
+export const fromPromiseRequester = (request) => (payload, outputSchema, options) => Effect.tryPromise({
+    catch: (error) => error,
+    try: () => request(payload, outputSchema, options),
+});
+const uncertainMutation = (error, cancelledBeforeRequest) => error instanceof MaiaClientError &&
+    !platformStoppedBeforeDispatch(error) &&
+    (error.code === "invalid_response" ||
+        error.code === "correlation_mismatch" ||
+        error.code === "transport_failure" ||
+        (error.code === "cancelled" && !cancelledBeforeRequest))
+    ? new MaiaClientError("outcome_unknown", "The mutation result could not be verified. Reconcile the original command ID.")
+    : error;
+export const verifiedMutation = (mutation, options) => Effect.suspend(() => {
+    const cancelledBeforeRequest = options.signal?.aborted ?? false;
+    return Effect.mapError(mutation, (error) => uncertainMutation(error, cancelledBeforeRequest));
+});
+export const failInvalidResponse = (reject) => Effect.suspend(() => {
+    try {
+        return reject();
+    }
+    catch (error) {
+        return error instanceof MaiaClientError
+            ? Effect.fail(error)
+            : Effect.die(error);
+    }
+});
+export const toPromiseClient = (client) => Object.fromEntries(Object.entries(client).map(([name, operation]) => [
+    name,
+    (...arguments_) => Effect.runPromise(operation(...arguments_)),
+]));
+//# sourceMappingURL=effect.js.map

package/dist/request/envelope-schema.d.ts

@@ -0,0 +1,2 @@
+export { localNodeRequestPayloadSchema as localNodeRequestPayloadParser } from "@maiaos/protocol";
+//# sourceMappingURL=envelope-schema.d.ts.map

package/dist/request/envelope-schema.js

@@ -0,0 +1,2 @@
+export { localNodeRequestPayloadSchema as localNodeRequestPayloadParser } from "@maiaos/protocol";
+//# sourceMappingURL=envelope-schema.js.map

package/dist/request/index.d.ts

@@ -0,0 +1,5 @@
+export { classifyClientError, type MaiaError, type MaiaErrorKind, } from "./classify.js";
+export { MaiaClientError, type MaiaClientErrorCode } from "./client-error.js";
+export { type CancellationSignal, createMaiaClient, type MaiaClient, type MaiaRequest, type MaiaTransport, type RuntimeSchema, type TransportRequestOptions, } from "./maia-client.js";
+export type { LocalNodeRequester, LocalNodeRequestOptions } from "./options.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/request/index.js

@@ -0,0 +1,4 @@
+export { classifyClientError, } from "./classify.js";
+export { MaiaClientError } from "./client-error.js";
+export { createMaiaClient, } from "./maia-client.js";
+//# sourceMappingURL=index.js.map