@everysk/apps-sdk 0.2.0 → 0.3.0-beta-20261019175049

package/dist/lib/workflowRun.js

@@ -0,0 +1,224 @@
+import { isRetryableFailure } from "../api/request.js";
+import { isTerminalRunStatus } from "../api/workflow.js";
+import { abortable, createDeadline, unlessAborted } from "./abort.js";
+//#region src/lib/workflowRun.ts
+/** The alert a run hook shows when its failure carries no message of its own. */
+var RUN_FAILED_MESSAGE = "Unable to run the workflow. Please try again.";
+/** The events the backend sends when a run's Ender finishes. */
+var RUN_END_EVENTS = ["WORKFLOW_EXECUTION_COMPLETED", "WORKFLOW_EXECUTION_FAILED"];
+var isRunEndEvent = (event) => RUN_END_EVENTS.includes(event.event_type);
+/**
+* The error a run ends with when its caller stopped it — the screen went away, or the app's own
+* signal — with that signal's reason as the cause. One class for both phases, the wait and the
+* result read, so a caller can tell a stop from a failure with `instanceof` rather than by its
+* message.
+*/
+var WorkflowRunAbortedError = class extends Error {
+	constructor(reason) {
+		super("Waiting for the workflow run was aborted", { cause: reason });
+		this.name = "WorkflowRunAbortedError";
+	}
+};
+/** The longest delay `setTimeout` honours; it fires a longer one after 1 ms. */
+var MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
+/**
+* Throws when a wait option is not a positive number a timer can wait: zero or NaN would read
+* back to back, and above `MAX_TIMER_DELAY_MS` the timer fires at once.
+*/
+var requireTimerDelays = (options) => {
+	for (const [name, value] of Object.entries(options)) if (!(value > 0 && value <= MAX_TIMER_DELAY_MS)) throw new Error(`[apps-sdk] runWorkflowToEnd: ${name} must be a positive number of milliseconds up to ${MAX_TIMER_DELAY_MS}, got ${value}`);
+};
+/** The triggers kept for later while the loop is busy reading, highest first. */
+var PENDING_PRIORITY = [
+	"unavailable",
+	"end",
+	"reconnect"
+];
+var socketUnavailableError = () => /* @__PURE__ */ new Error("Real-time notifications are unavailable, so the end of the workflow run cannot be followed. The run itself may still be going on on the server.");
+/**
+* The triggers, handed by the socket listeners to the wait loop one at a time, so the loop reads
+* as a sequence while the listeners stay callbacks.
+*
+* Only one trigger is kept for later while the loop is busy reading, the highest in
+* `PENDING_PRIORITY`; `progress` only restarts the silence, which matters only while the loop
+* waits. `unavailable` outranks everything, since it ends the wait; `end` outranks `reconnect`,
+* since both lead to a read and the end's read is the one that keeps going.
+*/
+var createTriggerQueue = (signal) => {
+	let pending = null;
+	let wake = null;
+	const outranks = (trigger) => PENDING_PRIORITY.includes(trigger) && (!pending || PENDING_PRIORITY.indexOf(trigger) < PENDING_PRIORITY.indexOf(pending));
+	return {
+		push(trigger) {
+			if (wake) return wake(trigger);
+			if (outranks(trigger)) pending = trigger;
+		},
+		/** The next trigger, or `silence` when none comes within `silenceMs`. */
+		next(silenceMs) {
+			if (pending) {
+				const trigger = pending;
+				pending = null;
+				return Promise.resolve(trigger);
+			}
+			return abortable(signal, (resolve) => {
+				const silenceTimer = setTimeout(() => resolve("silence"), silenceMs);
+				wake = resolve;
+				return () => {
+					clearTimeout(silenceTimer);
+					wake = null;
+				};
+			});
+		}
+	};
+};
+/**
+* Hands `onEvent` the events of one execution. Listening starts at once, and events are kept
+* until `follow` names the execution: a quick run can end before `POST /run` answers. After that,
+* only that execution's events pass — the channel carries every run of the account.
+*/
+var listenToRun = (subscribeToEvents, onEvent) => {
+	let workflowExecutionId = null;
+	const buffered = [];
+	const isFollowed = (event) => event.workflow_execution_id === workflowExecutionId;
+	return {
+		follow(id) {
+			workflowExecutionId = id;
+			buffered.splice(0).filter(isFollowed).forEach(onEvent);
+		},
+		stop: subscribeToEvents((event) => {
+			if (!workflowExecutionId) buffered.push(event);
+			else if (isFollowed(event)) onEvent(event);
+		})
+	};
+};
+/**
+* Follows the socket's status for the wait, starting from the one the subscription reports at
+* once. It reports the socket coming back (`connected` after any other status) and going: an
+* `error` that lasts `unavailableAfterMs` without a reconnect, counted from the first one, since
+* `connecting` in between only means socket.io is retrying. `isConnected` is false from any other
+* status until the next `connected`; the run is not started before then.
+*/
+var watchSocket = (subscribeToStatus, { unavailableAfterMs, onReconnect, onUnavailable }) => {
+	let connected = true;
+	let graceTimer;
+	const endGrace = () => {
+		clearTimeout(graceTimer);
+		graceTimer = void 0;
+	};
+	const stopListening = subscribeToStatus((status) => {
+		if (status === "error" && graceTimer === void 0) graceTimer = setTimeout(onUnavailable, unavailableAfterMs);
+		if (status !== "connected") {
+			connected = false;
+			return;
+		}
+		endGrace();
+		if (!connected) {
+			connected = true;
+			onReconnect();
+		}
+	});
+	return {
+		isConnected: () => connected,
+		stop() {
+			endGrace();
+			stopListening();
+		}
+	};
+};
+/**
+* runWorkflowToEnd
+*
+* Starts a workflow run and waits for it to end, listening to the websocket rather than polling;
+* the end itself is read from the API. Resolves with the ended execution, whatever its
+* `run_status` — deciding what counts as success is the caller's.
+*
+* The websocket says *when* to read, never *what* happened. The backend publishes a
+* `WORKER_EXECUTION_*` event per worker and a `WORKFLOW_EXECUTION_COMPLETED|FAILED` one when the
+* Ender finishes, all on the account's channel. That end event goes out before `run_status` is
+* written, and its `COMPLETED` is the Ender's status, not the run's: so it triggers a read, and
+* then more on a short, doubling delay (`confirmIntervalMs`, capped at `silenceMs`) until the run
+* reads ended — no later event would trigger one.
+*
+* Delivery is at most once, with no replay, and the server cuts every socket about once an hour.
+* So the execution is also read after `silenceMs` without any event of the run, and as soon as
+* the socket reconnects. A read that fails in a way that may pass (no response, a 5XX, a 429) does
+* not end the wait — the next trigger reads again — and the last such failure is the cause if the
+* wait times out, until a read succeeds. Any other failure ends it at once: a 4XX, or anything
+* that is not a request failure, such as a body that is not the expected JSON.
+*
+* The run's end cannot be followed without the socket, so a socket in `error` for
+* `unavailableAfterMs` — its config failed, or the server dropped it — fails the wait. The run is
+* held back until the socket is connected, so it is never started unfollowable, and nothing it
+* publishes goes out before the wait is listening.
+*
+* A timeout or an abort stops everything at once through one signal: the wait, the pause between
+* reads, and the read in flight, whose request is cancelled. The start request is abandoned
+* rather than cancelled — `startRun` takes no signal — so the run may still begin on the server.
+*
+* @param params - The start and read calls, the websocket subscriptions and the wait options.
+* @returns The execution, once its `run_status` is terminal.
+* @throws {Error} If a wait option is not a positive number, the run cannot be started or has no
+*   execution id, a read fails for good, the socket stays unavailable for `unavailableAfterMs`, or
+*   the wait times out or is aborted (`WorkflowRunAbortedError`, with the signal's reason as the cause).
+*/
+var runWorkflowToEnd = async ({ startRun, getExecution, subscribeToEvents, subscribeToStatus, silenceMs = 6e4, timeoutMs = 3e5, confirmIntervalMs = 1e3, unavailableAfterMs = 3e4, signal }) => {
+	requireTimerDelays({
+		silenceMs,
+		timeoutMs,
+		confirmIntervalMs,
+		unavailableAfterMs
+	});
+	let lastError;
+	const deadline = createDeadline({
+		timeoutMs,
+		signal,
+		timeoutError: () => new Error("Timed out while waiting for the workflow run to end", { cause: lastError }),
+		abortError: () => new WorkflowRunAbortedError(signal?.reason)
+	});
+	const waitSignal = deadline.signal;
+	const triggers = createTriggerQueue(waitSignal);
+	const runEvents = listenToRun(subscribeToEvents, (event) => triggers.push(isRunEndEvent(event) ? "end" : "progress"));
+	const connection = watchSocket(subscribeToStatus, {
+		unavailableAfterMs,
+		onReconnect: () => triggers.push("reconnect"),
+		onUnavailable: () => triggers.push("unavailable")
+	});
+	/** Reads the execution once; `null` while the run has not ended. */
+	const readIfEnded = async (id) => {
+		try {
+			const execution = await unlessAborted(getExecution(id, waitSignal), waitSignal);
+			lastError = void 0;
+			return isTerminalRunStatus(execution.run_status) ? execution : null;
+		} catch (error) {
+			if (waitSignal.aborted) throw waitSignal.reason;
+			if (!isRetryableFailure(error)) throw error;
+			lastError = error;
+			return null;
+		}
+	};
+	try {
+		if (waitSignal.aborted) throw waitSignal.reason;
+		while (!connection.isConnected()) if (await triggers.next(silenceMs) === "unavailable") throw socketUnavailableError();
+		const id = (await unlessAborted(startRun(), waitSignal))?.id;
+		if (!id) throw new Error("Workflow run did not return an execution id");
+		runEvents.follow(id);
+		let confirmDelay;
+		for (;;) {
+			const trigger = await triggers.next(confirmDelay ?? silenceMs);
+			if (trigger === "unavailable") throw socketUnavailableError();
+			if (trigger === "progress") continue;
+			if (trigger === "end") confirmDelay = confirmIntervalMs;
+			else if (trigger === "silence" && confirmDelay !== void 0) confirmDelay = Math.min(confirmDelay * 2, silenceMs);
+			const ended = await readIfEnded(id);
+			if (ended) return ended;
+		}
+	} finally {
+		deadline.dispose();
+		runEvents.stop();
+		connection.stop();
+	}
+};
+//#endregion
+export { RUN_FAILED_MESSAGE, WorkflowRunAbortedError, runWorkflowToEnd };
+
+//# sourceMappingURL=workflowRun.js.map

