@bolt-foundry/gambit 0.8.5 → 0.8.6-rc.1

package/esm/simulator-ui/src/hooks/graphqlSubscriptionSseClient.js

@@ -0,0 +1,209 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _GraphqlSubscriptionSseClient_instances, _GraphqlSubscriptionSseClient_sessionId, _GraphqlSubscriptionSseClient_offsetStorageKey, _GraphqlSubscriptionSseClient_closeWhenIdle, _GraphqlSubscriptionSseClient_source, _GraphqlSubscriptionSseClient_listeners, _GraphqlSubscriptionSseClient_ensureSource;
+const DEFAULT_SESSION_KEY = "gambit.graphql.stream.session_id";
+const DEFAULT_OFFSET_KEY = "gambit.graphql.stream.offset";
+const GRAPHQL_STREAM_EVENT_TYPES = [
+    "subscribed",
+    "next",
+    "error",
+    "complete",
+    "unsubscribed",
+];
+function readOffset(storageKey) {
+    try {
+        const raw = globalThis.localStorage.getItem(storageKey);
+        if (!raw)
+            return null;
+        const parsed = Number(raw);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeOffset(storageKey, offset) {
+    try {
+        globalThis.localStorage.setItem(storageKey, String(offset));
+    }
+    catch {
+        // Ignore storage write failures.
+    }
+}
+function getSessionOffsetStorageKey(baseKey, sessionId) {
+    return `${baseKey}.${sessionId}`;
+}
+function getOrCreateSessionId() {
+    try {
+        const existing = globalThis.sessionStorage.getItem(DEFAULT_SESSION_KEY);
+        if (existing && existing.trim().length > 0)
+            return existing;
+        const created = crypto.randomUUID();
+        globalThis.sessionStorage.setItem(DEFAULT_SESSION_KEY, created);
+        return created;
+    }
+    catch {
+        return crypto.randomUUID();
+    }
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isGraphqlEnvelope(value) {
+    if (!isRecord(value))
+        return false;
+    return typeof value.type === "string" &&
+        typeof value.sessionId === "string" &&
+        typeof value.subscriptionId === "string" &&
+        typeof value.operationId === "string" &&
+        typeof value.createdAt === "string";
+}
+async function postControl(body) {
+    const response = await fetch("/graphql/stream", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        throw new Error(`GraphQL stream control failed (${response.status})`);
+    }
+}
+export class GraphqlSubscriptionSseClient {
+    constructor(options) {
+        _GraphqlSubscriptionSseClient_instances.add(this);
+        _GraphqlSubscriptionSseClient_sessionId.set(this, void 0);
+        _GraphqlSubscriptionSseClient_offsetStorageKey.set(this, void 0);
+        _GraphqlSubscriptionSseClient_closeWhenIdle.set(this, void 0);
+        _GraphqlSubscriptionSseClient_source.set(this, null);
+        _GraphqlSubscriptionSseClient_listeners.set(this, new Map());
+        __classPrivateFieldSet(this, _GraphqlSubscriptionSseClient_sessionId, options?.sessionId?.trim() || getOrCreateSessionId(), "f");
+        __classPrivateFieldSet(this, _GraphqlSubscriptionSseClient_offsetStorageKey, getSessionOffsetStorageKey(options?.offsetStorageKey ?? DEFAULT_OFFSET_KEY, __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_sessionId, "f")), "f");
+        __classPrivateFieldSet(this, _GraphqlSubscriptionSseClient_closeWhenIdle, options?.closeWhenIdle ?? true, "f");
+    }
+    get sessionId() {
+        return __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_sessionId, "f");
+    }
+    async subscribe(request) {
+        if (!request.subscriptionId.trim()) {
+            throw new Error("subscriptionId is required");
+        }
+        if (!request.query.trim()) {
+            throw new Error("query is required");
+        }
+        __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_instances, "m", _GraphqlSubscriptionSseClient_ensureSource).call(this);
+        let listeners = __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_listeners, "f").get(request.subscriptionId);
+        if (!listeners) {
+            listeners = new Set();
+            __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_listeners, "f").set(request.subscriptionId, listeners);
+        }
+        listeners.add(request.onEnvelope);
+        try {
+            await postControl({
+                action: "subscribe",
+                sessionId: __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_sessionId, "f"),
+                subscriptionId: request.subscriptionId,
+                query: request.query,
+                variables: request.variables ?? {},
+                operationName: request.operationName ?? undefined,
+            });
+        }
+        catch (error) {
+            const current = __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_listeners, "f").get(request.subscriptionId);
+            if (current) {
+                current.delete(request.onEnvelope);
+                if (current.size === 0) {
+                    __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_listeners, "f").delete(request.subscriptionId);
+                }
+            }
+            if (__classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_listeners, "f").size === 0 && __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_closeWhenIdle, "f")) {
+                this.close();
+            }
+            throw error;
+        }
+        return async (options) => {
+            const notifyServer = options?.notifyServer !== false;
+            const current = __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_listeners, "f").get(request.subscriptionId);
+            if (current) {
+                current.delete(request.onEnvelope);
+                if (current.size === 0) {
+                    __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_listeners, "f").delete(request.subscriptionId);
+                    if (notifyServer) {
+                        await postControl({
+                            action: "unsubscribe",
+                            sessionId: __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_sessionId, "f"),
+                            subscriptionId: request.subscriptionId,
+                        });
+                    }
+                }
+            }
+            if (__classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_listeners, "f").size === 0 && __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_closeWhenIdle, "f")) {
+                this.close();
+            }
+        };
+    }
+    close() {
+        if (__classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_source, "f")) {
+            __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_source, "f").close();
+            __classPrivateFieldSet(this, _GraphqlSubscriptionSseClient_source, null, "f");
+        }
+    }
+}
+_GraphqlSubscriptionSseClient_sessionId = new WeakMap(), _GraphqlSubscriptionSseClient_offsetStorageKey = new WeakMap(), _GraphqlSubscriptionSseClient_closeWhenIdle = new WeakMap(), _GraphqlSubscriptionSseClient_source = new WeakMap(), _GraphqlSubscriptionSseClient_listeners = new WeakMap(), _GraphqlSubscriptionSseClient_instances = new WeakSet(), _GraphqlSubscriptionSseClient_ensureSource = function _GraphqlSubscriptionSseClient_ensureSource() {
+    if (__classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_source, "f"))
+        return;
+    const origin = globalThis.location?.origin ?? "http://localhost";
+    const url = new URL("/graphql/stream", origin);
+    url.searchParams.set("sessionId", __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_sessionId, "f"));
+    const offset = readOffset(__classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_offsetStorageKey, "f"));
+    if (offset !== null) {
+        url.searchParams.set("offset", String(offset));
+    }
+    const source = new EventSource(url.toString());
+    const handleMessage = (message) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(message.data);
+        }
+        catch {
+            return;
+        }
+        if (!isGraphqlEnvelope(parsed))
+            return;
+        const envelope = parsed;
+        const offsetValue = Number(message.lastEventId);
+        if (Number.isFinite(offsetValue)) {
+            writeOffset(__classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_offsetStorageKey, "f"), offsetValue + 1);
+        }
+        const listeners = __classPrivateFieldGet(this, _GraphqlSubscriptionSseClient_listeners, "f").get(envelope.subscriptionId);
+        if (!listeners || listeners.size === 0)
+            return;
+        for (const listener of listeners) {
+            listener(envelope, {
+                offset: Number.isFinite(offsetValue) ? offsetValue : null,
+                eventType: message.type,
+            });
+        }
+    };
+    for (const type of GRAPHQL_STREAM_EVENT_TYPES) {
+        source.addEventListener(type, handleMessage);
+    }
+    __classPrivateFieldSet(this, _GraphqlSubscriptionSseClient_source, source, "f");
+};
+let globalClient = null;
+export function getGraphqlSubscriptionSseClient() {
+    if (globalClient)
+        return globalClient;
+    globalClient = new GraphqlSubscriptionSseClient({
+        closeWhenIdle: false,
+    });
+    return globalClient;
+}

