stitchkit 0.93.0 → 0.94.1

package/dist/entrypoints/react.d.ts

@@ -0,0 +1,5 @@
+export { type CacheBridge, type CacheBridgeConfig, type CacheBridgeContext, type CacheBridgeHandler, type CacheBridgeHandlers, type CacheBridgeSocket, createCacheBridge, createRealtimeCacheBridge, type RealtimeCacheBridgeConfig, } from '../react/cache-bridge.js';
+export { type CursorQueryConfig, createCursorQuery } from '../react/cursor-query.js';
+export { createEntityCacheHandlers, type DeletedPayload, type EntityCacheConfig, type EntityCacheEvent, type EntityCacheHandlers, type EntityCacheKey, type EntityCacheListConfig, type EntityCacheListShape, type EntityCacheMembership, type EntityCacheMembershipPolicy, type EntityCacheTotalDeltaInput, type EntityCacheTotalPolicy, } from '../react/entity-cache.js';
+export { type ApiErrorRetryConfig, apiErrorRetry, createQueryClientFactory, type QueryClientFactoryConfig, type QueryClientServerCache, type QueryRetryValue, } from '../react/query-client.js';
+//# sourceMappingURL=react.d.ts.map

package/dist/entrypoints/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/entrypoints/react.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,iBAAiB,EACjB,yBAAyB,EACzB,KAAK,yBAAyB,GAC/B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,KAAK,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,EACL,yBAAyB,EACzB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,GAC5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,mBAAmB,EACxB,aAAa,EACb,wBAAwB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,eAAe,GACrB,MAAM,uBAAuB,CAAC"}

package/dist/entrypoints/react.js

