@maiaos/sdk 0.1.0-canary.2

package/dist/node/transport.js

@@ -0,0 +1,211 @@
+import { MAX_NODE_API_OBSERVATION_FRAME_BYTES, NODE_API_OBSERVATION_PATH, NODE_API_WEBSOCKET_CLOSE_CODES, NODE_API_WEBSOCKET_PROTOCOL, nodeApiEndpointSchema, nodeApiObservationFrameSchema, nodeApiObservationSubscribeSchema, sessionAttachFrameSchema, sessionAttachSubscribeSchema, } from "@maiaos/protocol";
+import * as Effect from "effect/Effect";
+import * as Queue from "effect/Queue";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import { createLocalNodeClient, } from "../client/index.js";
+import { MaiaClientError } from "../request/index.js";
+import { makeNodeApiHttpRequest, resolveCredential, toClientError, } from "./http.js";
+const MAX_OBSERVATION_BUFFERED_FRAMES = 256;
+export const createNodeApiTransport = (options) => {
+    const request = makeNodeApiHttpRequest(options);
+    return {
+        request: (envelope, requestOptions) => {
+            const signal = requestOptions?.signal;
+            return Effect.runPromise(request(envelope, requestOptions), signal === undefined ? undefined : { signal }).catch((error) => {
+                throw toClientError(error, signal);
+            });
+        },
+    };
+};
+export const createNodeApiClient = (options) => createLocalNodeClient(createNodeApiTransport(options));
+const decodeJsonFrame = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
+const defaultWebSocketFactory = (url, protocols) => {
+    const webSocketConstructor = globalThis.WebSocket;
+    if (webSocketConstructor === undefined) {
+        throw new TypeError("No WebSocket implementation is available.");
+    }
+    return new webSocketConstructor(url, [...protocols]);
+};
+const webSocketUrl = (endpoint) => `${endpoint.origin.replace(/^http:/u, "ws:")}${NODE_API_OBSERVATION_PATH}`;
+const observationError = (message, cause) => new MaiaClientError("transport_failure", message, { cause });
+const observationCloseError = (close) => {
+    if (close.code === NODE_API_WEBSOCKET_CLOSE_CODES.authenticationFailed) {
+        return observationError("The Maia Node API observation authentication failed.");
+    }
+    if (close.code === NODE_API_WEBSOCKET_CLOSE_CODES.saturated) {
+        return new MaiaClientError("saturated", "The Maia Node API observation consumer was saturated.");
+    }
+    if (close.code === NODE_API_WEBSOCKET_CLOSE_CODES.serverShutdown) {
+        return observationError("The Maia Node API observation server stopped.");
+    }
+    if (close.code === NODE_API_WEBSOCKET_CLOSE_CODES.cursorResetRequired ||
+        close.code === NODE_API_WEBSOCKET_CLOSE_CODES.policyRevoked) {
+        return new MaiaClientError("invalid_response", "The Maia Node API observation requires a fresh snapshot.");
+    }
+    return observationError("The Maia Node API observation connection closed unexpectedly.", close);
+};
+const failSaturatedQueue = (queue, socket) => Queue.fail(queue, observationError("The Maia Node API observation buffer is saturated.")).pipe(Effect.tap(() => Effect.sync(() => {
+    socket.close(4429);
+})));
+const handleOfferedFrame = (accepted, offered) => {
+    if (!accepted)
+        return failSaturatedQueue(offered.queue, offered.socket);
+    return offered.frame.terminal ? Queue.end(offered.queue) : Effect.void;
+};
+const offerFrame = (queue, frame, socket) => {
+    Effect.runFork(Queue.offer(queue, frame).pipe(Effect.flatMap((accepted) => handleOfferedFrame(accepted, { frame, queue, socket }))));
+};
+const parseObservationEndpoint = (options) => Effect.try({
+    catch: (error) => observationError("The Maia Node API observation endpoint is invalid.", error),
+    try: () => nodeApiEndpointSchema.parse(options.endpoint),
+});
+const authenticateSubscribe = Effect.fn("NodeApiObservation.authenticate")(function* (options, contract) {
+    const token = yield* resolveCredential(options.credential).pipe(Effect.mapError((error) => observationError("The Maia Node API observation credential is unavailable.", error)));
+    return yield* Effect.try({
+        catch: (error) => observationError("The Maia Node API observation request is invalid.", error),
+        try: () => contract.subscribe(token),
+    });
+});
+const openObservationSocket = Effect.fn("NodeApiObservation.open")(function* (options) {
+    const endpoint = yield* parseObservationEndpoint(options);
+    return yield* Effect.try({
+        catch: (error) => observationError("The Maia Node API observation connection could not be opened.", error),
+        try: () => (options.webSocketFactory ?? defaultWebSocketFactory)(webSocketUrl(endpoint), [NODE_API_WEBSOCKET_PROTOCOL]),
+    });
+});
+const decodeObservationFrame = (event, correlationId, decode) => {
+    if (typeof event.data !== "string") {
+        throw new TypeError("Observation frames must be text.");
+    }
+    if (new TextEncoder().encode(event.data).byteLength >
+        MAX_NODE_API_OBSERVATION_FRAME_BYTES) {
+        throw new TypeError("Observation frame exceeds its resource limit.");
+    }
+    const frame = decode(decodeJsonFrame(event.data));
+    if (frame.correlationId !== correlationId) {
+        throw new TypeError("Observation correlation does not match.");
+    }
+    return frame;
+};
+class ObservationSocketBridge {
+    closingWithFailure = false;
+    decode;
+    queue;
+    signal;
+    socket;
+    subscribe;
+    terminalReceived = false;
+    onAbort = () => {
+        this.closingWithFailure = true;
+        Effect.runFork(Queue.fail(this.queue, new MaiaClientError("cancelled", "The Maia Node API observation was cancelled.")));
+        this.socket.close(1000, "client_closed");
+    };
+    onClose = (event) => {
+        const close = event;
+        if (this.terminalReceived || close.code === 1000) {
+            if (!this.closingWithFailure)
+                Effect.runFork(Queue.end(this.queue));
+            return;
+        }
+        this.closingWithFailure = true;
+        Effect.runFork(Queue.fail(this.queue, observationCloseError(close)));
+    };
+    onError = (event) => {
+        this.closingWithFailure = true;
+        Effect.runFork(Queue.fail(this.queue, observationError("The Maia Node API observation transport failed.", event)));
+    };
+    onMessage = (event) => {
+        try {
+            const frame = decodeObservationFrame(event, this.subscribe.messageId, this.decode);
+            this.terminalReceived = frame.terminal;
+            offerFrame(this.queue, frame, this.socket);
+        }
+        catch (error) {
+            this.failInvalidFrame(error);
+        }
+    };
+    onOpen = () => {
+        this.socket.send(JSON.stringify(this.subscribe));
+    };
+    constructor(input) {
+        this.decode = input.decode;
+        this.queue = input.queue;
+        this.signal = input.signal;
+        this.socket = input.socket;
+        this.subscribe = input.subscribe;
+    }
+    install() {
+        this.socket.addEventListener("close", this.onClose);
+        this.socket.addEventListener("error", this.onError);
+        this.socket.addEventListener("message", this.onMessage);
+        this.socket.addEventListener("open", this.onOpen);
+        this.signal?.addEventListener("abort", this.onAbort, { once: true });
+        if (this.signal?.aborted === true)
+            this.onAbort();
+        else if (this.socket.readyState === 1)
+            this.onOpen();
+    }
+    uninstall() {
+        this.socket.removeEventListener("close", this.onClose);
+        this.socket.removeEventListener("error", this.onError);
+        this.socket.removeEventListener("message", this.onMessage);
+        this.socket.removeEventListener("open", this.onOpen);
+        this.signal?.removeEventListener("abort", this.onAbort);
+    }
+    failInvalidFrame(error) {
+        this.closingWithFailure = true;
+        Effect.runFork(Queue.fail(this.queue, observationError("The Maia Node API observation frame is invalid.", error)).pipe(Effect.tap(() => Effect.sync(() => {
+            this.socket.close(4400);
+        }))));
+    }
+}
+const makeObservationQueue = () => Queue.make({
+    capacity: MAX_OBSERVATION_BUFFERED_FRAMES,
+    strategy: "dropping",
+});
+const acquireObservationSocket = (options) => Effect.acquireRelease(openObservationSocket(options), (socket) => Effect.sync(() => {
+    socket.close(1000, "client_closed");
+}));
+const installObservationBridge = (bridge) => Effect.acquireRelease(Effect.sync(() => {
+    bridge.install();
+}), () => Effect.sync(() => {
+    bridge.uninstall();
+}));
+const ensureObservationActive = (signal) => signal?.aborted === true
+    ? Effect.fail(new MaiaClientError("cancelled", "The Maia Node API observation was cancelled."))
+    : Effect.void;
+const buildObservationStream = Effect.fn("NodeApiObservation.stream")(function* (options, contract) {
+    yield* ensureObservationActive(options.signal);
+    const [subscribe, queue, socket] = yield* Effect.all([
+        authenticateSubscribe(options, contract),
+        makeObservationQueue(),
+        acquireObservationSocket(options),
+    ]);
+    const bridge = new ObservationSocketBridge({
+        decode: contract.decode,
+        queue,
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+        socket,
+        subscribe,
+    });
+    yield* installObservationBridge(bridge);
+    return Stream.fromQueue(queue);
+});
+const makeObservationStream = (options) => Stream.unwrap(buildObservationStream(options, {
+    decode: (value) => nodeApiObservationFrameSchema.parse(value),
+    subscribe: (token) => nodeApiObservationSubscribeSchema.parse({
+        ...options.subscribe,
+        authentication: { scheme: "maia.node.bearer/v1", token },
+    }),
+}));
+export const subscribeNodeApiObservations = (options) => Stream.toAsyncIterable(makeObservationStream(options));
+export const makeSessionAttachStream = (options) => Stream.unwrap(buildObservationStream(options, {
+    decode: (value) => sessionAttachFrameSchema.parse(value),
+    subscribe: (token) => sessionAttachSubscribeSchema.parse({
+        ...options.request,
+        authentication: { scheme: "maia.node.bearer/v1", token },
+    }),
+}));
+export const attachSession = (options) => Stream.toAsyncIterable(makeSessionAttachStream(options));
+//# sourceMappingURL=transport.js.map

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

