@pyric/cli 0.1.0-alpha.12 → 0.1.0-alpha.14

package/src/serve/worker/protocol.ts

@@ -482,6 +482,8 @@ export type OpMessage = (
   | { t: 'op'; id: string; method: 'ai.countTokens'; model: string; request: Record<string, unknown>; engine?: AiEngineConfigWire }
   // Staleness guard: report the worker's baked build version so the page can
   // warn when a still-running OLD worker serves code older than what's served.
+  | { t: 'op'; id: string; method: 'getRuntimeEpoch' }
+  | { t: 'op'; id: string; method: 'retireRuntime'; targetEpoch: string }
   | { t: 'op'; id: string; method: 'getVersion' }
   // ── Phase 2 (transfer): export/import the FULL sandbox state as a bundle
   // string (the chunk format the persist layer uses). importState CLOBBERS. ──
@@ -914,7 +916,17 @@ export interface EventStreamMessage {
   events: readonly SandboxEvent[];
 }
 
-export type OutboundMessage = ResMessage | SnapMessage | EventStreamMessage;
+/** The retiring worker tells every connected page to reload after it drains. */
+export interface RuntimeReloadMessage {
+  t: 'runtime-reload';
+  epoch: string;
+}
+
+export type OutboundMessage =
+  | ResMessage
+  | SnapMessage
+  | EventStreamMessage
+  | RuntimeReloadMessage;
 
 // ─── Serialized document data ─────────────────────────────────────────────
 

package/src/serve/worker/retirement.ts

@@ -0,0 +1,125 @@
+interface RetirementPort {
+  postMessage(message: unknown): void;
+}
+
+interface WorkerRetirementOptions {
+  closeWorker(): void;
+  beforeAnnounce?(): Promise<void>;
+  drainTimeoutMs?: number;
+  schedule?: (run: () => void) => void;
+}
+
+export interface WorkerRetirement {
+  connect(port: RetirementPort): void;
+  disconnect(port: RetirementPort): void;
+  track(port: RetirementPort, work: Promise<void>): void;
+  trackDetached(work: Promise<void>): void;
+  accepting(): boolean;
+  retire(requester: RetirementPort, requestId: string, targetEpoch: string): Promise<void>;
+}
+
+/** Drain already-accepted port work before every page reloads onto a new worker. */
+export function createWorkerRetirement(options: WorkerRetirementOptions): WorkerRetirement {
+  const ports = new Set<RetirementPort>();
+  const workByPort = new Map<RetirementPort, Promise<void>>();
+  const detachedWork = new Set<Promise<void>>();
+  const requests: Array<{ requester: RetirementPort; requestId: string }> = [];
+  const schedule = options.schedule ?? ((run) => { setTimeout(run, 50); });
+  const drainTimeoutMs = options.drainTimeoutMs ?? 10_000;
+  let retiring = false;
+  let announced = false;
+  let announcedEpoch: string | null = null;
+  let retirement: Promise<void> | null = null;
+
+  const timeout = (work: Promise<void>): Promise<void> => new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error(`Worker retirement drain timed out after ${drainTimeoutMs}ms.`)),
+      drainTimeoutMs,
+    );
+    void work.then(
+      () => { clearTimeout(timer); resolve(); },
+      (error) => { clearTimeout(timer); reject(error); },
+    );
+  });
+
+  const failRequests = (error: Error): void => {
+    for (const request of requests.splice(0)) {
+      request.requester.postMessage({
+        t: 'res', id: request.requestId, ok: false,
+        error: { code: 'pyric/worker-retirement-timeout', message: error.message },
+      });
+    }
+  };
+
+  return {
+    connect(port) {
+      ports.add(port);
+      if (announcedEpoch) {
+        port.postMessage({ t: 'runtime-reload', epoch: announcedEpoch });
+      }
+    },
+    disconnect(port) {
+      ports.delete(port);
+    },
+    track(port, work) {
+      workByPort.set(port, work);
+      const settled = (): void => {
+        if (workByPort.get(port) === work) workByPort.delete(port);
+      };
+      void work.then(settled, settled);
+    },
+    trackDetached(work) {
+      detachedWork.add(work);
+      void work.then(
+        () => { detachedWork.delete(work); },
+        () => { detachedWork.delete(work); },
+      );
+    },
+    accepting: () => !retiring,
+    async retire(requester, requestId, targetEpoch) {
+      if (!/^[a-f0-9]{16}$/.test(targetEpoch)) {
+        requester.postMessage({
+          t: 'res', id: requestId, ok: false,
+          error: { code: 'pyric/invalid-worker-epoch', message: 'Invalid replacement worker epoch.' },
+        });
+        return;
+      }
+      if (announced) {
+        requester.postMessage({
+          t: 'res', id: requestId, ok: true, value: { retiring: true },
+        });
+        requester.postMessage({ t: 'runtime-reload', epoch: announcedEpoch! });
+        return;
+      }
+      requests.push({ requester, requestId });
+      if (!retirement) {
+        retiring = true;
+        const acceptedWork = [...workByPort.values(), ...detachedWork];
+        const attempt = { cancelled: false };
+        retirement = timeout((async () => {
+          await Promise.allSettled(acceptedWork);
+          if (attempt.cancelled) return;
+          await options.beforeAnnounce?.();
+          if (attempt.cancelled) return;
+          for (const request of requests.splice(0)) {
+            request.requester.postMessage({
+              t: 'res', id: request.requestId, ok: true, value: { retiring: true },
+            });
+          }
+          announced = true;
+          announcedEpoch = targetEpoch;
+          for (const port of ports) {
+            port.postMessage({ t: 'runtime-reload', epoch: targetEpoch });
+          }
+          schedule(options.closeWorker);
+        })()).catch((error: unknown) => {
+          attempt.cancelled = true;
+          retiring = false;
+          retirement = null;
+          failRequests(error instanceof Error ? error : new Error(String(error)));
+        });
+      }
+      await retirement;
+    },
+  };
+}