package/esm/simulator-ui/src/hooks/useGambitTypedMutation.d.ts

@@ -0,0 +1,10 @@
+import { type ExtractParameters, type FetchOptions, type NetworkResponseObject } from "@isograph/react";
+import type { GambitMutationDefinition } from "./defineGambitMutation.js";
+export declare function useGambitTypedMutation<TReadFromStore extends {
+    data: object;
+    parameters: object;
+}, TResult, TRawResponseType extends NetworkResponseObject>(mutation: GambitMutationDefinition<TReadFromStore, TResult, TRawResponseType>): {
+    readonly commit: (variables: ExtractParameters<TReadFromStore>, fetchOptions?: FetchOptions<TResult, TRawResponseType>) => void;
+    readonly inFlight: boolean;
+};
+//# sourceMappingURL=useGambitTypedMutation.d.ts.map

package/esm/simulator-ui/src/hooks/useGambitTypedMutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGambitTypedMutation.d.ts","sourceRoot":"","sources":["../../../../src/simulator-ui/src/hooks/useGambitTypedMutation.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,qBAAqB,EAE3B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAE1E,wBAAgB,sBAAsB,CACpC,cAAc,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,EAC3D,OAAO,EACP,gBAAgB,SAAS,qBAAqB,EAE9C,QAAQ,EAAE,wBAAwB,CAAC,cAAc,EAAE,OAAO,EAAE,gBAAgB,CAAC;iCAShE,iBAAiB,CAAC,cAAc,CAAC,iBAC7B,YAAY,CAAC,OAAO,EAAE,gBAAgB,CAAC;;EAgDzD"}