@@ -0,0 +1,11 @@
+import type * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import type { MaiaClientError } from "../request/index.js";
+import type { StreamRelay } from "../stream/index.js";
+import { type NodeChange, type NodeChangesSubscribe } from "./node-changes.js";
+export declare const nodeChangesSubscribe: (instanceId: string, messageId: string, afterCursor: string | undefined) => NodeChangesSubscribe;
+export declare const watchNodeChangesStream: (relay: StreamRelay<NodeChangesSubscribe>, options: {
+    readonly instanceId: string;
+    readonly nextId: (prefix: "request") => Effect.Effect<string>;
+}) => Stream.Stream<NodeChange, MaiaClientError>;
+//# sourceMappingURL=effect.d.ts.map

package/dist/node-changes/effect.js

@@ -0,0 +1,61 @@
+import { MAIA_PROTOCOL_VERSION, MAX_NODE_API_OBSERVATION_BATCH_RECORDS, MAX_NODE_API_OBSERVATION_FRAME_BYTES, NODE_API_SCHEMA_VERSION, nodeApiObservationFrameSchema, } from "@maiaos/protocol";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import { RESNAPSHOT, resumeStream } from "../stream/effect.js";
+import { reduceNodeChanges, } from "./node-changes.js";
+const utf8 = new TextEncoder();
+const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+export const nodeChangesSubscribe = (instanceId, messageId, afterCursor) => ({
+    kind: "subscribe",
+    messageId,
+    operationId: "observe.events",
+    parameters: {
+        ...(afterCursor === undefined ? {} : { afterCursor }),
+        maxBatchRecords: MAX_NODE_API_OBSERVATION_BATCH_RECORDS,
+        scopes: [{ instanceId, kind: "node" }],
+    },
+    protocolVersion: MAIA_PROTOCOL_VERSION,
+    schemaVersion: NODE_API_SCHEMA_VERSION,
+});
+const decodeFrame = (text, messageId) => {
+    if (utf8.encode(text).byteLength > MAX_NODE_API_OBSERVATION_FRAME_BYTES)
+        return Option.none();
+    return Option.flatMap(decodeJson(text), (json) => {
+        const frame = nodeApiObservationFrameSchema.safeParse(json);
+        return frame.success && frame.data.correlationId === messageId
+            ? Option.some(frame.data)
+            : Option.none();
+    });
+};
+const REVOKED = new Set([
+    "policy_revoked",
+    "principal_changed",
+]);
+const step = (frame) => {
+    if (frame.kind === "reset" && REVOKED.has(frame.data.reason))
+        return {
+            error: {
+                code: frame.data.reason,
+                message: "The Maia Node observation access changed.",
+                retryable: false,
+            },
+            kind: "error",
+        };
+    if (frame.kind === "gap" || frame.kind === "reset")
+        return { kind: "resnapshot" };
+    if (frame.kind === "error")
+        return { error: frame.data.error, kind: "error" };
+    return { cursor: frame.checkpoint.cursor, kind: "frame" };
+};
+export const watchNodeChangesStream = (relay, options) => resumeStream({
+    decode: decodeFrame,
+    nextId: options.nextId,
+    relay,
+    step,
+    subscribe: (messageId, cursor) => nodeChangesSubscribe(options.instanceId, messageId, cursor),
+    terminal: (frame) => frame.terminal,
+}).pipe(Stream.map((frame) => frame.kind === RESNAPSHOT.kind
+    ? [{ kind: "resync" }]
+    : Option.toArray(Option.fromNullishOr(reduceNodeChanges(frame)))), Stream.flattenIterable);
+//# sourceMappingURL=effect.js.map

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