package/dist/lib/workflowRun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflowRun.js","names":[],"sources":["../../src/lib/workflowRun.ts"],"sourcesContent":["import { isRetryableFailure } from \"@/api/request\";\nimport { isTerminalRunStatus } from \"@/api/workflow\";\nimport { abortable, createDeadline, unlessAborted } from \"@/lib/abort\";\nimport type { WebSocketNotification, WebSocketStatus } from \"@/contexts/webSocketContext/types\";\nimport type { WorkflowExecution } from \"@/types/workflow\";\n\n/** The alert a run hook shows when its failure carries no message of its own. */\nexport const RUN_FAILED_MESSAGE = \"Unable to run the workflow. Please try again.\";\n\n/** The events the backend sends when a run's Ender finishes. */\nconst RUN_END_EVENTS: readonly string[] = [\n    \"WORKFLOW_EXECUTION_COMPLETED\",\n    \"WORKFLOW_EXECUTION_FAILED\",\n];\n\nconst isRunEndEvent = (event: WebSocketNotification) => RUN_END_EVENTS.includes(event.event_type);\n\n/**\n * The error a run ends with when its caller stopped it — the screen went away, or the app's own\n * signal — with that signal's reason as the cause. One class for both phases, the wait and the\n * result read, so a caller can tell a stop from a failure with `instanceof` rather than by its\n * message.\n */\nexport class WorkflowRunAbortedError extends Error {\n    constructor(reason: unknown) {\n        super(\"Waiting for the workflow run was aborted\", { cause: reason });\n        this.name = \"WorkflowRunAbortedError\";\n    }\n}\n\n/** The longest delay `setTimeout` honours; it fires a longer one after 1 ms. */\nconst MAX_TIMER_DELAY_MS = 2 ** 31 - 1;\n\n/**\n * Throws when a wait option is not a positive number a timer can wait: zero or NaN would read\n * back to back, and above `MAX_TIMER_DELAY_MS` the timer fires at once.\n */\nconst requireTimerDelays = (options: Record<string, number>) => {\n    for (const [name, value] of Object.entries(options)) {\n        if (!(value > 0 && value <= MAX_TIMER_DELAY_MS)) {\n            throw new Error(\n                `[apps-sdk] runWorkflowToEnd: ${name} must be a positive number of milliseconds up to ${MAX_TIMER_DELAY_MS}, got ${value}`,\n            );\n        }\n    }\n};\n\nexport type WorkflowWaitOptions = {\n    /**\n     * How long the run may go without any event before the execution is read anyway, in\n     * milliseconds. Defaults to a minute. It covers a lost event, and a long worker, which sends\n     * nothing while it runs.\n     */\n    silenceMs?: number;\n    /** How long to wait for the run to end before giving up, in milliseconds. Defaults to 5 minutes. */\n    timeoutMs?: number;\n    /**\n     * The first gap between reads after the end event, while the run still reads RUNNING, in\n     * milliseconds. It doubles each time it passes without a new event, up to `silenceMs`.\n     * Defaults to 1 second.\n     */\n    confirmIntervalMs?: number;\n    /**\n     * How long the socket may stay in `error` before the run is given up on as unfollowable, in\n     * milliseconds. Defaults to 30 seconds: socket.io keeps retrying after a failed reconnect, on\n     * a backoff that alone can reach about 7.5 seconds between attempts.\n     */\n    unavailableAfterMs?: number;\n    /** Stops waiting. `useRunWorkflow` also stops when its screen unmounts. */\n    signal?: AbortSignal;\n};\n\nexport type RunWorkflowToEndParams = WorkflowWaitOptions & {\n    /** Starts the run (`POST /workflows/:id/run`) and returns the execution it created. */\n    startRun: () => Promise<WorkflowExecution>;\n    /**\n     * Reads the execution; its `run_status` is what says the run ended, and how. Pass `signal` to\n     * the request, so a timeout or an abort cancels a read in flight.\n     */\n    getExecution: (workflowExecutionId: string, signal: AbortSignal) => Promise<WorkflowExecution>;\n    /** The websocket context's `subscribe`. */\n    subscribeToEvents: (listener: (event: WebSocketNotification) => void) => () => void;\n    /**\n     * The websocket context's `subscribeStatus`, which tells a new listener the current status at\n     * once: that is how the wait learns the status it begins in.\n     */\n    subscribeToStatus: (listener: (status: WebSocketStatus) => void) => () => void;\n};\n\n/**\n * What wakes the wait up: an event of the run (`progress`, or `end` for the Ender's), the socket\n * coming back (`reconnect`) or going (`unavailable`), or nothing at all for `silenceMs` (`silence`).\n */\ntype Trigger = \"progress\" | \"end\" | \"reconnect\" | \"unavailable\" | \"silence\";\n\n/** The triggers kept for later while the loop is busy reading, highest first. */\nconst PENDING_PRIORITY: Trigger[] = [\"unavailable\", \"end\", \"reconnect\"];\n\nconst socketUnavailableError = () =>\n    new Error(\n        \"Real-time notifications are unavailable, so the end of the workflow run cannot be followed. \" +\n            \"The run itself may still be going on on the server.\",\n    );\n\n/**\n * The triggers, handed by the socket listeners to the wait loop one at a time, so the loop reads\n * as a sequence while the listeners stay callbacks.\n *\n * Only one trigger is kept for later while the loop is busy reading, the highest in\n * `PENDING_PRIORITY`; `progress` only restarts the silence, which matters only while the loop\n * waits. `unavailable` outranks everything, since it ends the wait; `end` outranks `reconnect`,\n * since both lead to a read and the end's read is the one that keeps going.\n */\nconst createTriggerQueue = (signal: AbortSignal) => {\n    let pending: Trigger | null = null;\n    let wake: ((trigger: Trigger) => void) | null = null;\n    const outranks = (trigger: Trigger) =>\n        PENDING_PRIORITY.includes(trigger) &&\n        (!pending || PENDING_PRIORITY.indexOf(trigger) < PENDING_PRIORITY.indexOf(pending));\n\n    return {\n        push(trigger: Trigger) {\n            if (wake) return wake(trigger);\n            if (outranks(trigger)) pending = trigger;\n        },\n        /** The next trigger, or `silence` when none comes within `silenceMs`. */\n        next(silenceMs: number): Promise<Trigger> {\n            if (pending) {\n                const trigger = pending;\n                pending = null;\n                return Promise.resolve(trigger);\n            }\n            return abortable<Trigger>(signal, (resolve) => {\n                const silenceTimer = setTimeout(() => resolve(\"silence\"), silenceMs);\n                wake = resolve;\n                return () => {\n                    clearTimeout(silenceTimer);\n                    wake = null;\n                };\n            });\n        },\n    };\n};\n\n/**\n * Hands `onEvent` the events of one execution. Listening starts at once, and events are kept\n * until `follow` names the execution: a quick run can end before `POST /run` answers. After that,\n * only that execution's events pass — the channel carries every run of the account.\n */\nconst listenToRun = (\n    subscribeToEvents: RunWorkflowToEndParams[\"subscribeToEvents\"],\n    onEvent: (event: WebSocketNotification) => void,\n) => {\n    let workflowExecutionId: string | null = null;\n    const buffered: WebSocketNotification[] = [];\n    const isFollowed = (event: WebSocketNotification) =>\n        event.workflow_execution_id === workflowExecutionId;\n\n    const stop = subscribeToEvents((event) => {\n        if (!workflowExecutionId) buffered.push(event);\n        else if (isFollowed(event)) onEvent(event);\n    });\n\n    return {\n        follow(id: string) {\n            workflowExecutionId = id;\n            buffered.splice(0).filter(isFollowed).forEach(onEvent);\n        },\n        stop,\n    };\n};\n\n/**\n * Follows the socket's status for the wait, starting from the one the subscription reports at\n * once. It reports the socket coming back (`connected` after any other status) and going: an\n * `error` that lasts `unavailableAfterMs` without a reconnect, counted from the first one, since\n * `connecting` in between only means socket.io is retrying. `isConnected` is false from any other\n * status until the next `connected`; the run is not started before then.\n */\nconst watchSocket = (\n    subscribeToStatus: RunWorkflowToEndParams[\"subscribeToStatus\"],\n    {\n        unavailableAfterMs,\n        onReconnect,\n        onUnavailable,\n    }: { unavailableAfterMs: number; onReconnect: () => void; onUnavailable: () => void },\n) => {\n    let connected = true;\n    let graceTimer: ReturnType<typeof setTimeout> | undefined;\n    const endGrace = () => {\n        clearTimeout(graceTimer);\n        graceTimer = undefined;\n    };\n\n    const stopListening = subscribeToStatus((status) => {\n        if (status === \"error\" && graceTimer === undefined)\n            graceTimer = setTimeout(onUnavailable, unavailableAfterMs);\n        if (status !== \"connected\") {\n            connected = false;\n            return;\n        }\n        endGrace();\n        if (!connected) {\n            connected = true;\n            onReconnect();\n        }\n    });\n\n    return {\n        isConnected: () => connected,\n        stop() {\n            endGrace();\n            stopListening();\n        },\n    };\n};\n\n/**\n * runWorkflowToEnd\n *\n * Starts a workflow run and waits for it to end, listening to the websocket rather than polling;\n * the end itself is read from the API. Resolves with the ended execution, whatever its\n * `run_status` — deciding what counts as success is the caller's.\n *\n * The websocket says *when* to read, never *what* happened. The backend publishes a\n * `WORKER_EXECUTION_*` event per worker and a `WORKFLOW_EXECUTION_COMPLETED|FAILED` one when the\n * Ender finishes, all on the account's channel. That end event goes out before `run_status` is\n * written, and its `COMPLETED` is the Ender's status, not the run's: so it triggers a read, and\n * then more on a short, doubling delay (`confirmIntervalMs`, capped at `silenceMs`) until the run\n * reads ended — no later event would trigger one.\n *\n * Delivery is at most once, with no replay, and the server cuts every socket about once an hour.\n * So the execution is also read after `silenceMs` without any event of the run, and as soon as\n * the socket reconnects. A read that fails in a way that may pass (no response, a 5XX, a 429) does\n * not end the wait — the next trigger reads again — and the last such failure is the cause if the\n * wait times out, until a read succeeds. Any other failure ends it at once: a 4XX, or anything\n * that is not a request failure, such as a body that is not the expected JSON.\n *\n * The run's end cannot be followed without the socket, so a socket in `error` for\n * `unavailableAfterMs` — its config failed, or the server dropped it — fails the wait. The run is\n * held back until the socket is connected, so it is never started unfollowable, and nothing it\n * publishes goes out before the wait is listening.\n *\n * A timeout or an abort stops everything at once through one signal: the wait, the pause between\n * reads, and the read in flight, whose request is cancelled. The start request is abandoned\n * rather than cancelled — `startRun` takes no signal — so the run may still begin on the server.\n *\n * @param params - The start and read calls, the websocket subscriptions and the wait options.\n * @returns The execution, once its `run_status` is terminal.\n * @throws {Error} If a wait option is not a positive number, the run cannot be started or has no\n *   execution id, a read fails for good, the socket stays unavailable for `unavailableAfterMs`, or\n *   the wait times out or is aborted (`WorkflowRunAbortedError`, with the signal's reason as the cause).\n */\nexport const runWorkflowToEnd = async ({\n    startRun,\n    getExecution,\n    subscribeToEvents,\n    subscribeToStatus,\n    silenceMs = 60_000,\n    timeoutMs = 5 * 60_000,\n    confirmIntervalMs = 1_000,\n    unavailableAfterMs = 30_000,\n    signal,\n}: RunWorkflowToEndParams): Promise<WorkflowExecution> => {\n    requireTimerDelays({ silenceMs, timeoutMs, confirmIntervalMs, unavailableAfterMs });\n\n    let lastError: unknown;\n    const deadline = createDeadline({\n        timeoutMs,\n        signal,\n        timeoutError: () =>\n            new Error(\"Timed out while waiting for the workflow run to end\", { cause: lastError }),\n        abortError: () => new WorkflowRunAbortedError(signal?.reason),\n    });\n    const waitSignal = deadline.signal;\n\n    const triggers = createTriggerQueue(waitSignal);\n    const runEvents = listenToRun(subscribeToEvents, (event) =>\n        triggers.push(isRunEndEvent(event) ? \"end\" : \"progress\"),\n    );\n    const connection = watchSocket(subscribeToStatus, {\n        unavailableAfterMs,\n        onReconnect: () => triggers.push(\"reconnect\"),\n        onUnavailable: () => triggers.push(\"unavailable\"),\n    });\n\n    /** Reads the execution once; `null` while the run has not ended. */\n    const readIfEnded = async (id: string) => {\n        try {\n            const execution = await unlessAborted(getExecution(id, waitSignal), waitSignal);\n            lastError = undefined;\n            return isTerminalRunStatus(execution.run_status) ? execution : null;\n        } catch (error) {\n            if (waitSignal.aborted) throw waitSignal.reason;\n            if (!isRetryableFailure(error)) throw error;\n            lastError = error;\n            return null;\n        }\n    };\n\n    try {\n        if (waitSignal.aborted) throw waitSignal.reason;\n        while (!connection.isConnected()) {\n            if ((await triggers.next(silenceMs)) === \"unavailable\") throw socketUnavailableError();\n        }\n\n        const id = (await unlessAborted(startRun(), waitSignal))?.id;\n        if (!id) throw new Error(\"Workflow run did not return an execution id\");\n        runEvents.follow(id);\n\n        let confirmDelay: number | undefined;\n        for (;;) {\n            const trigger = await triggers.next(confirmDelay ?? silenceMs);\n            if (trigger === \"unavailable\") throw socketUnavailableError();\n            if (trigger === \"progress\") continue;\n\n            if (trigger === \"end\") confirmDelay = confirmIntervalMs;\n            else if (trigger === \"silence\" && confirmDelay !== undefined)\n                confirmDelay = Math.min(confirmDelay * 2, silenceMs);\n\n            const ended = await readIfEnded(id);\n            if (ended) return ended;\n        }\n    } finally {\n        deadline.dispose();\n        runEvents.stop();\n        connection.stop();\n    }\n};\n"],"mappings":"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"}