package/esm/simulator-ui/src/hooks/useGambitTypedMutation.js

@@ -0,0 +1,50 @@
+import { useImperativeReference, } from "@isograph/react";
+import { useCallback, useRef, useState } from "react";
+export function useGambitTypedMutation(mutation) {
+    const { loadFragmentReference: commit } = useImperativeReference(mutation.entrypoint);
+    const [inFlight, setInFlight] = useState(false);
+    const inFlightRef = useRef(false);
+    const commitWithDefault = useCallback((variables, fetchOptions) => {
+        const isSingleFlight = mutation.flightPolicy === "single";
+        if (isSingleFlight && inFlightRef.current)
+            return;
+        if (isSingleFlight) {
+            inFlightRef.current = true;
+            setInFlight(true);
+        }
+        const clearInFlight = () => {
+            inFlightRef.current = false;
+            setInFlight(false);
+        };
+        const finalOptions = {
+            shouldFetch: fetchOptions?.shouldFetch ?? "Yes",
+            ...(fetchOptions ?? {}),
+        };
+        if (isSingleFlight) {
+            const originalOnComplete = finalOptions.onComplete;
+            const originalOnError = finalOptions.onError;
+            finalOptions.onComplete = (...args) => {
+                clearInFlight();
+                if (typeof originalOnComplete === "function") {
+                    originalOnComplete(...args);
+                }
+            };
+            finalOptions.onError = (...args) => {
+                clearInFlight();
+                if (typeof originalOnError === "function") {
+                    originalOnError(...args);
+                }
+            };
+        }
+        try {
+            commit(variables, finalOptions);
+        }
+        catch (error) {
+            if (isSingleFlight) {
+                clearInFlight();
+            }
+            throw error;
+        }
+    }, [commit, mutation.flightPolicy]);
+    return { commit: commitWithDefault, inFlight };
+}

package/esm/simulator-ui/src/hooks/useGambitTypedSubscription.d.ts