@@ -0,0 +1,2 @@
+export { type ChangedAggregate, type NodeChange, type NodeChangesSubscribe, reduceNodeChanges, watchNodeChanges, } from "./node-changes.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/node-changes/index.js

@@ -0,0 +1,2 @@
+export { reduceNodeChanges, watchNodeChanges, } from "./node-changes.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,21 @@
+import type { NodeApiObservationFrame, NodeApiObservationSubscribe } from "@maiaos/protocol";
+import type { StreamRelay } from "../stream/index.js";
+export type ChangedAggregate = {
+    readonly id: string;
+    readonly revision: string;
+    readonly type: string;
+};
+export type NodeChange = {
+    readonly aggregateTypes: readonly string[];
+    readonly changed?: readonly ChangedAggregate[];
+    readonly kind: "records";
+} | {
+    readonly kind: "resync";
+};
+export type NodeChangesSubscribe = Omit<NodeApiObservationSubscribe, "authentication">;
+export declare const reduceNodeChanges: (frame: NodeApiObservationFrame) => NodeChange | undefined;
+export declare const watchNodeChanges: (relay: StreamRelay<NodeChangesSubscribe>, options: {
+    readonly instanceId: string;
+    readonly newId: (prefix: "request") => string;
+}) => AsyncIterable<NodeChange>;
+//# sourceMappingURL=node-changes.d.ts.map

