@ogygia/core 0.12.3 → 0.13.0

package/dist/runtime/client-hooks.js

@@ -1,4 +1,5 @@
 import { kit_hydrates_page } from "./kit-boot.js";
+import { OgygiaError } from "../messages/core.js";
 // src/runtime/client-hooks.ts
 /**
 * Run the app's `hooks.client.ts` `init()` on a csr=false page.
@@ -17,6 +18,6 @@ import { kit_hydrates_page } from "./kit-boot.js";
 function run_app_client_hooks(loader) {
 	if (typeof document === "undefined") return;
 	if (kit_hydrates_page()) return;
-	Promise.resolve().then(loader).then((m) => m.init?.()).catch((e) => console.error("[ogygia] hooks.client init failed:", e));
+	Promise.resolve().then(loader).then((m) => m.init?.()).catch((e) => console.error(new OgygiaError("client_hooks_init_failed"), e));
 }
 export { run_app_client_hooks };

package/dist/runtime/concurrency.d.ts

@@ -1,12 +1,23 @@
-/**
- * Shared concurrency gate — client region fetches (SI-STORM) and server region SSR (M1).
- * Caps in-flight work; waiters queue FIFO. Does not cancel running work (see INVARIANTS.md).
- */
+export interface GateOptions {
+  /** The call answers within this long: the wait for a slot and the run together. */
+  deadline_ms?: number;
+  /** Nobody waits on the call any more once it aborts (a batch whose visitor left, #245): still
+   *  waiting, it leaves the queue at once and its body never runs (the call rejects with the
+   *  signal's reason); already running, it runs on (a body cannot be cancelled). */
+  signal?: AbortSignal;
+}
 export declare class ConcurrencyGate {
   #private;
   constructor(max: number);
-  run<T>(fn: () => Promise<T>): Promise<T>;
+  run<T>(fn: () => Promise<T>, options?: GateOptions): Promise<T>;
+  /** Bodies running that someone waits on (the limit counts these). */
   get active(): number;
+  /** Bodies past their deadline still running: nobody waits on them, and they hold no slot. */
+  get abandoned(): number;
+  /** Calls waiting for a slot. */
+  get waiting(): number;
 }
+/** Whether `error` is a call's run timeout: its body ran past the deadline and was abandoned. */
+export declare function is_run_timeout(error: unknown): boolean;
 /** Max concurrent region SSR renders per process (CPU amp under valid MAC). */
 export declare const REGION_RENDER_CONCURRENCY = 4;

package/dist/runtime/concurrency.js

@@ -1,29 +1,145 @@
+import { scope } from "@ogygia/machine";
 // src/runtime/concurrency.ts
 /**
 * Shared concurrency gate — client region fetches (SI-STORM) and server region SSR (M1).
 * Caps in-flight work; waiters queue FIFO. Does not cancel running work (see INVARIANTS.md).
+*
+* The promise: never more than `limit` bodies running that someone still waits on (#195), and a
+* call with a deadline answers within it.
+* - A freed slot is HANDED to the next waiter in the same step: it is never free in between, so a
+*   call arriving while the waiter resumes queues behind it instead of entering beside it.
+* - `deadline_ms` covers the whole call, the wait for a slot and the run together. A waiter whose
+*   deadline passes gives up and never runs. A body still running at its deadline is ABANDONED: its
+*   caller gets the timeout and its slot goes to the next call at once. Svelte's `render()` cannot
+*   be cancelled, so the body runs on, counted in `abandoned` until it ends; it never blocks a slot,
+*   or a hung upstream (renders that never end) would hold every slot and take every hole down.
+* - A call's `signal` aborting while it waits takes it out of the queue: a body nobody waits on any
+*   more never starts, and never holds a slot.
+*
+* Each call owns its timers and its listener on `signal` (a scope): they are let go the moment the
+* call settles, whichever way.
 */