package/dist/socket/index.d.ts

@@ -1,10 +1,8 @@
 export * from "../contexts/webSocketContext/index.js";
 export * from "../contexts/webSocketContext/provider.js";
 export * from "../contexts/webSocketContext/types.d.ts";
-export * from "../contexts/webSocketContext/constants.js";
-export * from "../contexts/webSocketContext/handler.js";
+export { APP_NOTIFICATION_EVENT_TYPE } from "../contexts/webSocketContext/constants.js";
 export * from "../contexts/webSocketContext/hooks/useWebSocket/index.js";
 export * from "../contexts/webSocketContext/hooks/useWebSocketSubscription/index.js";
 export * from "../contexts/webSocketContext/hooks/useAppNotificationSubscription/index.js";
-export * from "../api/websocketsConfig.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/socket/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/socket/index.ts"],"names":[],"mappings":"AAUA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AACtD,cAAc,qCAAqC,CAAC;AACpD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,4DAA4D,CAAC;AAC3E,cAAc,kEAAkE,CAAC;AACjF,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/socket/index.ts"],"names":[],"mappings":"AAUA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,OAAO,EAAE,2BAA2B,EAAE,MAAM,uCAAuC,CAAC;AACpF,cAAc,gDAAgD,CAAC;AAC/D,cAAc,4DAA4D,CAAC;AAC3E,cAAc,kEAAkE,CAAC"}