package/dist/node-changes/node-changes.js

@@ -0,0 +1,23 @@
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { watchNodeChangesStream } from "./effect.js";
+export const reduceNodeChanges = (frame) => {
+    if (frame.kind === "event")
+        return {
+            aggregateTypes: frame.data.records.map((record) => record.aggregateType),
+            changed: frame.data.records.map((record) => ({
+                id: record.aggregateId,
+                revision: record.aggregateRevision,
+                type: record.aggregateType,
+            })),
+            kind: "records",
+        };
+    if (frame.kind === "snapshot")
+        return { kind: "resync" };
+    return undefined;
+};
+export const watchNodeChanges = (relay, options) => Stream.toAsyncIterable(watchNodeChangesStream(relay, {
+    instanceId: options.instanceId,
+    nextId: (prefix) => Effect.sync(() => options.newId(prefix)),
+}));
+//# sourceMappingURL=node-changes.js.map

package/dist/port-lease/effect.d.ts

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

package/dist/port-lease/effect.js

@@ -0,0 +1,53 @@
+import { portLeaseAcquireResultSchema, portLeaseListResultSchema, portLeaseReleaseResultSchema, portLeaseRenewResultSchema, } 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 port lease response did not match the request.");
+};
+const ownerMatches = (owner, sessionId) => sessionId === undefined
+    ? owner.kind === "principal"
+    : owner.kind === "session" && owner.sessionId === sessionId;
+const parseAcquire = (value, input) => {
+    const result = portLeaseAcquireResultSchema.parse(value);
+    requireMatch(result.commandId === input.commandId &&
+        result.lease.purpose === input.purpose &&
+        result.lease.ports.length === (input.count ?? 1) &&
+        ownerMatches(result.lease.owner, input.sessionId));
+    return result;
+};
+const parseRenew = (value, input) => {
+    const result = portLeaseRenewResultSchema.parse(value);
+    requireMatch(result.commandId === input.commandId &&
+        result.lease.leaseId === input.leaseId &&
+        result.expectedRevision === input.expectedRevision);
+    return result;
+};
+const parseRelease = (value, input) => {
+    const result = portLeaseReleaseResultSchema.parse(value);
+    requireMatch(result.commandId === input.commandId &&
+        result.lease.leaseId === input.leaseId);
+    return result;
+};
+const parseList = (value, input) => {
+    const result = portLeaseListResultSchema.parse(value);
+    const { afterCursor, limit, sessionId } = input;
+    requireMatch(result.items.length <= limit &&
+        (result.nextCursor === undefined || result.nextCursor !== afterCursor) &&
+        (sessionId === undefined ||
+            result.items.every((item) => ownerMatches(item.lease.owner, sessionId))));
+    return result;
+};
+const makePortLeaseMutations = (request) => ({
+    acquirePortLease: (parameters, options) => request({ method: "port.lease.acquire", parameters }, { parse: (value) => parseAcquire(value, parameters) }, options),
+    releasePortLease: (parameters, options) => request({ method: "port.lease.release", parameters }, { parse: (value) => parseRelease(value, parameters) }, options),
+    renewPortLease: (parameters, options) => request({ method: "port.lease.renew", parameters }, { parse: (value) => parseRenew(value, parameters) }, options),
+});
+export const makePortLeaseOperations = (request) => {
+    const verified = (payload, output, options) => verifiedMutation(request(payload, output, options), options);
+    return {
+        ...makePortLeaseMutations(verified),
+        listPortLeases: (parameters, options) => request({ method: "port.lease.list", parameters }, { parse: (value) => parseList(value, parameters) }, options),
+    };
+};
+//# sourceMappingURL=effect.js.map