@@ -0,0 +1,403 @@
+import {
+  ApiError,
+  isAbortLikeError
+} from "../index-v260df89.js";
+import"../index-zcgf3gqf.js";
+import {
+  isRecord
+} from "../index-hffjpmq9.js";
+
+// src/react/cache-bridge.ts
+function createCacheBridge(config) {
+  const freshWindow = config.freshWindow ?? 500;
+  const maxFreshKeys = config.maxFreshKeys ?? 1000;
+  if (!Number.isFinite(freshWindow) || freshWindow < 0) {
+    throw new Error("cacheBridge.freshWindow must be a non-negative finite number");
+  }
+  if (!Number.isInteger(maxFreshKeys) || maxFreshKeys < 1) {
+    throw new Error("cacheBridge.maxFreshKeys must be a positive integer");
+  }
+  const freshAt = new Map;
+  const expiryTimers = new Map;
+  let unsubscribers = [];
+  const isFresh = (key) => {
+    const serialised = JSON.stringify(key);
+    const ts = freshAt.get(serialised);
+    if (ts === undefined)
+      return false;
+    if (Date.now() - ts < freshWindow)
+      return true;
+    freshAt.delete(serialised);
+    return false;
+  };
+  const clearFresh = () => {
+    for (const timer of expiryTimers.values())
+      clearTimeout(timer);
+    expiryTimers.clear();
+    freshAt.clear();
+  };
+  return {
+    connect() {
+      if (unsubscribers.length > 0)
+        return;
+      const queryClient = typeof config.queryClient === "function" ? config.queryClient() : config.queryClient;
+      const ctx = { queryClient, isFresh };
+      const handlers = config.handlers;
+      const socket = config.socket;
+      for (const event of Object.keys(handlers)) {
+        const handler = handlers[event];
+        if (!handler)
+          continue;
+        const off = socket.on(event, (data) => handler(data, ctx));
+        unsubscribers.push(off);
+      }
+    },
+    disconnect() {
+      for (const off of unsubscribers)
+        off();
+      unsubscribers = [];
+      clearFresh();
+    },
+    markFresh(key) {
+      const serialised = JSON.stringify(key);
+      const existingTimer = expiryTimers.get(serialised);
+      if (existingTimer)
+        clearTimeout(existingTimer);
+      freshAt.delete(serialised);
+      freshAt.set(serialised, Date.now());
+      expiryTimers.set(serialised, setTimeout(() => {
+        freshAt.delete(serialised);
+        expiryTimers.delete(serialised);
+      }, freshWindow));
+      while (freshAt.size > maxFreshKeys) {
+        const oldest = freshAt.keys().next().value;
+        if (oldest === undefined)
+          break;
+        freshAt.delete(oldest);
+        const timer = expiryTimers.get(oldest);
+        if (timer)
+          clearTimeout(timer);
+        expiryTimers.delete(oldest);
+      }
+    },
+    clearFresh
+  };
+}
+function createRealtimeCacheBridge(config) {
+  return createCacheBridge(config);
+}
+// src/react/cursor-query.ts
+import {
+  createInfiniteQuery
+} from "react-query-kit";
+function createCursorQuery(config) {
+  const { endpoint, ...rest } = config;
+  return createInfiniteQuery({
+    ...rest,
+    fetcher: (variables, { pageParam }) => endpoint({ ...variables, cursor: pageParam ?? undefined }),
+    initialPageParam: null,
+    getNextPageParam: (lastPage) => lastPage.nextCursor
+  });
+}
+// src/react/entity-cache.ts
+function resolveKey(key, event) {
+  return typeof key === "function" ? key(event) : key;
+}
+function ordered(items, compare) {
+  return compare ? [...items].sort(compare) : items;
+}
+function insertAt(items, item, at, compare) {
+  return ordered(at === "start" ? [item, ...items] : [...items, item], compare);
+}
+function mutateItemArrays(arrays, mutation, config, getId) {
+  const present = arrays.some((items) => items.some((item) => getId(item) === mutation.id));
+  if (mutation.type === "created" && present)
+    return { arrays, present };
+  if (mutation.type === "updated" && !present && config.updateMissing === "skip") {
+    return { arrays, present };
+  }
+  if (mutation.type !== "deleted" && (!present || mutation.type === "created")) {
+    if (arrays.length === 0)
+      return { arrays, present };
+    const target = config.createAt === "start" ? 0 : arrays.length - 1;
+    return {
+      arrays: arrays.map((items, index) => index === target ? insertAt(items, mutation.item, config.createAt, config.compare) : items),
+      present
+    };
+  }
+  if (mutation.type === "deleted") {
+    return {
+      arrays: arrays.map((items) => items.filter((item) => getId(item) !== mutation.id)),
+      present
+    };
+  }
+  return {
+    arrays: arrays.map((items) => ordered(items.map((item) => getId(item) === mutation.id ? mutation.item : item), config.compare)),
+    present
+  };
+}
+function firstArray(arrays) {
+  const first = arrays[0];
+  if (!first)
+    throw new Error("Entity cache list adapter lost its only item array");
+  return first;
+}
+function totalDelta(mutation, present, membership) {
+  if (mutation.type === "deleted") {
+    if (present)
+      return -1;
+    return "unknown";
+  }
+  if (membership === "unknown")
+    return "unknown";
+  if (mutation.type === "created") {
+    if (present)
+      return 0;
+    return membership === "include" ? 1 : 0;
+  }
+  if (present)
+    return membership === "exclude" ? -1 : 0;
+  return "unknown";
+}
+function reconcileTotal(value, delta) {
+  if (delta === "unknown")
+    return value;
+  if (!Number.isSafeInteger(delta)) {
+    throw new Error('Entity cache total delta must be a safe integer or "unknown"');
+  }
+  const current = Reflect.get(value, "total");
+  if (typeof current !== "number" || !Number.isSafeInteger(current) || current < 0) {
+    return value;
+  }
+  return { ...value, total: Math.max(0, current + delta) };
+}
+function unsupportedListShape(shape) {
+  throw new Error(`Unsupported entity cache list shape: ${String(shape)}`);
+}
+function patchList(context, key, config, event, mutation, getId) {
+  const queries = context.queryClient.getQueryCache().findAll({ queryKey: key });
+  const patchExact = (exactKey, membership) => {
+    const effectiveMutation = membership === "exclude" && mutation.type !== "deleted" ? { type: "deleted", id: mutation.id } : mutation;
+    const unknown = membership === "unknown";
+    if (unknown && mutation.type !== "deleted") {
+      if (config.membership?.unknown === "invalidate" || config.total?.unknown === "invalidate") {
+        context.queryClient.invalidateQueries({ queryKey: exactKey, exact: true });
+      }
+      return;
+    }
+    let invalidateMembership = false;
+    const mutate = (arrays) => {
+      const result = mutateItemArrays(arrays, effectiveMutation, config, getId);
+      if (membership === "unknown" && mutation.type === "deleted" && !result.present && config.membership?.unknown === "invalidate") {
+        invalidateMembership = true;
+      }
+      return result;
+    };
+    let invalidateTotal = false;
+    const reconcile = (value, delta) => {
+      if (delta === "unknown" && config.total?.unknown === "invalidate") {
+        invalidateTotal = true;
+      }
+      return reconcileTotal(value, delta);
+    };
+    const invalidateIfNeeded = () => {
+      if (invalidateMembership || invalidateTotal) {
+        context.queryClient.invalidateQueries({ queryKey: exactKey, exact: true });
+      }
+    };
+    switch (config.shape) {
+      case "array":
+        context.queryClient.setQueryData(exactKey, (old) => Array.isArray(old) ? firstArray(mutate([old]).arrays) : old);
+        invalidateIfNeeded();
+        return;
+      case "paginated":
+        context.queryClient.setQueryData(exactKey, (old) => {
+          if (!isRecord(old) || !Array.isArray(old.items))
+            return old;
+          const result = mutate([old.items]);
+          const patched = { ...old, items: firstArray(result.arrays) };
+          const delta = config.total?.delta?.({
+            event,
+            queryKey: exactKey,
+            present: result.present,
+            membership
+          }) ?? totalDelta(mutation, result.present, membership);
+          return config.total ? reconcile(patched, delta) : patched;
+        });
+        invalidateIfNeeded();
+        return;
+      case "infinite-array":
+        context.queryClient.setQueryData(exactKey, (old) => isRecord(old) && Array.isArray(old.pages) && old.pages.every((page) => Array.isArray(page)) ? { ...old, pages: mutate(old.pages).arrays } : old);
+        invalidateIfNeeded();
+        return;
+      case "infinite-paginated":
+        context.queryClient.setQueryData(exactKey, (old) => {
+          if (!isRecord(old) || !Array.isArray(old.pages) || !old.pages.every((page) => isRecord(page) && Array.isArray(page.items))) {
+            return old;
+          }
+          const result = mutate(old.pages.map((page) => page.items));
+          const delta = config.total?.delta?.({
+            event,
+            queryKey: exactKey,
+            present: result.present,
+            membership
+          }) ?? totalDelta(mutation, result.present, membership);
+          return {
+            ...old,
+            pages: old.pages.map((page, index) => {
+              const pageItems = result.arrays[index];
+              if (!pageItems) {
+                throw new Error("Entity cache list adapter changed the page count");
+              }
+              const patched = { ...page, items: pageItems };
+              return config.total ? reconcile(patched, delta) : patched;
+            })
+          };
+        });
+        invalidateIfNeeded();
+        return;
+      default:
+        unsupportedListShape(config.shape);
+    }
+  };
+  for (const query of queries) {
+    const exactKey = query.queryKey;
+    patchExact(exactKey, config.membership?.evaluate(event, exactKey) ?? "include");
+  }
+}
+function createEntityCacheHandlers(config) {
+  if (config.list.total && config.list.shape !== "paginated" && config.list.shape !== "infinite-paginated") {
+    throw new Error("Entity cache total policy requires a paginated list shape");
+  }
+  const deletedId = config.getDeletedId ?? ((payload) => idOf(payload, config.getId));
+  const apply = (event, mutation, context) => {
+    const listKey = resolveKey(config.list.key, event);
+    const detailKey = config.detailKey ? resolveKey(config.detailKey, event) : undefined;
+    if (context.isFresh(detailKey ?? listKey))
+      return false;
+    patchList(context, listKey, config.list, event, mutation, config.getListItemId);
+    return true;
+  };
+  return {
+    created(entity, context) {
+      const id = config.getId(entity);
+      const event = { type: "created", entity, id };
+      if (!apply(event, { type: "created", id, item: config.toListItem(entity) }, context)) {
+        return;
+      }
+      if (config.detailKey) {
+        context.queryClient.setQueryData(resolveKey(config.detailKey, event), entity);
+      }
+    },
+    updated(entity, context) {
+      const id = config.getId(entity);
+      const event = { type: "updated", entity, id };
+      if (!apply(event, { type: "updated", id, item: config.toListItem(entity) }, context)) {
+        return;
+      }
+      if (config.detailKey) {
+        context.queryClient.setQueryData(resolveKey(config.detailKey, event), entity);
+      }
+    },
+    deleted(payload, context) {
+      const id = deletedId(payload);
+      const event = { type: "deleted", payload, id };
+      if (!apply(event, { type: "deleted", id }, context))
+        return;
+      if (config.detailKey) {
+        context.queryClient.removeQueries({
+          queryKey: resolveKey(config.detailKey, event)
+        });
+      }
+    }
+  };
+}
+function hasStringId(value) {
+  return isRecord(value) && typeof value.id === "string";
+}
+function idOf(payload, getId) {
+  return hasStringId(payload) ? payload.id : getId(payload);
+}
+// src/react/query-client.ts
+import {
+  defaultShouldDehydrateQuery,
+  environmentManager,
+  MutationCache,
+  QueryClient
+} from "@tanstack/react-query";
+var DEFAULT_NEVER_RETRY = [
+  "UNAUTHORIZED",
+  "FORBIDDEN",
+  "VALIDATION_ERROR",
+  "REQUEST_ABORTED"
+];
+function apiErrorRetry(config = {}) {
+  const attempts = config.attempts ?? 1;
+  if (!Number.isSafeInteger(attempts) || attempts < 0) {
+    throw new Error(`apiErrorRetry attempts must be a non-negative safe integer, received ${attempts}`);
+  }
+  const never = new Set(config.never ?? DEFAULT_NEVER_RETRY);
+  const statusRanges = config.statusRanges ?? [[500, 599]];
+  for (const [from, to] of statusRanges) {
+    if (!Number.isSafeInteger(from) || !Number.isSafeInteger(to) || from < 100 || to > 599 || from > to) {
+      throw new Error(`apiErrorRetry status range must be an inclusive HTTP range, received ${from}..${to}`);
+    }
+  }
+  return (failureCount, error) => {
+    if (failureCount >= attempts)
+      return false;
+    if (isAbortLikeError(error))
+      return false;
+    if (!ApiError.is(error))
+      return config.network ?? true;
+    if (never.has(error.code))
+      return false;
+    if (error.status === 0)
+      return config.network ?? true;
+    return statusRanges.some(([from, to]) => error.status >= from && error.status <= to);
+  };
+}
+function createQueryClientFactory(config = {}) {
+  const supplied = config.queryClient ?? {};
+  if (config.onMutationError && supplied.mutationCache) {
+    throw new Error("createQueryClientFactory cannot combine onMutationError with queryClient.mutationCache");
+  }
+  const suppliedDefaults = supplied.defaultOptions ?? {};
+  const queryRetry = typeof config.retry === "object" || config.retry === undefined ? apiErrorRetry(config.retry) : config.retry;
+  const create = () => new QueryClient({
+    ...supplied,
+    ...config.onMutationError ? { mutationCache: new MutationCache({ onError: config.onMutationError }) } : {},
+    defaultOptions: {
+      ...suppliedDefaults,
+      queries: {
+        ...suppliedDefaults.queries,
+        retry: suppliedDefaults.queries?.retry ?? queryRetry
+      },
+      mutations: {
+        ...suppliedDefaults.mutations,
+        retry: suppliedDefaults.mutations?.retry ?? false
+      },
+      dehydrate: {
+        ...suppliedDefaults.dehydrate,
+        shouldDehydrateQuery: suppliedDefaults.dehydrate?.shouldDehydrateQuery ?? ((query) => defaultShouldDehydrateQuery(query) || query.state.status === "pending")
+      }
+    }
+  });
+  const getServer = config.serverCache ? config.serverCache(create) : create;
+  const isServer = config.server ?? (() => environmentManager.isServer());
+  let browserClient;
+  return () => {
+    if (isServer())
+      return getServer();
+    browserClient ??= create();
+    return browserClient;
+  };
+}
+export {
+  createRealtimeCacheBridge,
+  createQueryClientFactory,
+  createEntityCacheHandlers,
+  createCursorQuery,
+  createCacheBridge,
+  apiErrorRetry
+};