package/dist/socket/index.js

@@ -1,9 +1,7 @@
 import { WebSocketContext } from "../contexts/webSocketContext/index.js";
-import { getWebsocketsConfig } from "../api/websocketsConfig.js";
-import { APP_NOTIFICATION_EVENT_TYPE, JOIN_EVENT, NOTIFICATION_EVENT } from "../contexts/webSocketContext/constants.js";
-import { WebSocketHandler } from "../contexts/webSocketContext/handler.js";
-import { WebSocketProvider } from "../contexts/webSocketContext/provider.js";
 import { useWebSocket } from "../contexts/webSocketContext/hooks/useWebSocket/index.js";
+import { APP_NOTIFICATION_EVENT_TYPE } from "../contexts/webSocketContext/constants.js";
+import { WebSocketProvider } from "../contexts/webSocketContext/provider.js";
 import { useWebSocketSubscription } from "../contexts/webSocketContext/hooks/useWebSocketSubscription/index.js";
 import { useAppNotificationSubscription } from "../contexts/webSocketContext/hooks/useAppNotificationSubscription/index.js";
-export { APP_NOTIFICATION_EVENT_TYPE, JOIN_EVENT, NOTIFICATION_EVENT, WebSocketContext, WebSocketHandler, WebSocketProvider, getWebsocketsConfig, useAppNotificationSubscription, useWebSocket, useWebSocketSubscription };
+export { APP_NOTIFICATION_EVENT_TYPE, WebSocketContext, WebSocketProvider, useAppNotificationSubscription, useWebSocket, useWebSocketSubscription };