package/dist/port-lease/index.d.ts

@@ -0,0 +1,2 @@
+export { makePortLeaseClient, MAX_PORT_LEASE_COUNT, MAX_PORT_LEASE_PAGE_SIZE, PORT_LEASE_ERROR_CODES, PORT_LEASE_SCHEMA_VERSION, type PortLease, type PortLeaseAcquireParameters, portLeaseAcquireParametersSchema, type PortLeaseAcquireResult, portLeaseAcquireResultSchema, type PortLeaseClient, type PortLeaseErrorCode, type PortLeaseListParameters, portLeaseListParametersSchema, type PortLeaseListResult, portLeaseListResultSchema, type PortLeaseOwner, type PortLeaseReleaseParameters, portLeaseReleaseParametersSchema, type PortLeaseReleaseResult, portLeaseReleaseResultSchema, type PortLeaseRenewParameters, portLeaseRenewParametersSchema, type PortLeaseRenewResult, portLeaseRenewResultSchema, portLeaseSchema, } from "./port-lease.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/port-lease/index.js

@@ -0,0 +1,2 @@
+export { makePortLeaseClient, MAX_PORT_LEASE_COUNT, MAX_PORT_LEASE_PAGE_SIZE, PORT_LEASE_ERROR_CODES, PORT_LEASE_SCHEMA_VERSION, portLeaseAcquireParametersSchema, portLeaseAcquireResultSchema, portLeaseListParametersSchema, portLeaseListResultSchema, portLeaseReleaseParametersSchema, portLeaseReleaseResultSchema, portLeaseRenewParametersSchema, portLeaseRenewResultSchema, portLeaseSchema, } from "./port-lease.js";
+//# sourceMappingURL=index.js.map

package/dist/port-lease/port-lease.d.ts

@@ -0,0 +1,11 @@
+import type { PortLeaseAcquireParameters, PortLeaseAcquireResult, PortLeaseListParameters, PortLeaseListResult, PortLeaseReleaseParameters, PortLeaseReleaseResult, PortLeaseRenewParameters, PortLeaseRenewResult } from "@maiaos/protocol";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+export type PortLeaseClient = {
+    readonly acquirePortLease: (parameters: PortLeaseAcquireParameters, options: LocalNodeRequestOptions) => Promise<PortLeaseAcquireResult>;
+    readonly listPortLeases: (parameters: PortLeaseListParameters, options: LocalNodeRequestOptions) => Promise<PortLeaseListResult>;
+    readonly releasePortLease: (parameters: PortLeaseReleaseParameters, options: LocalNodeRequestOptions) => Promise<PortLeaseReleaseResult>;
+    readonly renewPortLease: (parameters: PortLeaseRenewParameters, options: LocalNodeRequestOptions) => Promise<PortLeaseRenewResult>;
+};
+export declare const makePortLeaseClient: (request: LocalNodeRequester) => PortLeaseClient;
+export { MAX_PORT_LEASE_COUNT, MAX_PORT_LEASE_PAGE_SIZE, PORT_LEASE_ERROR_CODES, PORT_LEASE_SCHEMA_VERSION, type PortLease, type PortLeaseAcquireParameters, portLeaseAcquireParametersSchema, type PortLeaseAcquireResult, portLeaseAcquireResultSchema, type PortLeaseErrorCode, type PortLeaseListParameters, portLeaseListParametersSchema, type PortLeaseListResult, portLeaseListResultSchema, type PortLeaseOwner, type PortLeaseReleaseParameters, portLeaseReleaseParametersSchema, type PortLeaseReleaseResult, portLeaseReleaseResultSchema, type PortLeaseRenewParameters, portLeaseRenewParametersSchema, type PortLeaseRenewResult, portLeaseRenewResultSchema, portLeaseSchema, } from "@maiaos/protocol";
+//# sourceMappingURL=port-lease.d.ts.map