+/** The caller's error when its body ran past the deadline (it was abandoned). */
+const RUN_TIMEOUT = "region render timeout";
+/** The caller's error when no slot came before the deadline (its body never ran). */
+const WAIT_TIMEOUT = "region render queue timeout";
 var ConcurrencyGate = class {
 	#limit;
 	#active = 0;
+	#abandoned = 0;
 	#wait = [];
 	constructor(max) {
 		this.#limit = Math.max(1, max);
 	}
-	async run(fn) {
-		if (this.#active >= this.#limit) await new Promise((resolve) => this.#wait.push(resolve));
-		this.#active++;
+	async run(fn, options = {}) {
+		const { deadline_ms, signal } = options;
+		if (signal?.aborted) throw signal.reason;
+		const deadline = deadline_ms === void 0 ? Infinity : Date.now() + deadline_ms;
+		const call = scope();
 		try {
-			return await fn();
+			await this.#enter(deadline, signal, call);
+			if (signal?.aborted) {
+				this.#leave();
+				throw signal.reason;
+			}
+			let body;
+			try {
+				body = fn();
+			} catch (error) {
+				body = Promise.reject(error);
+			}
+			let holds = true;
+			const end = () => {
+				if (holds) {
+					holds = false;
+					this.#leave();
+				} else this.#abandoned--;
+			};
+			body.then(end, end);
+			if (deadline === Infinity) return await body;
+			return await within(call, body, deadline - Date.now(), () => {
+				if (!holds) return;
+				holds = false;
+				this.#abandoned++;
+				this.#leave();
+			});
 		} finally {
-			this.#active--;
-			this.#wait.shift()?.();
+			call.close();
 		}
 	}
+	/** Bodies running that someone waits on (the limit counts these). */
 	get active() {
 		return this.#active;
 	}
+	/** Bodies past their deadline still running: nobody waits on them, and they hold no slot. */
+	get abandoned() {
+		return this.#abandoned;
+	}
+	/** Calls waiting for a slot. */
+	get waiting() {
+		return this.#wait.length;
+	}
+	/** A slot: at once when one is free, else in turn (or the deadline passes, or the signal aborts,
+	*  first). */
+	#enter(deadline, signal, call) {
+		if (this.#active < this.#limit) {
+			this.#active++;
+			return Promise.resolve();
+		}
+		return new Promise((resolve, reject) => {
+			const wait = call.child();
+			const settle = () => wait.close();
+			const give_up = (error) => {
+				waiter.gave_up = true;
+				settle();
+				const at = this.#wait.indexOf(waiter);
+				if (at !== -1) this.#wait.splice(at, 1);
+				reject(error);
+			};
+			const waiter = {
+				gave_up: false,
+				deadline,
+				enter: () => {
+					settle();
+					resolve();
+				}
+			};
+			if (deadline !== Infinity) wait.timeout(() => give_up(/* @__PURE__ */ new Error(WAIT_TIMEOUT)), timer_ms(deadline - Date.now()));
+			if (signal) wait.on(signal, "abort", () => give_up(signal.reason));
+			this.#wait.push(waiter);
+		});
+	}
+	/** A slot is given back: it goes straight to the next waiter still waiting, else it is free. (A
+	*  waiter whose deadline has come is passed over even before its timer runs: handed a slot, it
+	*  would only start a body nobody waits on.) */
+	#leave() {
+		const now = Date.now();
+		let next = this.#wait.shift();
+		while (next && (next.gave_up || next.deadline <= now)) next = this.#wait.shift();
+		if (next) next.enter();
+		else this.#active--;
+	}
 };
+/** Whether `error` is a call's run timeout: its body ran past the deadline and was abandoned. */
+function is_run_timeout(error) {
+	return error instanceof Error && error.message === RUN_TIMEOUT;
+}
+/** `work`, or the run timeout after `ms` (`on_timeout` first). The timer is the call's: it goes
+*  when the call settles. */
+function within(call, work, ms, on_timeout) {
+	return new Promise((resolve, reject) => {
+		call.timeout(() => {
+			on_timeout();
+			reject(/* @__PURE__ */ new Error(RUN_TIMEOUT));
+		}, timer_ms(ms));
+		work.then(resolve, reject);
+	});
+}
+/** A delay a timer can hold: a deadline already past is now, and one past the longest a timer
+*  holds (2^31 - 1 ms) waits that long. */
+function timer_ms(ms) {
+	return Math.min(2147483647, Math.max(0, ms));
+}
 /** Max concurrent region SSR renders per process (CPU amp under valid MAC). */
 const REGION_RENDER_CONCURRENCY = 4;
-export { ConcurrencyGate, REGION_RENDER_CONCURRENCY };
+export { ConcurrencyGate, REGION_RENDER_CONCURRENCY, is_run_timeout };

package/dist/runtime/core.d.ts

@@ -4,11 +4,13 @@ import { ClientPlugin } from "../plugin/client.js";
  * inlined `<style data-ogygia-region-css="href">`) it carries into `<head>` (deduped by href). A held / server-picked region's component was never
  * imported by the page, so its scoped CSS is in no stylesheet the page loaded; the region response
  * ships the links and the runtime lifts them to the head — where they load once and stick. (A link
- * left in the body would also fail to load inside a `<template>` batch parcel.)
+ * left in the body would also fail to load inside a `<template>` batch parcel.) `sheets`: the head
+ * nodes the answer uses, for the region that paints it (./region-sheets.ts `use_sheets`).
  */
 export declare function region_fragment(html: string): {
   frag: DocumentFragment;
   ready: Promise<void>;
+  sheets: readonly Element[];
 };
 /** TEST: the pristine server markup {@link region_fragment} stashed on a nested island, if any. */
 export declare function pristine_ssr_of(el: Element): string | undefined;