@@ -0,0 +1,11 @@
+import { type ExtractParameters, type NetworkResponseObject } from "@isograph/react";
+import type { GambitSubscriptionDefinition } from "./defineGambitSubscription.js";
+export declare function useGambitTypedSubscription<TReadFromStore extends {
+    data: object;
+    parameters: object;
+}, TResult, TRawResponseType extends NetworkResponseObject, TEnvelopePayload = TRawResponseType>(subscription: GambitSubscriptionDefinition<TReadFromStore, TResult, TRawResponseType, TEnvelopePayload>, variables: ExtractParameters<TReadFromStore> | null | undefined): {
+    readonly connected: boolean;
+    readonly inFlight: boolean;
+    readonly error: string | null;
+};
+//# sourceMappingURL=useGambitTypedSubscription.d.ts.map

package/esm/simulator-ui/src/hooks/useGambitTypedSubscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGambitTypedSubscription.d.ts","sourceRoot":"","sources":["../../../../src/simulator-ui/src/hooks/useGambitTypedSubscription.tsx"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAG3B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAgGlF,wBAAgB,0BAA0B,CACxC,cAAc,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,EAC3D,OAAO,EACP,gBAAgB,SAAS,qBAAqB,EAC9C,gBAAgB,GAAG,gBAAgB,EAEnC,YAAY,EAAE,4BAA4B,CACxC,cAAc,EACd,OAAO,EACP,gBAAgB,EAChB,gBAAgB,CACjB,EACD,SAAS,EAAE,iBAAiB,CAAC,cAAc,CAAC,GAAG,IAAI,GAAG,SAAS;;;;EAmNhE"}

package/esm/simulator-ui/src/hooks/useGambitTypedSubscription.js