package/dist/port-lease/port-lease.js

@@ -0,0 +1,5 @@
+import { fromPromiseRequester, toPromiseClient } from "../request/effect.js";
+import { makePortLeaseOperations } from "./effect.js";
+export const makePortLeaseClient = (request) => toPromiseClient(makePortLeaseOperations(fromPromiseRequester(request)));
+export { MAX_PORT_LEASE_COUNT, MAX_PORT_LEASE_PAGE_SIZE, PORT_LEASE_ERROR_CODES, PORT_LEASE_SCHEMA_VERSION, portLeaseAcquireParametersSchema, portLeaseAcquireResultSchema, portLeaseListParametersSchema, portLeaseListResultSchema, portLeaseReleaseParametersSchema, portLeaseReleaseResultSchema, portLeaseRenewParametersSchema, portLeaseRenewResultSchema, portLeaseSchema, } from "@maiaos/protocol";
+//# sourceMappingURL=port-lease.js.map

package/dist/presentation/client.d.ts

@@ -0,0 +1,10 @@
+import type { PresentationCatalogParameters, PresentationCatalogResult, PresentationDirectoryParameters, PresentationDirectoryResult, PresentationProjectListParameters, PresentationProjectListResult, PresentationSessionListParameters, PresentationSessionListResult } from "@maiaos/protocol";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+export type PresentationClient = {
+    readonly showPresentationCatalog: (parameters: PresentationCatalogParameters, options: LocalNodeRequestOptions) => Promise<PresentationCatalogResult>;
+    readonly showProjectList: (parameters: PresentationProjectListParameters, options: LocalNodeRequestOptions) => Promise<PresentationProjectListResult>;
+    readonly showSessionList: (parameters: PresentationSessionListParameters, options: LocalNodeRequestOptions) => Promise<PresentationSessionListResult>;
+    readonly showWorkspaceDirectory: (parameters: PresentationDirectoryParameters, options: LocalNodeRequestOptions) => Promise<PresentationDirectoryResult>;
+};
+export declare const makePresentationClient: (request: LocalNodeRequester) => PresentationClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/presentation/client.js

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

package/dist/presentation/effect.d.ts

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

package/dist/presentation/effect.js

@@ -0,0 +1,30 @@
+import { presentationCatalogResultSchema, presentationDirectoryParametersSchema, presentationDirectoryResultSchema, } from "@maiaos/protocol";
+import { Effect } from "effect";
+import { MaiaClientError } from "../request/index.js";
+import { requestProjectList } from "./project-list.js";
+import { requestSessionList } from "./session-list.js";
+const parseDirectory = (value, parameters) => {
+    const result = presentationDirectoryResultSchema.parse(value);
+    if (result.catalogDigest !== parameters.catalogDigest ||
+        result.catalogVersion !== parameters.catalogVersion ||
+        result.viewId !== parameters.viewId ||
+        result.generation !== parameters.generation ||
+        result.resources.items.length > parameters.page.limit)
+        throw new MaiaClientError("invalid_response", "The presentation response did not match the requested view.");
+    return result;
+};
+const requestDirectory = (request, input, options) => Effect.gen(function* () {
+    const parameters = yield* Effect.try({
+        catch: () => new MaiaClientError("invalid_request", "The presentation request failed runtime validation."),
+        try: () => presentationDirectoryParametersSchema.parse(input),
+    });
+    const expected = { ...parameters, page: { ...parameters.page } };
+    return yield* request({ method: "presentation.workspace-directory.show", parameters }, { parse: (value) => parseDirectory(value, expected) }, options);
+}).pipe(Effect.withSpan("PresentationClient.requestDirectory"));
+export const makePresentationOperations = (request) => ({
+    showPresentationCatalog: (parameters, options) => request({ method: "presentation.catalog.show", parameters }, presentationCatalogResultSchema, options),
+    showProjectList: (parameters, options) => requestProjectList(request, parameters, options),
+    showSessionList: (parameters, options) => requestSessionList(request, parameters, options),
+    showWorkspaceDirectory: (parameters, options) => requestDirectory(request, parameters, options),
+});
+//# sourceMappingURL=effect.js.map

package/dist/presentation/index.d.ts