package/dist/test/mocks/index.d.ts

@@ -1,5 +1,5 @@
 export { agGridReactMock } from "./agGridReact";
-export { agGridEnterpriseMock, getAgGridLicenseKey, resetAgGridLicense, } from "./agGridEnterprise";
+export { agGridEnterpriseMock, getAgGridLicenseKey, resetAgGridLicense } from "./agGridEnterprise";
 export { socketIoClientMock, createMockSocket, getMockSocket, resetMockSocket, } from "./socketIoClient";
 export type { MockSocket, SocketEventHandler } from "./socketIoClient";
 //# sourceMappingURL=index.d.ts.map

package/dist/test/mocks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/test/mocks/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EACH,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,GACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACH,kBAAkB,EAClB,gBAAgB,EAChB,aAAa,EACb,eAAe,GAClB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/test/mocks/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACnG,OAAO,EACH,kBAAkB,EAClB,gBAAgB,EAChB,aAAa,EACb,eAAe,GAClB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/test/msw/fakeApi.d.ts

@@ -0,0 +1,43 @@
+import { type SetupServer } from "msw/node";
+import { type RecordedRequest } from "./recorder";
+import { type FakeApiSeed, type FakeApiStore } from "./store";
+export type FakeApi = {
+    store: FakeApiStore;
+    requests: RecordedRequest[];
+    /** Replaces what the store holds. */
+    seed: (data: FakeApiSeed) => void;
+    /** Answers the next matching request with the API's error body, once. */
+    fail: (method: string, path: string, status: number, message?: string) => void;
+    /** The MSW server, for a handler of an app's own (`api.server.use(...)`). */
+    server: SetupServer;
+};
+/**
+ * setupFakeApi — a fake of the API behind the app's `/api`, for tests that render pages with
+ * the SDK's real hooks.
+ *
+ * The hooks, their axios instance and the query cache run for real; MSW answers the requests
+ * they send from an in-memory store, the way the API would. A test seeds data, renders, and
+ * asserts on what the page shows and on `requests`, what it sent. Nothing ties a test to the
+ * SDK's files: mocking its modules by path did, and could not reach its hooks at all once the
+ * SDK was a package.
+ *
+ * Every request an SDK hook sends is answered: datastores, files and portfolios (listed by
+ * JSON query), workflows and workspaces (by text search), workflow and worker executions, a
+ * workflow run, the profile and the websocket config. `useRunWorkflow` waits for a run's end
+ * over the websocket, which this does not fake; pair it with the socket double in
+ * `@everysk/apps-sdk/test/mocks`.
+ *
+ * Call it once at the top of a test file. It registers its own `beforeAll`, `afterEach` and
+ * `afterAll`: the server listens for the file, and the store, the recorded requests and any
+ * pending failure are cleared after every test. A request no handler answers fails the test,
+ * so a page that calls an endpoint the fake does not have says so instead of hanging.
+ *
+ * The behaviour follows the API as `CLAUDE.md` records it (Platform facts): a JSON query's
+ * filters, order, projection and page (20 by default, the URL's `page_size` and `page_token`
+ * winning), a text search's id, `#tag`, `&link_uid` or name prefix (10 a page), a create
+ * defaulting the workspace to `main`, a delete answering with one object, a run answering 202
+ * with a RUNNING execution, worker executions grouped and unpaginated, and errors as
+ * `{ code, message }`.
+ */
+export declare const setupFakeApi: () => FakeApi;
+//# sourceMappingURL=fakeApi.d.ts.map

