apps 0.0.1-beta.0

package/js/client.js

@@ -0,0 +1,1023 @@
+import {
+  AppUiApi,
+  HttpApiClient_exports,
+  UiContext,
+  UiDeploymentChanged,
+  UiFailed
+} from "./chunk-3ANFZFCV.js";
+import {
+  AsyncResult_exports,
+  AtomRegistry_exports,
+  Atom_exports,
+  queryResult
+} from "./chunk-YDR4CPJA.js";
+import "./chunk-D6BKYP2L.js";
+import {
+  OtlpExporter_exports,
+  TraceContext,
+  externalTrace,
+  pendingSpan,
+  telemetryLayer,
+  traceLinks
+} from "./chunk-OWD2YICM.js";
+import {
+  FetchHttpClient_exports
+} from "./chunk-VFUZI3NY.js";
+import {
+  HttpClientError_exports
+} from "./chunk-W7Q5EOTS.js";
+import {
+  decoderOf
+} from "./chunk-BPEFS4YF.js";
+import {
+  StorageName
+} from "./chunk-EP6AEUZO.js";
+import {
+  JsonValue
+} from "./chunk-36DNRFZQ.js";
+import {
+  Cause_exports,
+  Clock_exports,
+  Context_exports,
+  Deferred_exports,
+  Effect_exports,
+  Exit_exports,
+  FiberSet_exports,
+  Layer_exports,
+  Logger_exports,
+  ManagedRuntime_exports,
+  Option_exports,
+  Schedule_exports,
+  Schema_exports,
+  Semaphore_exports,
+  Stream_exports,
+  Tracer_exports
+} from "./chunk-2OTCEKL2.js";
+import "./chunk-MLKGABMK.js";
+
+// src/contracts/live.ts
+var AppQueryFailed = class extends Schema_exports.TaggedError()("AppQueryFailed", {}) {
+};
+
+// src/implementation/live.ts
+var queryReference = (name) => ({
+  name: Schema_exports.decodeUnknownSync(StorageName)(name),
+  kind: "query"
+});
+var mutationReference = (name) => ({
+  name: Schema_exports.decodeUnknownSync(StorageName)(name),
+  kind: "mutation"
+});
+var liveQueryAtom = (reference, input, options) => Atom_exports.make(
+  Stream_exports.unwrap(
+    Effect_exports.gen(function* () {
+      const parsed = yield* Schema_exports.decodeUnknownEffect(JsonValue)(input).pipe(
+        Effect_exports.mapError(() => new AppQueryFailed())
+      );
+      const iterable = yield* Effect_exports.tryPromise({
+        try: () => options.transport.subscribe({ name: reference.name, input: parsed }),
+        catch: () => new AppQueryFailed()
+      });
+      return Stream_exports.fromAsyncIterable(iterable, () => new AppQueryFailed()).pipe(
+        Stream_exports.mapEffect(
+          (value) => Schema_exports.decodeUnknownEffect(decoderOf(options.output))(value).pipe(
+            Effect_exports.mapError(() => new AppQueryFailed())
+          )
+        )
+      );
+    })
+  )
+);
+
+// ../telemetry/src/browser-request-timing.ts
+var milliseconds = Schema_exports.Number.check(Schema_exports.isFinite(), Schema_exports.isGreaterThanOrEqualTo(0));
+var Entry = Schema_exports.Struct({
+  name: Schema_exports.String,
+  startTime: milliseconds,
+  duration: milliseconds,
+  domainLookupStart: milliseconds,
+  domainLookupEnd: milliseconds,
+  connectStart: milliseconds,
+  connectEnd: milliseconds,
+  secureConnectionStart: milliseconds,
+  requestStart: milliseconds,
+  responseStart: milliseconds,
+  responseEnd: milliseconds,
+  deliveryType: Schema_exports.optional(Schema_exports.String),
+  transferSize: Schema_exports.optional(milliseconds),
+  decodedBodySize: Schema_exports.optional(milliseconds),
+  serverTiming: Schema_exports.Array(
+    Schema_exports.Struct({
+      name: Schema_exports.String,
+      description: Schema_exports.String,
+      duration: milliseconds
+    })
+  )
+});
+var decode = Schema_exports.decodeUnknownOption(Entry);
+var browserRequestTiming = (entry, origin) => {
+  const parsed = decode(entry);
+  if (Option_exports.isNone(parsed)) return;
+  const value = parsed.value;
+  if (value.deliveryType === "cache" || value.transferSize === 0 && value.decodedBodySize !== void 0 && value.decodedBodySize > 0)
+    return;
+  if (!URL.canParse(value.name)) return;
+  const url = new URL(value.name);
+  if (url.origin !== origin || /\/api\/telemetry\/(traces|logs)\/?$/.test(url.pathname)) return;
+  const trace = value.serverTiming.find((timing) => timing.name === "executor-trace")?.description;
+  if (trace === void 0 || !/^[a-f0-9]{32}$/.test(trace)) return;
+  const attributes = {
+    "executor.trace_id": trace,
+    "browser.request.duration_ms": value.duration
+  };
+  const span = value.serverTiming.find((timing) => timing.name === "executor-span")?.description;
+  if (span !== void 0 && /^(?!0{16}$)[a-f0-9]{16}$/.test(span))
+    attributes["executor.span_id"] = span;
+  const sampled = value.serverTiming.find(
+    (timing) => timing.name === "executor-sampled"
+  )?.description;
+  if (sampled === "1" || sampled === "0") attributes["executor.trace_sampled"] = Number(sampled);
+  const ray = value.serverTiming.find((timing) => timing.name === "cf-ray")?.description;
+  if (ray !== void 0 && /^[a-f0-9]{16,32}(?:-[A-Z]{3})?$/i.test(ray))
+    attributes["cloudflare.ray_id"] = ray.replace(/-[A-Z]{3}$/i, "");
+  const phase = (name, start, end) => {
+    if (start > 0 && end >= start) attributes[`browser.request.${name}_ms`] = end - start;
+  };
+  phase("dns", value.domainLookupStart, value.domainLookupEnd);
+  phase("connection", value.connectStart, value.connectEnd);
+  phase("tls", value.secureConnectionStart, value.connectEnd);
+  phase("waiting_for_headers", value.requestStart, value.responseStart);
+  phase("body", value.responseStart, value.responseEnd);
+  if (value.responseStart > 0 && value.responseStart >= value.startTime)
+    attributes["browser.request.time_to_first_byte_ms"] = value.responseStart - value.startTime;
+  const handler = value.serverTiming.find((timing) => timing.name === "executor");
+  if (handler !== void 0) attributes["executor.handler.duration_ms"] = handler.duration;
+  return attributes;
+};
+
+// ../telemetry/src/browser-performance.ts
+var layoutShift = Schema_exports.decodeUnknownOption(
+  Schema_exports.Struct({ value: Schema_exports.Number, hadRecentInput: Schema_exports.Boolean })
+);
+var eventTiming = Schema_exports.decodeUnknownOption(
+  Schema_exports.Struct({
+    interactionId: Schema_exports.Number,
+    processingStart: Schema_exports.Number,
+    processingEnd: Schema_exports.Number
+  })
+);
+var eventDurationThreshold = 104;
+var observeBrowserPerformance = Effect_exports.gen(function* () {
+  const clock = window.performance;
+  if (clock === void 0 || typeof PerformanceObserver === "undefined") {
+    return {
+      flush: Effect_exports.void,
+      pause: Effect_exports.void,
+      resume: Effect_exports.void,
+      hide: Effect_exports.void,
+      restore: Effect_exports.void,
+      navigation: (_path) => Effect_exports.void
+    };
+  }
+  let pagePath = window.location.pathname;
+  const observers = /* @__PURE__ */ new Map();
+  const supported = /* @__PURE__ */ new Set();
+  let path = pagePath;
+  let generation = 0;
+  let since = 0;
+  let pageStart = 0;
+  let active = document.visibilityState !== "hidden";
+  let firstHidden = active ? Infinity : 0;
+  let connected = true;
+  let paint;
+  let largestPaint;
+  let lastPaint;
+  let lastLargestPaint;
+  let largestPaintFinished = false;
+  let cls = 0;
+  let lastCls;
+  let shiftWindowStart = 0;
+  let shiftWindowEnd = 0;
+  let shiftWindowValue = 0;
+  let longTasks = { count: 0, duration: 0, blocking: 0, max: 0 };
+  let interactions = { count: 0, duration: 0, inputDelay: 0, processing: 0 };
+  const run = yield* FiberSet_exports.makeRuntime();
+  const report = (name, attributes) => Effect_exports.logInfo(name).pipe(
+    Effect_exports.annotateLogs(attributes),
+    Effect_exports.withSpan(name, {
+      root: true,
+      attributes,
+      links: traceLinks(
+        {
+          traceId: attributes["executor.trace_id"],
+          spanId: attributes["executor.span_id"],
+          sampled: attributes["executor.trace_sampled"] === void 0 ? void 0 : attributes["executor.trace_sampled"] === 1
+        },
+        "request-timing"
+      )
+    })
+  );
+  const record = (entries) => {
+    for (const entry of entries) {
+      if (entry.startTime < pageStart) continue;
+      switch (entry.entryType) {
+        case "resource": {
+          const attributes = browserRequestTiming(entry, window.location.origin);
+          if (attributes !== void 0) run(report("ui.request.timing", attributes));
+          break;
+        }
+        case "paint":
+          if (entry.name === "first-contentful-paint" && entry.startTime < firstHidden) {
+            paint = entry.startTime;
+          }
+          break;
+        case "largest-contentful-paint":
+          if (!largestPaintFinished && entry.startTime < firstHidden) {
+            largestPaint = entry.startTime;
+          }
+          break;
+        case "layout-shift": {
+          const parsed = layoutShift(entry);
+          if (!active || Option_exports.isNone(parsed) || parsed.value.hadRecentInput) break;
+          const value = parsed.value.value;
+          if (!Number.isFinite(value) || value < 0) break;
+          if (shiftWindowValue > 0 && entry.startTime - shiftWindowEnd < 1e3 && entry.startTime - shiftWindowStart < 5e3) {
+            shiftWindowValue += value;
+          } else {
+            shiftWindowStart = entry.startTime;
+            shiftWindowValue = value;
+          }
+          shiftWindowEnd = entry.startTime;
+          cls = Math.max(cls, shiftWindowValue);
+          break;
+        }
+        case "longtask":
+          if (active) {
+            longTasks.count += 1;
+            longTasks.duration += entry.duration;
+            longTasks.blocking += Math.max(0, entry.duration - 50);
+            longTasks.max = Math.max(longTasks.max, entry.duration);
+          }
+          break;
+        case "event": {
+          const parsed = eventTiming(entry);
+          if (!active || Option_exports.isNone(parsed) || parsed.value.interactionId === 0) break;
+          interactions.count += 1;
+          interactions.duration = Math.max(interactions.duration, entry.duration);
+          interactions.inputDelay = Math.max(
+            interactions.inputDelay,
+            parsed.value.processingStart - entry.startTime
+          );
+          interactions.processing = Math.max(
+            interactions.processing,
+            parsed.value.processingEnd - parsed.value.processingStart
+          );
+          break;
+        }
+      }
+    }
+  };
+  const drain = () => {
+    for (const observer of observers.values()) record(observer.takeRecords());
+  };
+  const disconnect = () => {
+    for (const observer of observers.values()) observer.disconnect();
+    observers.clear();
+  };
+  const observe = (buffered) => {
+    for (const type of [
+      "paint",
+      "largest-contentful-paint",
+      "layout-shift",
+      "longtask",
+      "event",
+      "resource"
+    ]) {
+      if (!PerformanceObserver.supportedEntryTypes?.includes(type)) continue;
+      const observer = new PerformanceObserver((list) => record(list.getEntries()));
+      try {
+        observer.observe({
+          type,
+          buffered,
+          ...type === "event" ? { durationThreshold: eventDurationThreshold } : {}
+        });
+        supported.add(type);
+        observers.set(type, observer);
+      } catch {
+        observer.disconnect();
+      }
+    }
+  };
+  observe(true);
+  const flush = Effect_exports.gen(function* () {
+    drain();
+    const common = {
+      "browser.page.time_origin_ms": clock.timeOrigin,
+      "browser.page.restore_count": generation
+    };
+    const measurements = [];
+    const vital = (name, value, unit) => {
+      measurements.push({
+        name: "ui.performance.vital",
+        attributes: {
+          ...common,
+          "url.path": pagePath,
+          "browser.vital.name": name,
+          "browser.vital.value": value,
+          "browser.vital.unit": unit
+        }
+      });
+    };
+    if (paint !== void 0 && paint !== lastPaint) {
+      vital("FCP", paint, "ms");
+      lastPaint = paint;
+    }
+    if (largestPaint !== void 0 && largestPaint !== lastLargestPaint) {
+      vital("LCP", largestPaint, "ms");
+      lastLargestPaint = largestPaint;
+    }
+    if (supported.has("layout-shift") && (paint !== void 0 || generation > 0) && cls !== lastCls) {
+      vital("CLS", cls, "1");
+      lastCls = cls;
+    }
+    const now = clock.now();
+    const window2 = { ...common, "url.path": path, "browser.observation.duration_ms": now - since };
+    if (longTasks.count > 0) {
+      measurements.push({
+        name: "ui.performance.long-tasks",
+        attributes: {
+          ...window2,
+          "browser.long_task.count": longTasks.count,
+          "browser.long_task.duration_ms": longTasks.duration,
+          "browser.long_task.blocking_ms": longTasks.blocking,
+          "browser.long_task.max_duration_ms": longTasks.max
+        }
+      });
+    }
+    if (interactions.count > 0) {
+      measurements.push({
+        name: "ui.performance.interactions",
+        attributes: {
+          ...window2,
+          "browser.interaction.slow_event_count": interactions.count,
+          "browser.interaction.max_duration_ms": interactions.duration,
+          "browser.interaction.max_input_delay_ms": interactions.inputDelay,
+          "browser.interaction.max_processing_ms": interactions.processing,
+          "browser.interaction.duration_threshold_ms": eventDurationThreshold
+        }
+      });
+    }
+    since = now;
+    longTasks = { count: 0, duration: 0, blocking: 0, max: 0 };
+    interactions = { count: 0, duration: 0, inputDelay: 0, processing: 0 };
+    yield* Effect_exports.forEach(
+      measurements,
+      (measurement) => report(measurement.name, measurement.attributes)
+    );
+  });
+  const stopLargestPaint = () => {
+    drain();
+    largestPaintFinished = true;
+    observers.get("largest-contentful-paint")?.disconnect();
+    observers.delete("largest-contentful-paint");
+  };
+  window.addEventListener("keydown", stopLargestPaint, { capture: true });
+  window.addEventListener("pointerdown", stopLargestPaint, { capture: true });
+  yield* Effect_exports.addFinalizer(
+    () => flush.pipe(
+      Effect_exports.ensuring(
+        Effect_exports.sync(() => {
+          disconnect();
+          window.removeEventListener("keydown", stopLargestPaint, { capture: true });
+          window.removeEventListener("pointerdown", stopLargestPaint, { capture: true });
+        })
+      )
+    )
+  );
+  yield* report("ui.performance.support", {
+    "browser.performance.paint": supported.has("paint"),
+    "browser.performance.largest_contentful_paint": supported.has("largest-contentful-paint"),
+    "browser.performance.layout_shift": supported.has("layout-shift"),
+    "browser.performance.long_task": supported.has("longtask"),
+    "browser.performance.event_timing": supported.has("event")
+  });
+  yield* flush.pipe(Effect_exports.repeat(Schedule_exports.spaced("30 seconds")), Effect_exports.forkScoped);
+  return {
+    flush,
+    pause: Effect_exports.sync(() => {
+      drain();
+      firstHidden = Math.min(firstHidden, clock.now());
+      stopLargestPaint();
+      active = false;
+    }),
+    resume: Effect_exports.sync(() => {
+      drain();
+      active = connected;
+      since = clock.now();
+    }),
+    hide: Effect_exports.sync(() => {
+      drain();
+      connected = false;
+      active = false;
+      disconnect();
+    }),
+    restore: Effect_exports.sync(() => {
+      disconnect();
+      generation += 1;
+      pageStart = clock.now();
+      pagePath = window.location.pathname;
+      since = pageStart;
+      paint = lastPaint = largestPaint = lastLargestPaint = void 0;
+      largestPaintFinished = false;
+      cls = shiftWindowStart = shiftWindowEnd = shiftWindowValue = 0;
+      lastCls = void 0;
+      connected = true;
+      active = document.visibilityState !== "hidden";
+      firstHidden = active ? Infinity : pageStart;
+      longTasks = { count: 0, duration: 0, blocking: 0, max: 0 };
+      interactions = { count: 0, duration: 0, inputDelay: 0, processing: 0 };
+      observe(false);
+    }),
+    navigation: (nextPath) => flush.pipe(
+      Effect_exports.andThen(
+        Effect_exports.sync(() => {
+          path = nextPath;
+        })
+      )
+    )
+  };
+});
+
+// ../telemetry/src/browser-operations.ts
+var BrowserOperationFailure = Schema_exports.Struct({
+  error_type: Schema_exports.Literals([
+    "BrowserDecodeFailed",
+    "BrowserTransportFailed",
+    "BrowserOperationFailed"
+  ]),
+  trace_id: TraceContext.fields.traceId,
+  span_id: TraceContext.fields.spanId,
+  page_id: Schema_exports.String
+});
+var ResponseTrace = Context_exports.Reference("telemetry/ResponseTrace", {
+  defaultValue: () => void 0
+});
+
+// ../telemetry/src/browser.ts
+var BrowserTelemetry = class extends Context_exports.Service()("executor/BrowserTelemetry") {
+};
+var browserTelemetryLayer = (settings) => Layer_exports.unwrap(
+  settings.pipe(
+    Effect_exports.map(
+      (config) => Layer_exports.effect(
+        BrowserTelemetry,
+        Effect_exports.gen(function* () {
+          const flusher = yield* OtlpExporter_exports.Flusher;
+          const run = yield* FiberSet_exports.makeRuntime();
+          let navigation;
+          const performance = yield* observeBrowserPerformance;
+          const flush = performance.flush.pipe(
+            Effect_exports.andThen(flusher.flush),
+            Effect_exports.timeoutOption("2 seconds"),
+            Effect_exports.asVoid
+          );
+          const error = (name, value) => run(
+            Effect_exports.logError(Cause_exports.die(value)).pipe(
+              Effect_exports.andThen(Effect_exports.fail(value)),
+              Effect_exports.withSpan(name),
+              Effect_exports.ignore
+            )
+          );
+          const onError = (event) => error("ui.error", event.error ?? new Error(event.message));
+          const onRejection = (event) => error("ui.unhandled-rejection", event.reason);
+          const onHidden = () => {
+            run(
+              document.visibilityState === "hidden" ? performance.pause.pipe(Effect_exports.andThen(flush)) : performance.resume
+            );
+          };
+          const onHide = () => {
+            run(performance.hide.pipe(Effect_exports.andThen(flush)));
+          };
+          const onShow = (event) => {
+            if (event.persisted) run(performance.restore);
+          };
+          window.addEventListener("error", onError);
+          window.addEventListener("unhandledrejection", onRejection);
+          window.addEventListener("pagehide", onHide);
+          window.addEventListener("pageshow", onShow);
+          document.addEventListener("visibilitychange", onHidden);
+          yield* Effect_exports.addFinalizer(
+            () => Effect_exports.sync(() => {
+              window.removeEventListener("error", onError);
+              window.removeEventListener("unhandledrejection", onRejection);
+              window.removeEventListener("pagehide", onHide);
+              window.removeEventListener("pageshow", onShow);
+              document.removeEventListener("visibilitychange", onHidden);
+            })
+          );
+          return {
+            flush,
+            navigation: (event) => Effect_exports.sync(() => {
+              if (event.type === "end") {
+                if (navigation !== void 0) Deferred_exports.doneUnsafe(navigation, Effect_exports.void);
+                navigation = void 0;
+                return;
+              }
+              if (navigation !== void 0) Deferred_exports.doneUnsafe(navigation, Effect_exports.interrupt);
+              navigation = Deferred_exports.makeUnsafe();
+              run(
+                Deferred_exports.await(navigation).pipe(
+                  Effect_exports.withSpan("ui.navigation", {
+                    root: true,
+                    attributes: { "url.path": event.path }
+                  }),
+                  Effect_exports.ignore
+                )
+              );
+            }).pipe(
+              Effect_exports.andThen(
+                event.type === "start" ? performance.navigation(event.path) : Effect_exports.void
+              )
+            )
+          };
+        })
+      ).pipe(
+        Layer_exports.provideMerge(telemetryLayer(config, "process", Logger_exports.consoleJson)),
+        Layer_exports.provide(
+          Layer_exports.succeed(FetchHttpClient_exports.RequestInit, {
+            keepalive: true,
+            credentials: "same-origin"
+          })
+        )
+      )
+    )
+  )
+);
+var makeBrowserTelemetry = (settings) => {
+  const layer = browserTelemetryLayer(settings);
+  const memoMap = Layer_exports.makeMemoMapUnsafe();
+  const runtime = ManagedRuntime_exports.make(layer, { memoMap });
+  const atoms = Atom_exports.context({ memoMap });
+  atoms.addGlobalLayer(layer);
+  return { runtime, atoms };
+};
+var browserSettings = (basePath, service) => Effect_exports.sync(() => ({
+  service,
+  clock: "system",
+  version: document.querySelector('meta[name="executor-build"]')?.content ?? "development",
+  environment: document.querySelector('meta[name="executor-environment"]')?.content ?? "development",
+  traces: { url: new URL(`${basePath}/traces`, window.location.origin).href },
+  logs: { url: new URL(`${basePath}/logs`, window.location.origin).href }
+}));
+
+// src/implementation/optimistic.ts
+var canonical = (value) => Array.isArray(value) ? value.map(canonical) : value !== null && typeof value === "object" ? Object.fromEntries(
+  Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, canonical(item)])
+) : value;
+var keyOf = (name, input) => JSON.stringify([name, canonical(input)]);
+var json = Schema_exports.decodeUnknownSync(JsonValue);
+var makeOptimisticClient = (transport) => {
+  const registry = AtomRegistry_exports.make({ defaultIdleTTL: 0 });
+  const entries = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
+  const callers = /* @__PURE__ */ new Set();
+  const lock = Semaphore_exports.makeUnsafe(1);
+  let disposed = false;
+  let idle = true;
+  const project = () => {
+    let values = new Map(
+      [...entries].map(([key, entry]) => [
+        key,
+        Option_exports.getOrUndefined(AsyncResult_exports.value(entry.base))
+      ])
+    );
+    const changed = /* @__PURE__ */ new Set();
+    for (const update of pending) {
+      const next = new Map(values);
+      const touched = /* @__PURE__ */ new Set();
+      const store = {
+        getQuery: (reference, input) => {
+          return structuredClone(next.get(keyOf(reference.name, json(input))));
+        },
+        getAllQueries: (reference) => [...entries].filter(([, entry]) => entry.name === reference.name).map(([key, entry]) => ({
+          // SAFETY: input is validated JSON; the referenced operation and each query decoder bind these types.
+          input: structuredClone(entry.input),
+          value: structuredClone(next.get(key))
+        })),
+        setQuery: (reference, input, value) => {
+          const key = keyOf(reference.name, json(input));
+          const entry = entries.get(key);
+          if (entry !== void 0) {
+            next.set(key, structuredClone(entry.schema.parse(value)));
+            touched.add(key);
+          }
+        }
+      };
+      try {
+        const result = update.project(store);
+        if (result !== void 0)
+          throw new Error("Optimistic updates must be synchronous and return nothing.");
+        values = next;
+        for (const key of touched) changed.add(key);
+      } catch (error) {
+        update.invalid = true;
+        pending.delete(update);
+        if (!update.sent) Deferred_exports.doneUnsafe(update.result, Effect_exports.fail(error));
+        transport.reportProjectionError({
+          operationId: update.operationId,
+          name: update.name,
+          sent: update.sent
+        });
+      }
+    }
+    Atom_exports.batch(() => {
+      for (const [key, entry] of entries) {
+        registry.set(
+          entry.visible,
+          changed.has(key) ? AsyncResult_exports.isInitial(entry.base) ? AsyncResult_exports.success(values.get(key)) : AsyncResult_exports.map(entry.base, () => values.get(key)) : entry.base
+        );
+      }
+    });
+  };
+  const stop = (entry) => {
+    entry.generation++;
+    entry.stop?.();
+    entry.stop = void 0;
+  };
+  const start = (entry) => {
+    stop(entry);
+    const generation = entry.generation;
+    entry.stop = registry.subscribe(
+      transport.source(entry.name, entry.input, entry.schema),
+      (snapshot) => {
+        if (disposed || generation !== entry.generation || !idle || AsyncResult_exports.isInitial(snapshot))
+          return;
+        entry.base = snapshot;
+        project();
+      },
+      { immediate: true }
+    );
+  };
+  const reconcile = Effect_exports.gen(function* () {
+    for (const entry of entries.values()) entry.staged = void 0;
+    while (!disposed) {
+      const unread = [...entries.values()].filter((entry) => entry.staged === void 0);
+      if (unread.length === 0) break;
+      yield* Effect_exports.forEach(
+        unread,
+        (entry) => Effect_exports.gen(function* () {
+          yield* Effect_exports.raceFirst(
+            Effect_exports.gen(function* () {
+              const exit = yield* Effect_exports.exit(
+                transport.read(entry.name, entry.input, entry.schema).pipe(Effect_exports.timeout("30 seconds"))
+              );
+              entry.staged = Exit_exports.isSuccess(exit) ? AsyncResult_exports.success(exit.value) : AsyncResult_exports.failureWithPrevious(exit.cause, {
+                previous: Option_exports.some(entry.base)
+              });
+            }),
+            Deferred_exports.await(entry.released)
+          );
+        }),
+        { concurrency: "unbounded", discard: true }
+      );
+    }
+    for (const entry of entries.values()) {
+      if (entry.staged !== void 0) entry.base = entry.staged;
+      entry.staged = void 0;
+    }
+  });
+  const mutation = (reference, output, update) => {
+    const invoke = (input) => {
+      if (disposed) return Promise.reject(new Error("App client is disposed."));
+      let parsed;
+      let args;
+      try {
+        parsed = structuredClone(json(input));
+        args = structuredClone(input);
+      } catch (error) {
+        return Promise.reject(error);
+      }
+      const result = Deferred_exports.makeUnsafe();
+      const item = {
+        operationId: crypto.randomUUID(),
+        name: reference.name,
+        project: (store) => update?.(store, structuredClone(args)),
+        result,
+        sent: false,
+        invalid: false
+      };
+      callers.add(result);
+      pending.add(item);
+      project();
+      transport.fork(
+        lock.withPermits(1)(
+          Effect_exports.gen(function* () {
+            if (disposed || item.invalid) return;
+            idle = false;
+            for (const entry of entries.values()) stop(entry);
+            item.sent = true;
+            const exit = yield* Effect_exports.exit(
+              transport.write(reference.name, parsed, output).pipe(Effect_exports.annotateSpans("executor.operation.id", item.operationId))
+            );
+            Deferred_exports.doneUnsafe(result, exit);
+            callers.delete(result);
+            if (Exit_exports.isFailure(exit)) {
+              pending.delete(item);
+              project();
+            }
+            yield* reconcile;
+            pending.delete(item);
+            idle = true;
+            project();
+            for (const entry of entries.values()) start(entry);
+          })
+        ).pipe(
+          Effect_exports.ensuring(
+            Effect_exports.sync(() => {
+              callers.delete(result);
+              pending.delete(item);
+            })
+          ),
+          Effect_exports.ignore
+        )
+      );
+      return transport.run(Deferred_exports.await(result)).then((value) => output.parse(value));
+    };
+    return Object.assign(invoke, {
+      withOptimisticUpdate: (project2) => mutation(reference, output, project2)
+    });
+  };
+  return {
+    mutation: (reference, output) => mutation(reference, output),
+    /** Shares state across mounts; the last subscriber releases the stream and cache entry. */
+    queryAtom: (reference, input, output) => {
+      const parsed = structuredClone(json(input));
+      const key = keyOf(reference.name, parsed);
+      return Atom_exports.readable((get) => {
+        if (disposed) return AsyncResult_exports.failure(Cause_exports.fail(new Error("App client is disposed.")));
+        let entry = entries.get(key);
+        if (entry === void 0) {
+          entry = {
+            name: reference.name,
+            input: parsed,
+            schema: output,
+            visible: Atom_exports.make(AsyncResult_exports.initial()),
+            base: AsyncResult_exports.initial(),
+            staged: void 0,
+            stop: void 0,
+            generation: 0,
+            subscribers: 0,
+            released: Deferred_exports.makeUnsafe()
+          };
+          entries.set(key, entry);
+          if (idle) start(entry);
+          project();
+        }
+        const retained = entry;
+        retained.subscribers++;
+        const typed = (snapshot) => {
+          return snapshot;
+        };
+        const release = registry.subscribe(
+          retained.visible,
+          (snapshot) => get.setSelf(typed(snapshot))
+        );
+        get.addFinalizer(() => {
+          release();
+          retained.subscribers--;
+          if (retained.subscribers === 0) {
+            stop(retained);
+            entries.delete(key);
+            Deferred_exports.doneUnsafe(retained.released, Effect_exports.void);
+          }
+        });
+        return typed(registry.get(retained.visible));
+      }).pipe(Atom_exports.setIdleTTL(0));
+    },
+    /** Cancel callers and close streams; the transport owner then interrupts its fibers. */
+    dispose: () => {
+      disposed = true;
+      for (const entry of entries.values()) stop(entry);
+      for (const result of callers)
+        Deferred_exports.doneUnsafe(result, Effect_exports.fail(new Error("App client is disposed.")));
+      entries.clear();
+      pending.clear();
+      callers.clear();
+      registry.dispose();
+    }
+  };
+};
+
+// src/implementation/ui-client.ts
+var createAppClient = () => {
+  const { runtime, atoms } = makeBrowserTelemetry(
+    browserSettings("/_executor/api/telemetry", "executor-app-web")
+  );
+  const browser = atoms(Layer_exports.empty);
+  const deploymentChanged = Effect_exports.sync(() => {
+    window.dispatchEvent(new Event("executor:deployment-changed"));
+  });
+  let pendingWrites = 0;
+  const beforeUnload = (event) => {
+    event.preventDefault();
+    event.returnValue = "";
+  };
+  const awaitWrite = (effect) => {
+    if (pendingWrites++ === 0) window.addEventListener("beforeunload", beforeUnload);
+    return runtime.runPromise(effect).finally(() => {
+      if (--pendingWrites === 0) window.removeEventListener("beforeunload", beforeUnload);
+    });
+  };
+  const onHide = (event) => {
+    if (!event.persisted) void dispose().catch((error) => console.error(error));
+  };
+  const dispose = async () => {
+    window.removeEventListener("pagehide", onHide);
+    window.removeEventListener("beforeunload", beforeUnload);
+    optimistic.dispose();
+    await runtime.dispose();
+  };
+  window.addEventListener("pagehide", onHide);
+  runtime.runFork(Effect_exports.void);
+  const context = Effect_exports.try({
+    try: () => document.getElementById("executor-context")?.textContent,
+    catch: () => new UiFailed({ reason: "unavailable" })
+  }).pipe(Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.fromJsonString(UiContext))));
+  const client = HttpApiClient_exports.make(AppUiApi).pipe(Effect_exports.provide(FetchHttpClient_exports.layer));
+  const payload = (name, input) => Effect_exports.gen(function* () {
+    return {
+      ...yield* context,
+      name,
+      input: yield* Schema_exports.decodeUnknownEffect(JsonValue)(input)
+    };
+  });
+  const request = (kind, name, input, output) => Effect_exports.gen(function* () {
+    const api = yield* client;
+    const value = yield* api.ui[kind]({ payload: yield* payload(name, input) });
+    return yield* Schema_exports.decodeUnknownEffect(decoderOf(output))(value);
+  }).pipe(
+    Effect_exports.tapErrorTag("UiDeploymentChanged", () => deploymentChanged),
+    Effect_exports.withSpan(`ui.app.${kind}`, { attributes: { "executor.operation.name": name } })
+  );
+  const source = (name, input, output) => browser.atom(
+    Stream_exports.suspend(() => {
+      let previous;
+      let attempts = 0;
+      return Stream_exports.unwrap(
+        Effect_exports.gen(function* () {
+          const attempt = attempts++;
+          const first = yield* pendingSpan("ui.app.first_result", {
+            attributes: {
+              "executor.operation.name": name,
+              "executor.subscription.attempt": attempt
+            },
+            links: previous === void 0 ? [] : [{ span: previous, attributes: { "executor.link.kind": "retry" } }]
+          });
+          previous = Tracer_exports.externalSpan({
+            traceId: first.span.traceId,
+            spanId: first.span.spanId,
+            sampled: first.span.sampled
+          });
+          const finish = (exit) => first.finish(exit).pipe(
+            Effect_exports.andThen(
+              Exit_exports.isFailure(exit) && !Cause_exports.hasInterrupts(exit.cause) ? Effect_exports.fail(new AppQueryFailed()).pipe(
+                Effect_exports.withSpan("ui.app.subscription.failure", {
+                  parent: first.span,
+                  attributes: {
+                    "executor.operation.name": name,
+                    "executor.subscription.attempt": attempt
+                  }
+                }),
+                Effect_exports.ignore
+              ) : Effect_exports.void
+            )
+          );
+          const clock = yield* Clock_exports.Clock;
+          const started = clock.currentTimeMillisUnsafe();
+          const frames = yield* Effect_exports.gen(function* () {
+            const api = yield* client;
+            return yield* api.ui.subscribe({
+              payload: yield* payload(name, input)
+            });
+          }).pipe(
+            Effect_exports.withSpan("ui.app.subscribe", {
+              parent: first.span,
+              attributes: { "executor.operation.name": name }
+            }),
+            Effect_exports.onError((cause) => finish(Exit_exports.failCause(cause)))
+          );
+          let revision = 0;
+          return frames.pipe(
+            Stream_exports.timeout("45 seconds"),
+            Stream_exports.concat(Stream_exports.fail(new UiFailed({ reason: "unavailable" }))),
+            Stream_exports.filter((frame) => frame.type !== "heartbeat"),
+            Stream_exports.mapEffect((frame) => {
+              if (frame.type === "failure") return Effect_exports.fail(frame.error);
+              const server = externalTrace(frame.trace);
+              return Effect_exports.gen(function* () {
+                const value = yield* Schema_exports.decodeUnknownEffect(decoderOf(output))(
+                  frame.value
+                ).pipe(Effect_exports.mapError(() => new UiFailed({ reason: "operation_failed" })));
+                const received = yield* Effect_exports.currentSpan;
+                const receivedAt = clock.currentTimeMillisUnsafe();
+                const currentRevision = revision++;
+                yield* Effect_exports.annotateCurrentSpan({
+                  "executor.operation.name": name,
+                  "executor.snapshot.revision": currentRevision,
+                  "browser.query.elapsed_ms": receivedAt - started,
+                  "executor.trace.context_valid": Option_exports.isSome(server)
+                });
+                yield* first.finish(Exit_exports.void);
+                let committed = false;
+                return {
+                  value,
+                  commit: () => {
+                    if (committed) return;
+                    committed = true;
+                    const committedAt = clock.currentTimeMillisUnsafe();
+                    runtime.runFork(
+                      Effect_exports.void.pipe(
+                        Effect_exports.withSpan("ui.app.result.commit", {
+                          parent: received,
+                          attributes: {
+                            "executor.operation.name": name,
+                            "executor.snapshot.revision": currentRevision,
+                            "browser.query.elapsed_ms": committedAt - started,
+                            "browser.query.receive_to_commit_ms": committedAt - receivedAt,
+                            "browser.page.hidden": document.visibilityState === "hidden"
+                          }
+                        })
+                      )
+                    );
+                  }
+                };
+              }).pipe(
+                Effect_exports.withSpan("ui.app.result.receive", {
+                  parent: Option_exports.isSome(server) ? server.value : first.span,
+                  kind: "consumer"
+                })
+              );
+            }),
+            Stream_exports.onExit(finish),
+            Stream_exports.provideService(Tracer_exports.ParentSpan, first.span)
+          );
+        })
+      ).pipe(
+        // Keep the last snapshot while the watcher replaces the document.
+        // Unmount or client disposal interrupts the deployment-change wait.
+        Stream_exports.catch(
+          (error) => Schema_exports.is(UiDeploymentChanged)(error) ? Stream_exports.unwrap(deploymentChanged.pipe(Effect_exports.as(Stream_exports.never))) : Stream_exports.fail(error)
+        ),
+        Stream_exports.retry(
+          Schedule_exports.spaced("1 second").pipe(
+            Schedule_exports.while(
+              ({ input: input2 }) => HttpClientError_exports.isHttpClientError(input2) || Cause_exports.isTimeoutError(input2) || Schema_exports.is(UiFailed)(input2)
+            )
+          )
+        )
+      );
+    })
+  ).pipe(Atom_exports.map(queryResult));
+  const optimistic = makeOptimisticClient({
+    source,
+    read: (name, input, output) => request("query", name, input, output),
+    write: (name, input, output) => request("mutate", name, input, output),
+    fork: (effect) => {
+      runtime.runFork(effect);
+    },
+    run: awaitWrite,
+    reportProjectionError: ({ operationId, name, sent }) => {
+      runtime.runFork(
+        Effect_exports.fail(new UiFailed({ reason: "operation_failed" })).pipe(
+          Effect_exports.withSpan("ui.optimistic.failure", {
+            attributes: {
+              "executor.operation.id": operationId,
+              "executor.operation.name": name,
+              "executor.optimistic.sent": sent
+            }
+          }),
+          Effect_exports.ignore
+        )
+      );
+    }
+  });
+  return {
+    /** Close this client when its page or embedding owner is removed. */
+    dispose,
+    /** Query this app once, with a runtime-validated response. Does not populate the mounted query cache. */
+    query: (reference, input, output) => runtime.runPromise(request("query", reference.name, input, output)),
+    /** Execute a write once in this client's queue. Success acknowledges the write; queries reconcile afterward. */
+    mutate: (reference, input, output) => optimistic.mutation(reference, output)(input),
+    /** Create a callable mutation with optional withOptimisticUpdate projections over mounted queries. */
+    mutation: optimistic.mutation,
+    /** Share a live query across mounts and reconcile optimistic changes against fresh server reads. */
+    queryAtom: optimistic.queryAtom
+  };
+};
+export {
+  AppQueryFailed,
+  createAppClient,
+  liveQueryAtom,
+  mutationReference,
+  queryReference
+};