@@ -0,0 +1,5 @@
+export type { PresentationClient } from "./client.js";
+export { makePresentationClient } from "./client.js";
+export type { PresentationCatalogParameters, PresentationCatalogResult, PresentationDirectoryParameters, PresentationDirectoryResult, PresentationProjectListParameters, PresentationProjectListResult, PresentationProjectSpec, PresentationSessionListParameters, PresentationSessionListResult, PresentationSessionSpec, PresentationSpec, } from "@maiaos/protocol";
+export { PRESENTATION_CATALOG_DIGEST, PRESENTATION_CATALOG_VERSION, presentationCatalogParametersSchema, presentationCatalogResultSchema, presentationDirectoryParametersSchema, presentationDirectoryResultSchema, presentationProjectListParametersSchema, presentationProjectListResultSchema, presentationProjectSpecSchema, presentationSessionListParametersSchema, presentationSessionListResultSchema, presentationSessionSpecSchema, presentationSpecSchema, } from "@maiaos/protocol";
+//# sourceMappingURL=index.d.ts.map

package/dist/presentation/index.js

@@ -0,0 +1,3 @@
+export { makePresentationClient } from "./client.js";
+export { PRESENTATION_CATALOG_DIGEST, PRESENTATION_CATALOG_VERSION, presentationCatalogParametersSchema, presentationCatalogResultSchema, presentationDirectoryParametersSchema, presentationDirectoryResultSchema, presentationProjectListParametersSchema, presentationProjectListResultSchema, presentationProjectSpecSchema, presentationSessionListParametersSchema, presentationSessionListResultSchema, presentationSessionSpecSchema, presentationSpecSchema, } from "@maiaos/protocol";
+//# sourceMappingURL=index.js.map

package/dist/presentation/project-list.d.ts

@@ -0,0 +1,7 @@
+import { type PresentationProjectListParameters, type PresentationProjectListResult } from "@maiaos/protocol";
+import { Effect } from "effect";
+import type { LocalNodeEffectRequester } from "../request/effect.js";
+import type { LocalNodeRequestOptions } from "../request/index.js";
+import { MaiaClientError } from "../request/index.js";
+export declare const requestProjectList: <TError>(request: LocalNodeEffectRequester<TError>, input: PresentationProjectListParameters, options: LocalNodeRequestOptions) => Effect.Effect<PresentationProjectListResult, MaiaClientError | TError>;
+//# sourceMappingURL=project-list.d.ts.map

package/dist/presentation/project-list.js

@@ -0,0 +1,24 @@
+import { presentationProjectListParametersSchema, presentationProjectListResultSchema, } from "@maiaos/protocol";
+import { Effect } from "effect";
+import { MaiaClientError } from "../request/index.js";
+const parse = (value, expected) => {
+    const result = presentationProjectListResultSchema.parse(value);
+    if (result.catalogDigest !== expected.catalogDigest ||
+        result.catalogVersion !== expected.catalogVersion ||
+        result.viewId !== expected.viewId ||
+        result.generation !== expected.generation ||
+        result.resources.container.id !== expected.page.containerId ||
+        result.membershipCursor !== expected.page.afterCursor ||
+        result.resources.projects.length > expected.page.limit)
+        throw new MaiaClientError("invalid_response", "The Project presentation did not match the requested view.");
+    return result;
+};
+export const requestProjectList = (request, input, options) => Effect.gen(function* () {
+    const parameters = yield* Effect.try({
+        catch: () => new MaiaClientError("invalid_request", "The Project presentation request failed runtime validation."),
+        try: () => presentationProjectListParametersSchema.parse(input),
+    });
+    const expected = { ...parameters, page: { ...parameters.page } };
+    return yield* request({ method: "presentation.project-list.show", parameters }, { parse: (value) => parse(value, expected) }, options);
+}).pipe(Effect.withSpan("PresentationClient.requestProjectList"));
+//# sourceMappingURL=project-list.js.map

package/dist/presentation/session-list.d.ts

@@ -0,0 +1,7 @@
+import { type PresentationSessionListParameters, type PresentationSessionListResult } from "@maiaos/protocol";
+import { Effect } from "effect";
+import type { LocalNodeEffectRequester } from "../request/effect.js";
+import type { LocalNodeRequestOptions } from "../request/index.js";
+import { MaiaClientError } from "../request/index.js";
+export declare const requestSessionList: <TError>(request: LocalNodeEffectRequester<TError>, input: PresentationSessionListParameters, options: LocalNodeRequestOptions) => Effect.Effect<PresentationSessionListResult, MaiaClientError | TError>;
+//# sourceMappingURL=session-list.d.ts.map

package/dist/presentation/session-list.js