package/dist/entrypoints/release.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `stitchkit/release` — a page follows the release it was built for.
+ *
+ * The server keeps a marker of the current frontend build and names it on
+ * every HTTP response and every socket connection; the browser compares that
+ * to its own build id and reloads under a declared policy. Reading the build
+ * id, sending the deploy signal and the moment to reload are the
+ * application's; the comparison, the channels and the policy are here, once.
+ * → ADR 0167.
+ */
+export { RELEASE_HEADER } from '../release/header.js';
+export { createReleaseMarker, type ReleaseMarker, type ReleaseMarkerConfig, type ReleaseRefresh, } from '../release/marker.js';
+export { bindReleaseToSocketServer, observeReleaseFromSocket, type ReleaseSocketEmitter, type ReleaseSocketListener, type ReleaseSocketOptions, type ReleaseSocketServer, } from '../release/socket.js';
+export { browserReleaseHost, createReleaseWatcher, type ReleaseReloadPolicy, type ReleaseWatcher, type ReleaseWatcherConfig, type ReleaseWatcherHost, } from '../release/watcher.js';
+//# sourceMappingURL=release.d.ts.map

package/dist/entrypoints/release.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release.d.ts","sourceRoot":"","sources":["../../src/entrypoints/release.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EACL,mBAAmB,EACnB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,cAAc,GACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACxB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAC"}