package/dist/test/msw/fakeApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakeApi.d.ts","sourceRoot":"","sources":["../../../src/test/msw/fakeApi.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AAGzD,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAyB,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAErF,MAAM,MAAM,OAAO,GAAG;IAClB,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,qCAAqC;IACrC,IAAI,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC;IAClC,yEAAyE;IACzE,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/E,6EAA6E;IAC7E,MAAM,EAAE,WAAW,CAAC;CACvB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,YAAY,QAAO,OAoC/B,CAAC"}

package/dist/test/msw/fakeApi.js

@@ -0,0 +1,74 @@
+import { recordRequests } from "./recorder.js";
+import { emptyStore, storeFrom } from "./store.js";
+import { fakeApiHandlers } from "./handlers.js";
+import { afterAll, afterEach, beforeAll } from "vitest";
+import { setupServer } from "msw/node";
+//#region src/test/msw/fakeApi.ts
+/**
+* setupFakeApi — a fake of the API behind the app's `/api`, for tests that render pages with
+* the SDK's real hooks.
+*
+* The hooks, their axios instance and the query cache run for real; MSW answers the requests
+* they send from an in-memory store, the way the API would. A test seeds data, renders, and
+* asserts on what the page shows and on `requests`, what it sent. Nothing ties a test to the
+* SDK's files: mocking its modules by path did, and could not reach its hooks at all once the
+* SDK was a package.
+*
+* Every request an SDK hook sends is answered: datastores, files and portfolios (listed by
+* JSON query), workflows and workspaces (by text search), workflow and worker executions, a
+* workflow run, the profile and the websocket config. `useRunWorkflow` waits for a run's end
+* over the websocket, which this does not fake; pair it with the socket double in
+* `@everysk/apps-sdk/test/mocks`.
+*
+* Call it once at the top of a test file. It registers its own `beforeAll`, `afterEach` and
+* `afterAll`: the server listens for the file, and the store, the recorded requests and any
+* pending failure are cleared after every test. A request no handler answers fails the test,
+* so a page that calls an endpoint the fake does not have says so instead of hanging.
+*
+* The behaviour follows the API as `CLAUDE.md` records it (Platform facts): a JSON query's
+* filters, order, projection and page (20 by default, the URL's `page_size` and `page_token`
+* winning), a text search's id, `#tag`, `&link_uid` or name prefix (10 a page), a create
+* defaulting the workspace to `main`, a delete answering with one object, a run answering 202
+* with a RUNNING execution, worker executions grouped and unpaginated, and errors as
+* `{ code, message }`.
+*/
+var setupFakeApi = () => {
+	let failures = [];
+	const api = {
+		store: emptyStore(),
+		requests: [],
+		seed: (data) => {
+			api.store = storeFrom(data);
+		},
+		fail: (method, path, status, message = `Request failed with status ${status}`) => {
+			failures.push({
+				method: method.toUpperCase(),
+				path,
+				status,
+				message
+			});
+		},
+		server: setupServer(...fakeApiHandlers({
+			store: () => api.store,
+			takeFailure: (method, path) => {
+				const failure = failures.find((f) => f.method === method && f.path === path);
+				failures = failures.filter((f) => f !== failure);
+				return failure;
+			}
+		}))
+	};
+	recordRequests(api.server, () => api.requests);
+	beforeAll(() => api.server.listen({ onUnhandledRequest: "error" }));
+	afterEach(() => {
+		api.server.resetHandlers();
+		api.store = emptyStore();
+		api.requests = [];
+		failures = [];
+	});
+	afterAll(() => api.server.close());
+	return api;
+};
+//#endregion
+export { setupFakeApi };
+
+//# sourceMappingURL=fakeApi.js.map