@@ -0,0 +1,32 @@
+import { presentationSessionListParametersSchema, presentationSessionListResultSchema, } from "@maiaos/protocol";
+import { Effect } from "effect";
+import { MaiaClientError } from "../request/index.js";
+const parse = (value, expected) => {
+    const result = presentationSessionListResultSchema.parse(value);
+    const target = result.target;
+    if (result.catalogDigest !== expected.catalogDigest ||
+        result.catalogVersion !== expected.catalogVersion ||
+        result.viewId !== expected.viewId ||
+        result.generation !== expected.generation ||
+        target.containerId !== expected.target.containerId ||
+        target.containerRevision !== expected.target.containerRevision ||
+        target.projectId !== expected.target.projectId ||
+        target.projectRevision !== expected.target.projectRevision ||
+        target.membershipCursor !== expected.target.membershipCursor ||
+        result.resources.items.length > expected.page.limit)
+        throw new MaiaClientError("invalid_response", "The Session presentation did not match the requested view.");
+    return result;
+};
+export const requestSessionList = (request, input, options) => Effect.gen(function* () {
+    const parameters = yield* Effect.try({
+        catch: () => new MaiaClientError("invalid_request", "The Session presentation request failed runtime validation."),
+        try: () => presentationSessionListParametersSchema.parse(input),
+    });
+    const expected = {
+        ...parameters,
+        page: { ...parameters.page },
+        target: { ...parameters.target },
+    };
+    return yield* request({ method: "presentation.session-list.show", parameters }, { parse: (value) => parse(value, expected) }, options);
+}).pipe(Effect.withSpan("PresentationClient.requestSessionList"));
+//# sourceMappingURL=session-list.js.map

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

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

package/dist/project-guard/effect.js

@@ -0,0 +1,39 @@
+import { projectGuardConfirmResultSchema, projectGuardPreviewResultSchema, projectGuardShowResultSchema, } 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 Project guard response did not match the request.");
+};
+const sameLimits = (left, right) => left.maxDepth === right.maxDepth &&
+    left.maxLeasesPerSession === right.maxLeasesPerSession &&
+    left.maxLiveChildren === right.maxLiveChildren &&
+    left.maxMessagesPerMinute === right.maxMessagesPerMinute;
+const parseShow = (value, input) => {
+    const result = projectGuardShowResultSchema.parse(value);
+    requireMatch(result.guard.projectId === input.projectId);
+    return result;
+};
+const parsePreview = (value, input) => {
+    const result = projectGuardPreviewResultSchema.parse(value);
+    requireMatch(result.commandId === input.commandId &&
+        result.expectedRevision === input.expectedRevision &&
+        result.projectId === input.projectId &&
+        sameLimits(result.limits, input.limits));
+    return result;
+};
+const parseConfirm = (value, input) => {
+    const result = projectGuardConfirmResultSchema.parse(value);
+    requireMatch(result.commandId === input.commandId &&
+        result.expectedRevision === input.expectedRevision &&
+        result.inputDigest === input.inputDigest &&
+        result.guard.projectId === input.projectId &&
+        sameLimits(result.guard.limits, input.limits));
+    return result;
+};
+export const makeProjectGuardOperations = (request) => ({
+    confirmProjectGuard: (parameters, options) => verifiedMutation(request({ method: "project.guard.confirm", parameters }, { parse: (value) => parseConfirm(value, parameters) }, options), options),
+    previewProjectGuard: (parameters, options) => request({ method: "project.guard.preview", parameters }, { parse: (value) => parsePreview(value, parameters) }, options),
+    showProjectGuard: (parameters, options) => request({ method: "project.guard.show", parameters }, { parse: (value) => parseShow(value, parameters) }, options),
+});
+//# sourceMappingURL=effect.js.map

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

@@ -0,0 +1,2 @@
+export { DEFAULT_SESSION_GUARD_LIMITS, makeProjectGuardClient, type ProjectGuard, type ProjectGuardClient, 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 "./project-guard.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/project-guard/index.js

@@ -0,0 +1,2 @@
+export { DEFAULT_SESSION_GUARD_LIMITS, makeProjectGuardClient, projectGuardConfirmParametersSchema, projectGuardConfirmResultSchema, projectGuardPreviewParametersSchema, projectGuardPreviewResultSchema, projectGuardShowParametersSchema, projectGuardShowResultSchema, SESSION_GUARD_BOUNDS, SESSION_GUARD_ERROR_CODES, SESSION_ROLE_DENIED_ERROR_CODE, } from "./project-guard.js";
+//# sourceMappingURL=index.js.map