package/src/serve/worker/serve-init.ts

@@ -263,7 +263,7 @@ export function applyServeInit(
     const debounceMs = payload.capture ? (env.captureDebounceMs ?? 400) : 0;
     let timer: ReturnType<typeof setTimeout> | null = null;
 
-    const flush = (): void => {
+    const flush = async (): Promise<void> => {
       const rtdb = ctx.rtdb ??= getDatabase(ctx.sandbox);
       const rtdbState =
         payload.databaseRules || ctx.sandbox.history().some((event) => event.service === 'rtdb')
@@ -286,8 +286,7 @@ export function applyServeInit(
       }));
       // Relative URL resolves against the worker script's origin (same origin
       // as the page). Fire-and-forget — capture failures never break ops.
-      env
-        .fetch('/__pyric/capture', {
+      await env.fetch('/__pyric/capture', {
           method: 'POST',
           headers: { 'content-type': 'application/json' },
           body,
@@ -297,7 +296,7 @@ export function applyServeInit(
 
     const unsub = ctx.sandbox.onEvent(() => {
       if (timer) clearTimeout(timer);
-      timer = setTimeout(flush, debounceMs);
+      timer = setTimeout(() => { void flush(); }, debounceMs);
     });
 
     result.captureEnabled = true;
@@ -308,12 +307,12 @@ export function applyServeInit(
     // the next boot's `hydrateEventHistory` would prime them straight back
     // into Traffic. Bypasses the debounce; cancels any pending flush (it
     // would only re-write the same post-reset history).
-    ctx.captureFlush = (): void => {
+    ctx.captureFlush = async (): Promise<void> => {
       if (timer) {
         clearTimeout(timer);
         timer = null;
       }
-      flush();
+      await flush();
     };
     result.dispose = (): void => {
       if (timer) clearTimeout(timer);

package/src/vite.ts

@@ -8,6 +8,7 @@
  */
 export { pyric } from './serve/vite-plugin.js';
 export type { PyricOptions } from './serve/vite-plugin.js';
+export type { PyricRuntimeChipOption } from './serve/runtime/chip-config.js';
 
 // The benign node-builtin shims serve's bundler and this plugin apply when
 // bundling pyric's browser graph (`fs`/`path`/`url` reached via the rules