package/dist/test/msw/fakeApi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakeApi.js","names":[],"sources":["../../../src/test/msw/fakeApi.ts"],"sourcesContent":["import { afterAll, afterEach, beforeAll } from \"vitest\";\nimport { setupServer, type SetupServer } from \"msw/node\";\n\nimport { fakeApiHandlers, type Failure } from \"./handlers\";\nimport { recordRequests, type RecordedRequest } from \"./recorder\";\nimport { emptyStore, storeFrom, type FakeApiSeed, type FakeApiStore } from \"./store\";\n\nexport type FakeApi = {\n    store: FakeApiStore;\n    requests: RecordedRequest[];\n    /** Replaces what the store holds. */\n    seed: (data: FakeApiSeed) => void;\n    /** Answers the next matching request with the API's error body, once. */\n    fail: (method: string, path: string, status: number, message?: string) => void;\n    /** The MSW server, for a handler of an app's own (`api.server.use(...)`). */\n    server: SetupServer;\n};\n\n/**\n * setupFakeApi — a fake of the API behind the app's `/api`, for tests that render pages with\n * the SDK's real hooks.\n *\n * The hooks, their axios instance and the query cache run for real; MSW answers the requests\n * they send from an in-memory store, the way the API would. A test seeds data, renders, and\n * asserts on what the page shows and on `requests`, what it sent. Nothing ties a test to the\n * SDK's files: mocking its modules by path did, and could not reach its hooks at all once the\n * SDK was a package.\n *\n * Every request an SDK hook sends is answered: datastores, files and portfolios (listed by\n * JSON query), workflows and workspaces (by text search), workflow and worker executions, a\n * workflow run, the profile and the websocket config. `useRunWorkflow` waits for a run's end\n * over the websocket, which this does not fake; pair it with the socket double in\n * `@everysk/apps-sdk/test/mocks`.\n *\n * Call it once at the top of a test file. It registers its own `beforeAll`, `afterEach` and\n * `afterAll`: the server listens for the file, and the store, the recorded requests and any\n * pending failure are cleared after every test. A request no handler answers fails the test,\n * so a page that calls an endpoint the fake does not have says so instead of hanging.\n *\n * The behaviour follows the API as `CLAUDE.md` records it (Platform facts): a JSON query's\n * filters, order, projection and page (20 by default, the URL's `page_size` and `page_token`\n * winning), a text search's id, `#tag`, `&link_uid` or name prefix (10 a page), a create\n * defaulting the workspace to `main`, a delete answering with one object, a run answering 202\n * with a RUNNING execution, worker executions grouped and unpaginated, and errors as\n * `{ code, message }`.\n */\nexport const setupFakeApi = (): FakeApi => {\n    let failures: Failure[] = [];\n\n    const api: FakeApi = {\n        store: emptyStore(),\n        requests: [],\n        seed: (data) => {\n            api.store = storeFrom(data);\n        },\n        fail: (method, path, status, message = `Request failed with status ${status}`) => {\n            failures.push({ method: method.toUpperCase(), path, status, message });\n        },\n        server: setupServer(\n            ...fakeApiHandlers({\n                store: () => api.store,\n                takeFailure: (method, path) => {\n                    const failure = failures.find((f) => f.method === method && f.path === path);\n                    failures = failures.filter((f) => f !== failure);\n                    return failure;\n                },\n            }),\n        ),\n    };\n\n    recordRequests(api.server, () => api.requests);\n\n    beforeAll(() => api.server.listen({ onUnhandledRequest: \"error\" }));\n    afterEach(() => {\n        api.server.resetHandlers();\n        api.store = emptyStore();\n        api.requests = [];\n        failures = [];\n    });\n    afterAll(() => api.server.close());\n\n    return api;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,IAAa,qBAA8B;CACvC,IAAI,WAAsB,CAAC;CAE3B,MAAM,MAAe;EACjB,OAAO,WAAW;EAClB,UAAU,CAAC;EACX,OAAO,SAAS;GACZ,IAAI,QAAQ,UAAU,IAAI;EAC9B;EACA,OAAO,QAAQ,MAAM,QAAQ,UAAU,8BAA8B,aAAa;GAC9E,SAAS,KAAK;IAAE,QAAQ,OAAO,YAAY;IAAG;IAAM;IAAQ;GAAQ,CAAC;EACzE;EACA,QAAQ,YACJ,GAAG,gBAAgB;GACf,aAAa,IAAI;GACjB,cAAc,QAAQ,SAAS;IAC3B,MAAM,UAAU,SAAS,MAAM,MAAM,EAAE,WAAW,UAAU,EAAE,SAAS,IAAI;IAC3E,WAAW,SAAS,QAAQ,MAAM,MAAM,OAAO;IAC/C,OAAO;GACX;EACJ,CAAC,CACL;CACJ;CAEA,eAAe,IAAI,cAAc,IAAI,QAAQ;CAE7C,gBAAgB,IAAI,OAAO,OAAO,EAAE,oBAAoB,QAAQ,CAAC,CAAC;CAClE,gBAAgB;EACZ,IAAI,OAAO,cAAc;EACzB,IAAI,QAAQ,WAAW;EACvB,IAAI,WAAW,CAAC;EAChB,WAAW,CAAC;CAChB,CAAC;CACD,eAAe,IAAI,OAAO,MAAM,CAAC;CAEjC,OAAO;AACX"}