package/dist/entrypoints/release.js

@@ -0,0 +1,196 @@
+import {
+  RELEASE_HEADER
+} from "../index-y91ry9h2.js";
+// src/release/marker.ts
+var BUILD_ID = /^[!-~]{1,200}$/;
+function createReleaseMarker(config) {
+  const listeners = new Set;
+  const report = (error) => {
+    try {
+      config.onError?.(error);
+    } catch {}
+  };
+  const read = () => {
+    let value;
+    try {
+      value = config.read();
+    } catch (error) {
+      report(error);
+      return null;
+    }
+    if (value === null || value === undefined)
+      return null;
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    if (trimmed === "")
+      return null;
+    if (!BUILD_ID.test(trimmed)) {
+      report(new Error(`release marker: not a build id: ${JSON.stringify(value).slice(0, 80)}`));
+      return null;
+    }
+    return trimmed;
+  };
+  let current = read();
+  return {
+    current: () => current,
+    refresh() {
+      const next = read();
+      if (next === null)
+        return { changed: false, buildId: current };
+      if (next === current)
+        return { changed: false, buildId: current };
+      current = next;
+      for (const listener of listeners) {
+        try {
+          listener(next);
+        } catch (error) {
+          report(error);
+        }
+      }
+      return { changed: true, buildId: next };
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    }
+  };
+}
+// src/release/socket.ts
+function bindReleaseToSocketServer(io, marker, options = {}) {
+  const event = options.event ?? "release";
+  const refreshOnConnection = options.refreshOnConnection ?? true;
+  const unsubscribe = marker.subscribe((buildId) => {
+    io.emit(event, { buildId });
+  });
+  io.on("connection", (socket) => {
+    if (refreshOnConnection)
+      marker.refresh();
+    const buildId = marker.current();
+    if (buildId !== null)
+      socket.emit(event, { buildId });
+  });
+  return unsubscribe;
+}
+function observeReleaseFromSocket(socket, watcher, options = {}) {
+  const event = options.event ?? "release";
+  const handler = (payload) => watcher.observe(payload.buildId);
+  const returned = socket.on(event, handler);
+  return () => {
+    if (typeof returned === "function")
+      returned();
+    else
+      socket.off?.(event, handler);
+  };
+}
+// src/release/watcher.ts
+var REMEMBER_KEY = "stitchkit.release.reloaded-for";
+function browserReleaseHost() {
+  const doc = typeof document === "undefined" ? null : document;
+  const win = typeof window === "undefined" ? null : window;
+  return {
+    hidden: () => doc?.visibilityState === "hidden",
+    onVisibilityChange(handler) {
+      if (!doc)
+        return () => {
+          return;
+        };
+      doc.addEventListener("visibilitychange", handler);
+      return () => doc.removeEventListener("visibilitychange", handler);
+    },
+    setTimeout(handler, ms) {
+      const id = globalThis.setTimeout(handler, ms);
+      return () => globalThis.clearTimeout(id);
+    },
+    reload: () => win?.location.reload(),
+    remember(buildId) {
+      try {
+        win?.sessionStorage.setItem(REMEMBER_KEY, buildId);
+      } catch {}
+    },
+    recall() {
+      try {
+        return win?.sessionStorage.getItem(REMEMBER_KEY) ?? null;
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+function createReleaseWatcher(config) {
+  const policy = config.policy ?? "when-hidden";
+  const maxDeferMs = config.maxDeferMs ?? 15 * 60 * 1000;
+  const ignore = new Set(config.ignore ?? ["dev"]);
+  const host = config.host ?? browserReleaseHost();
+  let stale = false;
+  let done = false;
+  let target = null;
+  const cleanups = [];
+  const reload = () => {
+    if (done)
+      return;
+    done = true;
+    for (const off of cleanups.splice(0))
+      off();
+    if (target !== null)
+      host.remember(target);
+    host.reload();
+  };
+  const notify = (buildId) => {
+    try {
+      config.onStale?.(buildId);
+    } catch {}
+  };
+  return {
+    observe(buildId) {
+      if (stale || done)
+        return;
+      if (buildId === null || buildId === undefined || buildId === "")
+        return;
+      if (!config.own || ignore.has(config.own))
+        return;
+      if (buildId === config.own)
+        return;
+      stale = true;
+      target = buildId;
+      if (host.recall() === buildId) {
+        notify(buildId);
+        return;
+      }
+      if (policy === "immediate") {
+        reload();
+        notify(buildId);
+        return;
+      }
+      if (policy === "when-hidden") {
+        if (host.hidden()) {
+          reload();
+          notify(buildId);
+          return;
+        }
+        cleanups.push(host.onVisibilityChange(() => {
+          if (host.hidden())
+            reload();
+        }));
+      }
+      cleanups.push(host.setTimeout(reload, maxDeferMs));
+      notify(buildId);
+    },
+    navigated() {
+      if (stale && policy === "on-navigation")
+        reload();
+    },
+    stale: () => stale,
+    dispose() {
+      done = true;
+      for (const off of cleanups.splice(0))
+        off();
+    }
+  };
+}
+export {
+  observeReleaseFromSocket,
+  createReleaseWatcher,
+  createReleaseMarker,
+  browserReleaseHost,
+  bindReleaseToSocketServer,
+  RELEASE_HEADER
+};

package/dist/entrypoints/remote.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `stitchkit/remote` — peer-free remote service implementation.
+ *
+ * `implementRemote` needs only the contract and HTTP client. Keeping it in its
+ * own entrypoint lets CLI and other thin processes proxy a deployed API without
+ * importing the MCP SDK or the AI SDK through the broad tools barrel.
+ */
+export { type ImplementRemoteOptions, implementRemote } from '../tools/remote.js';
+//# sourceMappingURL=remote.d.ts.map

package/dist/entrypoints/remote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../../src/entrypoints/remote.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,KAAK,sBAAsB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC"}