@@ -0,0 +1,258 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { useIsographEnvironment, writeData, } from "@isograph/react";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { getGraphqlSubscriptionSseClient, } from "./graphqlSubscriptionSseClient.js";
+function isBuildStreamDebugEnabled() {
+    const globals = dntShim.dntGlobalThis;
+    return globals.__GAMBIT_BUILD_STREAM_DEBUG__ === true;
+}
+function logBuildStreamDebug(event, payload) {
+    if (!isBuildStreamDebugEnabled())
+        return;
+    // deno-lint-ignore no-console -- gated debug logs for live subscription tracing
+    console.info("[gambit-build-stream-debug]", event, payload);
+}
+function stableStringify(value) {
+    return JSON.stringify(value, (_key, next) => {
+        if (!next || typeof next !== "object" || Array.isArray(next)) {
+            return next;
+        }
+        const record = next;
+        const sorted = {};
+        for (const key of Object.keys(record).sort()) {
+            sorted[key] = record[key];
+        }
+        return sorted;
+    });
+}
+function fnv1a(input) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < input.length; i += 1) {
+        hash ^= input.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16);
+}
+function readOffset(storageKey) {
+    try {
+        const raw = globalThis.localStorage.getItem(storageKey);
+        if (!raw)
+            return null;
+        const parsed = Number(raw);
+        if (!Number.isFinite(parsed) || parsed < 0)
+            return null;
+        return Math.floor(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+function writeOffset(storageKey, nextOffset) {
+    try {
+        globalThis.localStorage.setItem(storageKey, String(nextOffset));
+    }
+    catch {
+        // Ignore storage write failures.
+    }
+}
+function extractOperationName(queryText) {
+    const match = queryText.match(/\bsubscription\s+([_A-Za-z][_0-9A-Za-z]*)\b/);
+    return match?.[1];
+}
+function toSubscriptionControlVariables(variables) {
+    if (!variables || typeof variables !== "object" || Array.isArray(variables)) {
+        return {};
+    }
+    return variables;
+}
+function toErrorMessage(envelope) {
+    if (Array.isArray(envelope.errors) && envelope.errors.length > 0) {
+        const first = envelope.errors[0];
+        if (first && typeof first.message === "string" && first.message.length > 0) {
+            return first.message;
+        }
+    }
+    if (typeof envelope.reason === "string" && envelope.reason.length > 0) {
+        return envelope.reason;
+    }
+    return "GraphQL subscription failed";
+}
+export function useGambitTypedSubscription(subscription, variables) {
+    const environment = useIsographEnvironment();
+    const client = useMemo(() => getGraphqlSubscriptionSseClient(), []);
+    const [connected, setConnected] = useState(false);
+    const [inFlight, setInFlight] = useState(false);
+    const [error, setError] = useState(null);
+    const inFlightRef = useRef(false);
+    const hookIdRef = useRef(`gambit-sub-${crypto.randomUUID()}`);
+    const stableVariablesKey = useMemo(() => stableStringify(variables ?? null), [
+        variables,
+    ]);
+    const stableVariables = useMemo(() => variables ?? null, [
+        stableVariablesKey,
+    ]);
+    const generationRef = useRef(0);
+    // deno-lint-ignore gambit/no-useeffect-setstate gambit/no-useeffect-setstate -- this hook models connection lifecycle and must update status state from effect events
+    useEffect(() => {
+        generationRef.current += 1;
+        const generation = generationRef.current;
+        let closed = false;
+        let unsubscribe = null;
+        const cleanup = async (notifyServer) => {
+            setConnected(false);
+            if (!unsubscribe)
+                return;
+            const dispose = unsubscribe;
+            unsubscribe = null;
+            await dispose({ notifyServer });
+        };
+        if (stableVariables === null) {
+            setError(null);
+            void cleanup(true);
+            return () => {
+                void cleanup(false);
+            };
+        }
+        if (subscription.isEnabled && !subscription.isEnabled(stableVariables)) {
+            setError(null);
+            void cleanup(true);
+            return () => {
+                void cleanup(false);
+            };
+        }
+        const queryText = subscription.query.trim();
+        if (!queryText) {
+            setError("Subscription query text is missing.");
+            return () => { };
+        }
+        const operationName = subscription.operationName ??
+            extractOperationName(queryText);
+        const isSingleFlight = subscription.flightPolicy === "single";
+        const writeVariables = stableVariables;
+        const subscriptionVariablesBase = subscription.toSubscriptionVariables?.(writeVariables) ??
+            toSubscriptionControlVariables(writeVariables);
+        const defaultOffsetStorageKey = subscription.offset
+            ? `gambit.graphql.subscription.offset:${fnv1a(`${queryText}:${stableStringify(subscriptionVariablesBase)}:${subscription.offset.variableName}`)}`
+            : null;
+        const offsetStorageKey = subscription.offset
+            ? (subscription.offset.storageKey?.(writeVariables) ??
+                defaultOffsetStorageKey)
+            : null;
+        const resumeOffset = offsetStorageKey ? readOffset(offsetStorageKey) : null;
+        const subscriptionVariables = (() => {
+            if (!subscription.offset || resumeOffset === null) {
+                return subscriptionVariablesBase;
+            }
+            const withOffset = {
+                ...subscriptionVariablesBase,
+            };
+            withOffset[subscription.offset.variableName] = resumeOffset;
+            return withOffset;
+        })();
+        const start = async () => {
+            if (isSingleFlight && inFlightRef.current)
+                return;
+            if (isSingleFlight) {
+                inFlightRef.current = true;
+                setInFlight(true);
+            }
+            try {
+                logBuildStreamDebug("subscribe.start", {
+                    operationName: operationName ?? null,
+                    subscriptionId: hookIdRef.current,
+                    variables: subscriptionVariables,
+                });
+                const dispose = await client.subscribe({
+                    subscriptionId: hookIdRef.current,
+                    query: queryText,
+                    variables: subscriptionVariables,
+                    operationName,
+                    onEnvelope: (envelope) => {
+                        if (generationRef.current !== generation)
+                            return;
+                        logBuildStreamDebug("subscribe.envelope", {
+                            operationName: operationName ?? null,
+                            type: envelope.type,
+                            hasPayload: Boolean(envelope.payload),
+                        });
+                        if (envelope.type === "next") {
+                            if (!envelope.payload || typeof envelope.payload !== "object") {
+                                return;
+                            }
+                            const envelopePayload = envelope.payload;
+                            const writePayload = subscription.mapPayload
+                                ? subscription.mapPayload(envelopePayload, writeVariables)
+                                // mapPayload is optional; when omitted, envelope payload is the write payload.
+                                : envelopePayload;
+                            if (!writePayload)
+                                return;
+                            writeData(environment, subscription.entrypoint, writePayload, writeVariables);
+                            logBuildStreamDebug("subscribe.write", {
+                                operationName: operationName ?? null,
+                                hasOffset: Boolean(subscription.offset),
+                                variableWorkspaceId: writeVariables?.workspaceId ??
+                                    null,
+                            });
+                            if (subscription.offset && offsetStorageKey) {
+                                const offset = subscription.offset.getOffset(envelopePayload, writeVariables);
+                                if (typeof offset === "number" && Number.isFinite(offset)) {
+                                    writeOffset(offsetStorageKey, Math.max(0, Math.floor(offset) + 1));
+                                }
+                            }
+                            setError(null);
+                            return;
+                        }
+                        if (envelope.type === "error") {
+                            setError(toErrorMessage(envelope));
+                            logBuildStreamDebug("subscribe.error", {
+                                operationName: operationName ?? null,
+                                reason: toErrorMessage(envelope),
+                            });
+                            return;
+                        }
+                        if (envelope.type === "complete" ||
+                            envelope.type === "unsubscribed") {
+                            setConnected(false);
+                        }
+                    },
+                });
+                if (closed || generationRef.current !== generation) {
+                    await dispose({ notifyServer: false });
+                    return;
+                }
+                unsubscribe = dispose;
+                setConnected(true);
+                setError(null);
+            }
+            catch (cause) {
+                if (closed || generationRef.current !== generation)
+                    return;
+                const message = cause instanceof Error ? cause.message : String(cause);
+                setError(message || "GraphQL subscription failed");
+                logBuildStreamDebug("subscribe.exception", {
+                    operationName: operationName ?? null,
+                    message: message || "GraphQL subscription failed",
+                });
+                setConnected(false);
+            }
+            finally {
+                if (isSingleFlight) {
+                    inFlightRef.current = false;
+                    setInFlight(false);
+                }
+            }
+        };
+        void start();
+        return () => {
+            closed = true;
+            void cleanup(true);
+        };
+    }, [
+        client,
+        environment,
+        stableVariables,
+        subscription,
+        stableVariablesKey,
+    ]);
+    return { connected, inFlight, error };
+}

package/esm/simulator-ui/src/isographEnvironment.d.ts

@@ -0,0 +1,3 @@
+export declare function createFreshIsographEnvironment(): import("@isograph/react").IsographEnvironment;
+export declare function getEnvironment(): import("@isograph/react").IsographEnvironment;
+//# sourceMappingURL=isographEnvironment.d.ts.map

package/esm/simulator-ui/src/isographEnvironment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isographEnvironment.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/src/isographEnvironment.ts"],"names":[],"mappings":"AAmHA,wBAAgB,8BAA8B,kDAM7C;AAED,wBAAgB,cAAc,kDAW7B"}

package/esm/simulator-ui/src/isographEnvironment.js

@@ -0,0 +1,88 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { createIsographEnvironment, createIsographStore, } from "@isograph/react";
+function makePreloadKey(queryText, variables) {
+    return `${queryText}::${JSON.stringify(variables ?? null)}`;
+}
+function extractOperation(opOrText) {
+    if (typeof opOrText === "string")
+        return { queryText: opOrText };
+    if (opOrText && typeof opOrText === "object") {
+        const maybeWrapper = opOrText;
+        if (maybeWrapper.text || maybeWrapper.operationId) {
+            return {
+                queryText: maybeWrapper.text,
+                operationId: maybeWrapper.operationId,
+            };
+        }
+        if (maybeWrapper.operation) {
+            return {
+                queryText: maybeWrapper.operation.text,
+                operationId: maybeWrapper.operation.operationId,
+            };
+        }
+        if (maybeWrapper.networkRequestInfo?.operation) {
+            return {
+                queryText: maybeWrapper.networkRequestInfo.operation.text,
+                operationId: maybeWrapper.networkRequestInfo.operation.operationId,
+            };
+        }
+    }
+    return {};
+}
+function makeNetworkRequest(opOrText, variables, maybeInfo) {
+    const primary = extractOperation(opOrText);
+    const fallback = extractOperation(maybeInfo);
+    const query = primary.queryText ?? fallback.queryText ??
+        (typeof opOrText === "string" ? opOrText : "");
+    const operationId = primary.operationId ?? fallback.operationId;
+    try {
+        const globalWithIso = dntShim.dntGlobalThis;
+        if (query && globalWithIso.__ISO_PRELOADED__) {
+            const preloadKey = makePreloadKey(query, variables);
+            if (Object.prototype.hasOwnProperty.call(globalWithIso.__ISO_PRELOADED__, preloadKey)) {
+                const payload = globalWithIso.__ISO_PRELOADED__[preloadKey];
+                delete globalWithIso.__ISO_PRELOADED__[preloadKey];
+                return Promise.resolve(payload);
+            }
+        }
+    }
+    catch {
+        // Best effort preload read; fall through to network fetch.
+    }
+    if (!query && operationId) {
+        return Promise.reject(new Error("Persisted operations are not supported by the current /graphql endpoint."));
+    }
+    return fetch("/graphql", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ query, variables }),
+    }).then(async (response) => {
+        const json = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            throw new Error("NetworkError", { cause: json });
+        }
+        if (Array.isArray(json.errors) && json.errors.length > 0) {
+            const firstMessage = json.errors[0]?.message ??
+                "GraphQL operation failed";
+            throw new Error(firstMessage, {
+                cause: {
+                    query,
+                    variables,
+                    errors: json.errors,
+                },
+            });
+        }
+        return json;
+    });
+}
+export function createFreshIsographEnvironment() {
+    return createIsographEnvironment(createIsographStore(), makeNetworkRequest, undefined);
+}
+export function getEnvironment() {
+    const globalWithIso = dntShim.dntGlobalThis;
+    if (!globalWithIso.__SIMULATOR_ISOGRAPH_ENVIRONMENT__) {
+        globalWithIso.__SIMULATOR_ISOGRAPH_ENVIRONMENT__ =
+            createFreshIsographEnvironment();
+    }
+    return globalWithIso.__SIMULATOR_ISOGRAPH_ENVIRONMENT__;
+}

package/esm/simulator-ui/src/routing.d.ts

@@ -0,0 +1,11 @@
+type MatchedRoute = {
+    match: boolean;
+    params: Record<string, string>;
+    queryParams: Record<string, string>;
+};
+export declare function stripQueryFromPath(path: string): string;
+export declare function normalizePathname(pathname: string): string;
+export declare function matchRouteWithParams(pathRaw?: string, pathTemplate?: string): MatchedRoute;
+export declare const isographAppRoutes: Map<string, unknown>;
+export {};
+//# sourceMappingURL=routing.d.ts.map

package/esm/simulator-ui/src/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/src/routing.ts"],"names":[],"mappings":"AAMA,KAAK,YAAY,GAAG;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC,CAAC;AAIF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKvD;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAG1D;AAED,wBAAgB,oBAAoB,CAClC,OAAO,SAAK,EACZ,YAAY,CAAC,EAAE,MAAM,GACpB,YAAY,CAwCd;AAED,eAAO,MAAM,iBAAiB,sBAiD5B,CAAC"}