package/dist/test/msw/handlers.d.ts

@@ -0,0 +1,20 @@
+import { type HttpHandler } from "msw";
+import { type FakeApiStore } from "./store";
+export type Failure = {
+    method: string;
+    path: string;
+    status: number;
+    message: string;
+};
+/** What the handlers read and write: the store, and the failures queued. */
+export type FakeState = {
+    store: () => FakeApiStore;
+    takeFailure: (method: string, path: string) => Failure | undefined;
+};
+export declare const errorBody: (status: number, message: string) => {
+    code: number;
+    message: string;
+};
+/** Every route the SDK's request functions call. */
+export declare const fakeApiHandlers: (state: FakeState) => HttpHandler[];
+//# sourceMappingURL=handlers.d.ts.map

package/dist/test/msw/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../../src/test/msw/handlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,WAAW,EAAqB,MAAM,KAAK,CAAC;AAO9E,OAAO,EAA+B,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAEzE,MAAM,MAAM,OAAO,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAExF,4EAA4E;AAC5E,MAAM,MAAM,SAAS,GAAG;IACpB,KAAK,EAAE,MAAM,YAAY,CAAC;IAC1B,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,CAAC;CACtE,CAAC;AASF,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,EAAE,SAAS,MAAM;;;CAAgC,CAAC;AAoS1F,oDAAoD;AACpD,eAAO,MAAM,eAAe,GAAI,OAAO,SAAS,KAAG,WAAW,EAgC7D,CAAC"}