@askrjs/askr 0.2.4 → 0.3.1

package/dist/scope-Cq_iYbTR.js

@@ -0,0 +1,403 @@
+//#region src/runtime/ownership/record.ts
+/** One record per lifetime. Render and request revisions belong to execution
+* and requests respectively; neither replaces this identity on a rerender. */
+var OwnershipRecord = class {
+	constructor() {
+		this.identity = this;
+		this.disposed = false;
+		this.mounted = false;
+		this.controller = null;
+		this.hadScopedChildren = false;
+	}
+};
+/** A shared view surface populated only by the public compatibility adapter. */
+const componentRecordPrototype = {};
+const disposedSignal = (() => {
+	const controller = new AbortController();
+	controller.abort();
+	return controller.signal;
+})();
+function getOwnershipSignal(owner) {
+	if (owner.signal) return owner.signal;
+	if (owner.disposed) return disposedSignal;
+	owner.controller ??= new AbortController();
+	return owner.signal = owner.controller.signal;
+}
+function ownCleanup(owner, cleanup) {
+	if (owner.disposed) cleanup();
+	else (owner.cleanups ??= []).push(cleanup);
+}
+const scopedOwners = /* @__PURE__ */ new WeakMap();
+/** Index an existing native lifetime; scopes never receive another owner. */
+function registerScopedOwnership(scope, owner) {
+	owner.scope = scope;
+	scopedOwners.set(scope, owner);
+	if (owner.parent) {
+		owner.parent.hadScopedChildren = true;
+		owner.parent.scopedIndex?.add(scope);
+	}
+}
+function scopedOwnership(child) {
+	let lifetime = scopedOwners.get(child);
+	if (!lifetime) {
+		lifetime = new OwnershipRecord();
+		lifetime.cleanups = [() => child.dispose()];
+		registerScopedOwnership(child, lifetime);
+	}
+	return lifetime;
+}
+function ownChild(owner, child) {
+	attachOwnership(scopedOwnership(child), owner);
+}
+function releaseOwnedChild(owner, child) {
+	const lifetime = scopedOwners.get(child);
+	if (lifetime?.parent === owner) detachOwnership(lifetime);
+}
+function synchronizeScopedIndex(owner) {
+	const index = owner.scopedIndex;
+	for (let child = owner.head; child;) {
+		const next = child.next;
+		if (child.scope && !index?.has(child.scope)) detachOwnership(child);
+		child = next;
+	}
+	if (index) for (const scope of Set.prototype.values.call(index)) ownChild(owner, scope);
+}
+/** Compatibility collections are maintained indexes of the lifetime graph. */
+function getOwnedChildScopes(owner) {
+	if (!owner.hadScopedChildren) return void 0;
+	if (!owner.scopedIndex) {
+		owner.scopedIndex = /* @__PURE__ */ new Set();
+		if (owner.disposed) return owner.scopedIndex;
+		for (let child = owner.head; child; child = child.next) if (child.scope) owner.scopedIndex.add(child.scope);
+	}
+	return owner.scopedIndex;
+}
+function setOwnedChildScopes(owner, scopes) {
+	owner.scopedIndex = scopes;
+	owner.hadScopedChildren = scopes !== void 0;
+	synchronizeScopedIndex(owner);
+}
+function detachOwnedChildren(owner) {
+	while (owner.head) detachOwnership(owner.head);
+}
+/** Drain attachments within a composite cleanup before surfacing its failures. */
+function drainOwnedCleanup(items, cleanup) {
+	const errors = [];
+	for (const item of items) try {
+		cleanup(item);
+	} catch (error) {
+		errors.push(error);
+	}
+	if (errors.length) throw new AggregateError(errors, "Owned cleanup failed");
+}
+/** Detach the exact lifetime, independently of its execution record. */
+function detachOwnership(owner) {
+	const parent = owner.parent;
+	if (!parent) return;
+	if (owner.previous) owner.previous.next = owner.next;
+	else parent.head = owner.next;
+	if (owner.next) owner.next.previous = owner.previous;
+	else parent.tail = owner.previous;
+	if (owner.scope) parent.scopedIndex?.delete(owner.scope);
+	owner.parent = void 0;
+	owner.previous = void 0;
+	owner.next = void 0;
+}
+function attachOwnership(owner, parent) {
+	if (owner.parent === parent || owner.disposed) return;
+	if (parent === owner) throw new Error("[Askr] A lifetime cannot own itself.");
+	if (owner.head) {
+		for (let ancestor = parent; ancestor; ancestor = ancestor.parent) if (ancestor === owner) throw new Error("[Askr] Lifetime ownership cannot contain a cycle.");
+	}
+	detachOwnership(owner);
+	if (!parent) return;
+	if (parent.disposed) {
+		disposeOwnership(owner);
+		return;
+	}
+	linkOwnership(owner, parent);
+}
+function linkOwnership(owner, parent) {
+	owner.parent = parent;
+	owner.previous = parent.tail;
+	if (parent.tail) parent.tail.next = owner;
+	else parent.head = owner;
+	parent.tail = owner;
+	if (owner.scope) {
+		parent.hadScopedChildren = true;
+		parent.scopedIndex?.add(owner.scope);
+	}
+}
+function defaultDisposalPhases() {
+	const errors = [];
+	return {
+		recordError(_message, error) {
+			errors.push(error);
+		},
+		finish() {
+			if (errors.length) throw new AggregateError(errors, "Owned cleanup failed");
+		}
+	};
+}
+function attemptDisposal(frame, message, run) {
+	try {
+		run?.();
+	} catch (error) {
+		try {
+			frame.phases.recordError(message, error);
+		} catch (reportError) {
+			frame.unreported.push(reportError);
+		}
+	}
+}
+function prepareDisposal(owner, phases) {
+	const errors = [];
+	let scopes;
+	try {
+		if (owner.scopedIndex) synchronizeScopedIndex(owner);
+		if (owner.scopedIndex?.size) scopes = Set.prototype.values.call(owner.scopedIndex);
+	} catch (error) {
+		errors.push(error);
+		owner.scopedIndex = void 0;
+	}
+	owner.disposed = true;
+	detachOwnership(owner);
+	try {
+		phases ??= owner.lifecycle?.(owner);
+	} catch (error) {
+		errors.push(error);
+	}
+	const frame = {
+		owner,
+		phases: phases ?? defaultDisposalPhases(),
+		scopes,
+		unreported: errors
+	};
+	if (scopes) owner.scopedIndex = void 0;
+	attemptDisposal(frame, "[Askr] owner preparation threw:", frame.phases.begin);
+	return frame;
+}
+/** One iterative postorder drain for every lifetime, including deep chains. */
+function disposeOwnership(owner, phases) {
+	if (owner.disposed) return;
+	const stack = [prepareDisposal(owner, phases)];
+	while (stack.length) {
+		const frame = stack[stack.length - 1];
+		const current = frame.owner;
+		if (frame.scopes) {
+			const next = frame.scopes.next();
+			if (!next.done) {
+				const child = scopedOwnership(next.value);
+				if (!child.disposed && (!child.parent || child.parent === current)) {
+					if (!child.parent) linkOwnership(child, current);
+					stack.push(prepareDisposal(child));
+				}
+				continue;
+			}
+		}
+		if (current.head) {
+			const child = current.head;
+			if (frame.scopes && child.scope) {
+				detachOwnership(child);
+				continue;
+			}
+			stack.push(prepareDisposal(child));
+			continue;
+		}
+		const attempt = (message, run) => attemptDisposal(frame, message, run);
+		attempt("[Askr] readable subscription cleanup threw:", frame.phases.beforeCleanup);
+		const cleanups = current.cleanups;
+		current.cleanups = void 0;
+		if (cleanups) for (const cleanup of cleanups) attempt("[Askr] cleanup function threw:", cleanup);
+		attempt("[Askr] readable subscription cleanup threw:", frame.phases.afterCleanup);
+		attempt("[Askr] abort controller cleanup threw:", () => {
+			if (current.controller && !current.controller.signal.aborted) current.controller.abort(disposedSignal.reason);
+		});
+		current.controller = null;
+		current.reads = void 0;
+		current.mounted = false;
+		const finalizer = current.finalizer;
+		current.finalizer = void 0;
+		if (finalizer) attempt("[Askr] owner finalization threw:", () => finalizer.release());
+		try {
+			frame.phases.finish?.();
+		} catch (error) {
+			frame.unreported.push(error);
+		}
+		current.scope = void 0;
+		current.subject = void 0;
+		current.lifecycle = void 0;
+		stack.pop();
+		if (frame.unreported.length) {
+			const error = frame.unreported.length === 1 ? frame.unreported[0] : new AggregateError(frame.unreported, "Owned cleanup failed");
+			const parent = stack[stack.length - 1];
+			if (parent) attemptDisposal(parent, "[Askr] child ownership cleanup threw:", () => {
+				throw error;
+			});
+			else throw error;
+		}
+	}
+}
+//#endregion
+//#region src/runtime/component/scope.ts
+let currentInstance = null;
+let currentPortalScope = null;
+let scopedAppRenderRuntime;
+let stateIndex = 0;
+let globalRenderCounter = 0;
+function nextRenderToken() {
+	return ++globalRenderCounter;
+}
+function captureScope() {
+	return {
+		instance: currentInstance,
+		portalScope: currentPortalScope,
+		stateIndex
+	};
+}
+function restoreScope(snapshot) {
+	currentInstance = snapshot.instance;
+	currentPortalScope = snapshot.portalScope;
+	stateIndex = snapshot.stateIndex;
+}
+/**
+* Enter a component scope, returning the snapshot that restores it.
+*
+* The entry describes only what changes; the snapshot always carries all three
+* ambient fields, and `endComponentScope` always restores all three. Callers
+* therefore cannot introduce a variant that saves a subset and leaves the rest
+* pointing at the previous component, which is what the older enter/exit pairs
+* each did differently.
+*
+* Prefer `withComponentScope`. Use this pair directly only where the scope
+* genuinely cannot be expressed as a closure, such as a span across two
+* separately invoked lifecycle phases.
+*/
+function beginComponentScope(entry) {
+	const snapshot = captureScope();
+	if ("instance" in entry) {
+		const instance = entry.instance ?? null;
+		currentInstance = instance;
+		currentPortalScope = instance?.portalScope ?? snapshot.portalScope;
+	}
+	if ("portalScope" in entry) currentPortalScope = entry.portalScope ?? null;
+	if (entry.stateIndex !== void 0) stateIndex = entry.stateIndex;
+	return snapshot;
+}
+/** Restore every ambient scope field captured by `beginComponentScope`. */
+function endComponentScope(snapshot) {
+	restoreScope(snapshot);
+}
+function getCurrentComponentInstance() {
+	return currentInstance;
+}
+function getCurrentAppRenderRuntime() {
+	let instance = currentInstance;
+	while (instance) {
+		if (instance._appRenderRuntime) return instance._appRenderRuntime;
+		instance = instance.parentInstance;
+	}
+	return scopedAppRenderRuntime;
+}
+/** @internal Preserve root ownership without exposing component hook scope. */
+function withAppRenderRuntime(runtime, fn) {
+	const previous = scopedAppRenderRuntime;
+	scopedAppRenderRuntime = runtime;
+	try {
+		return fn();
+	} finally {
+		scopedAppRenderRuntime = previous;
+	}
+}
+function getCurrentPortalScope() {
+	return currentInstance?.portalScope ?? currentPortalScope;
+}
+function getSignalForInstance(instance) {
+	return getOwnershipSignal(instance.owner);
+}
+/**
+* Get the abort signal for the current component.
+*
+* The signal is guaranteed to be aborted when:
+* - Component unmounts
+* - Navigation occurs (different route)
+* - Parent is destroyed
+*/
+function getSignal() {
+	if (!currentInstance) throw new Error("getSignal() can only be called during component render execution. Ensure you are calling this from inside your component function.");
+	return getSignalForInstance(currentInstance);
+}
+function resetRenderState(instance) {
+	instance.stateIndexCheck = -1;
+	for (const state of instance.stateValues ?? []) if (state) state._hasBeenRead = false;
+	instance._pendingReadSources = void 0;
+	instance._pendingReadSourceVersions = void 0;
+}
+function beginRenderTracking(instance) {
+	instance.renderRevision = (instance.renderRevision ?? 0) + 1;
+	instance._currentRenderToken = nextRenderToken();
+	instance._pendingReadSources = void 0;
+	instance._pendingReadSourceVersions = void 0;
+}
+function clearRenderTracking(instance) {
+	instance._pendingReadSources = void 0;
+	instance._pendingReadSourceVersions = void 0;
+	instance._currentRenderToken = void 0;
+}
+function captureInlineRenderTracking(instance) {
+	return {
+		currentRenderToken: instance._currentRenderToken,
+		pendingReadSources: instance._pendingReadSources,
+		pendingReadSourceVersions: instance._pendingReadSourceVersions
+	};
+}
+function restoreInlineRenderTracking(instance, snapshot) {
+	instance._currentRenderToken = snapshot.currentRenderToken;
+	instance._pendingReadSources = snapshot.pendingReadSources;
+	instance._pendingReadSourceVersions = snapshot.pendingReadSourceVersions;
+}
+function enterRenderScopedComponent(instance, startStateIndex) {
+	return beginComponentScope({
+		instance,
+		stateIndex: startStateIndex
+	});
+}
+function captureInlineComponentScope() {
+	return beginComponentScope({});
+}
+function enterComponentExecutionScope(instance) {
+	return beginComponentScope({
+		instance,
+		stateIndex: 0
+	});
+}
+function enterDomCommitScope(instance) {
+	return beginComponentScope({ instance });
+}
+function clearCurrentComponentScope() {
+	return beginComponentScope({
+		instance: null,
+		portalScope: null
+	});
+}
+function getNextStateIndex() {
+	return stateIndex++;
+}
+function hookOrderGuidance(hookName) {
+	return `The render-scoped hook sequence changed between renders. This can happen when ${hookName}() is called conditionally, or when a conditional subtree skips an outer control boundary through a plain if, ternary, && branch, or loop. Keep render-scoped hooks and their outer control boundaries unconditional. Use <Show> or <Case> with <Match> children for conditional branches, and <For> for changing collections.`;
+}
+function claimHookIndex(instance, hookName) {
+	const index = getNextStateIndex();
+	if (index < instance.stateIndexCheck) throw new Error(`Hook index violation: ${hookName}() call at index ${index}, but previously saw index ${instance.stateIndexCheck}. ` + hookOrderGuidance(hookName));
+	instance.stateIndexCheck = index;
+	const expectedStateIndices = instance.expectedStateIndices ??= [];
+	if (instance.firstRenderComplete) {
+		if (expectedStateIndices[index] !== index) throw new Error(`Hook order violation: ${hookName}() called at index ${index}, but this index was not in the first render's sequence [${expectedStateIndices.join(", ")}]. ` + hookOrderGuidance(hookName));
+	} else expectedStateIndices.push(index);
+	return index;
+}
+function getCurrentStateIndex() {
+	return stateIndex;
+}
+//#endregion
+export { releaseOwnedChild as A, disposeOwnership as C, ownChild as D, getOwnershipSignal as E, ownCleanup as O, detachOwnedChildren as S, getOwnedChildScopes as T, restoreInlineRenderTracking as _, clearCurrentComponentScope as a, attachOwnership as b, enterComponentExecutionScope as c, getCurrentAppRenderRuntime as d, getCurrentComponentInstance as f, resetRenderState as g, getSignal as h, claimHookIndex as i, setOwnedChildScopes as j, registerScopedOwnership as k, enterDomCommitScope as l, getCurrentStateIndex as m, captureInlineComponentScope as n, clearRenderTracking as o, getCurrentPortalScope as p, captureInlineRenderTracking as r, endComponentScope as s, beginRenderTracking as t, enterRenderScopedComponent as u, withAppRenderRuntime as v, drainOwnedCleanup as w, componentRecordPrototype as x, OwnershipRecord as y };

package/dist/{selector-CsKuomw0.js → selector-BSPVkjKP.js}

@@ -1,31 +1,29 @@
-import { t as enqueueRuntimeLane } from "./access-BucjYZcX.js";
-import { i as claimHookIndex, p as getCurrentInstance } from "./component-scope-4I3yEMkb.js";
-import { c as markReadableUsage, f as syncDerivedDependencySubscriptions, l as notifyReadableReaders, o as markReactivePropsDirtySource, p as withDerivedReadTracking, r as clearDerivedDependencySubscriptions, s as markReadableDerivedSubscribersDirty, u as recordReadableRead } from "./readable-Di1fzSwm.js";
-//#region src/runtime/selector-store.ts
+import { b as ScheduledWork, f as requestRuntimeWork } from "./access-CEA2pOry.js";
+import { O as ownCleanup, f as getCurrentComponentInstance, i as claimHookIndex } from "./scope-Cq_iYbTR.js";
+import { _ as markReadableUsage, b as syncDerivedDependencySubscriptions, h as clearDerivedDependencySubscriptions, t as notifyReadableSource, v as recordReadableRead, x as withDerivedReadTracking } from "./notify-DxxuDPeY.js";
+//#region src/runtime/reactivity/selector-store.ts
 const dirtySelectorRecords = /* @__PURE__ */ new Set();
-let hasPendingSelectorFlush = false;
+let selectorWork;
 function markDirtySelectorRecord(record, flush) {
 	record._dirty = true;
-	if (record._scheduled) return;
-	record._scheduled = true;
-	dirtySelectorRecords.add(record);
-	if (hasPendingSelectorFlush) return;
-	hasPendingSelectorFlush = true;
-	enqueueRuntimeLane("derived", flush);
+	if (!record._pending) {
+		record._pending = true;
+		dirtySelectorRecords.add(record);
+	}
+	requestRuntimeWork("derived", selectorWork ??= new ScheduledWork(flush));
 }
 function takeDirtySelectorRecords() {
-	hasPendingSelectorFlush = false;
 	if (dirtySelectorRecords.size === 0) return [];
 	const pending = Array.from(dirtySelectorRecords);
 	dirtySelectorRecords.clear();
 	return pending;
 }
 //#endregion
-//#region src/runtime/selector.ts
+//#region src/runtime/reactivity/selector.ts
 const selectorCells = /* @__PURE__ */ new WeakMap();
 const selectorRecords = /* @__PURE__ */ new WeakMap();
 function getSelectorStore(instance) {
-	const generation = instance._ownershipGeneration;
+	const generation = instance.owner.identity;
 	let store = selectorCells.get(generation);
 	if (!store) {
 		store = /* @__PURE__ */ new Map();
@@ -39,7 +37,7 @@ function markSelectorRecordDirty(record) {
 function flushDirtySelectorRecords() {
 	let failures = null;
 	for (const record of takeDirtySelectorRecords()) {
-		record._scheduled = false;
+		record._pending = false;
 		if (!record._dirty) continue;
 		try {
 			recomputeSelectorSourceRecord(record, true);
@@ -93,7 +91,7 @@ function createSelectorSourceRecord(source) {
 		_value: void 0,
 		_hasValue: false,
 		_dirty: true,
-		_scheduled: false,
+		_pending: false,
 		_evaluating: false,
 		_sources: /* @__PURE__ */ new Set(),
 		_lanes: /* @__PURE__ */ new Map(),
@@ -101,7 +99,7 @@ function createSelectorSourceRecord(source) {
 			markSelectorRecordDirty(record);
 		},
 		_cleanup: () => {
-			record._scheduled = false;
+			record._pending = false;
 			record._dirty = false;
 			record._hasValue = false;
 			record._evaluating = false;
@@ -147,9 +145,7 @@ function createSelectorLane(record, equals) {
 	return lane;
 }
 function notifySelectorSource(source) {
-	markReadableDerivedSubscribersDirty(source, true);
-	markReactivePropsDirtySource(source);
-	notifyReadableReaders(source);
+	notifyReadableSource(source, { skipCurrentDerivedSubscriber: true });
 }
 function notifyAllSelectorSources(lane) {
 	for (const source of lane._primitiveCandidates.values()) notifySelectorSource(source);
@@ -237,7 +233,7 @@ function createSelectorHook(instance, generation, store, hookIndex, source, equa
 		const sourceRef = getCandidateSource(lane, candidate);
 		recordReadableRead(sourceRef);
 		if (record._evaluating) throw new Error("selector() cannot read itself recursively");
-		const current = record._dirty || !record._hasValue ? recomputeSelectorSourceRecord(record, record._scheduled) : record._value;
+		const current = record._dirty || !record._hasValue ? recomputeSelectorSourceRecord(record, record._pending) : record._value;
 		return lane._equals(current, candidate);
 	};
 	hook._owner = instance;
@@ -259,10 +255,13 @@ function createSelectorHook(instance, generation, store, hookIndex, source, equa
 		detachSelectorHookBinding(hook);
 	};
 	attachSelectorHookBinding(hook, source, equals);
-	(instance.cleanupFns ??= []).push(() => {
-		hook._cleanup();
-		store.delete(hookIndex);
-		if (store.size === 0 && selectorCells.get(generation) === store) selectorCells.delete(generation);
+	ownCleanup(instance.owner, () => {
+		try {
+			hook._cleanup();
+		} finally {
+			store.delete(hookIndex);
+			if (store.size === 0 && selectorCells.get(generation) === store) selectorCells.delete(generation);
+		}
 	});
 	return hook;
 }
@@ -287,7 +286,7 @@ function getOrCreateSelectorHook(instance, hookIndex, source, equals) {
 		} else ensureSelectorHookBinding(existing);
 		return existing;
 	}
-	const created = createSelectorHook(instance, instance._ownershipGeneration, store, hookIndex, source, equals);
+	const created = createSelectorHook(instance, instance.owner.identity, store, hookIndex, source, equals);
 	store.set(hookIndex, created);
 	return created;
 }
@@ -301,7 +300,7 @@ function getOrCreateSelectorHook(instance, hookIndex, source, equals) {
 */
 function selector(source, equals = Object.is) {
 	markReadableUsage(source);
-	const instance = getCurrentInstance();
+	const instance = getCurrentComponentInstance();
 	if (!instance) throw new Error("selector() can only be called during component render execution. Move selector() calls to the top level of your component function.");
 	const hook = getOrCreateSelectorHook(instance, claimHookIndex(instance, "selector"), source, equals);
 	if (!hook._record) throw new Error("selector() record binding was not established.");

package/dist/{shared-CYBH3F8I.js → shared-kU8yvryp.js}

@@ -1,13 +1,10 @@
-import { l as notifyReadableReaders, o as markReactivePropsDirtySource, s as markReadableDerivedSubscribersDirty } from "./readable-Di1fzSwm.js";
+import { t as notifyReadableSource } from "./notify-DxxuDPeY.js";
 //#region src/data/shared.ts
 function createReadableSource() {
 	return (() => void 0);
 }
-function notifySource(source) {
-	markReadableDerivedSubscribersDirty(source);
-	markReactivePropsDirtySource(source);
-	notifyReadableReaders(source);
-}
+/** Re-exported so data cells keep their existing name for the shared fan-out. */
+const notifySource = notifyReadableSource;
 function isAbortError(error, signal) {
 	return signal.aborted || error instanceof Error && error.name === "AbortError" || typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError";
 }

package/dist/{snapshot-source-BB42xgwb.js → snapshot-source-An4iKajG.js}

@@ -1,4 +1,4 @@
-//#region src/runtime/snapshot-source.ts
+//#region src/runtime/reactivity/snapshot-source.ts
 const SNAPSHOT_SOURCE_BRAND = Symbol.for("__ASKR_SNAPSHOT_SOURCE__");
 function brandSnapshotSource(value) {
 	Object.defineProperty(value, SNAPSHOT_SOURCE_BRAND, {

package/dist/ssg/index.d.ts

@@ -1,14 +1,33 @@
-import { An as SSRStyleRegistrationValidation, Bt as RoutePathParams, Dn as DocumentRenderer, En as DocumentRenderContext, Kt as RouteRegistry, Mt as RouteHandler, Rt as RouteOptions, Tn as DocumentRenderArgs, Vt as RoutePolicy } from "../index-Dgjbo2gU.js";
-import { AuthRequirement } from "@askrjs/auth";
-import "node:fs/promises";
-//#region src/ssg/types.d.ts
+import {
+  SSRStyleRegistrationValidation,
+  RoutePathParams,
+  DocumentRenderer,
+  DocumentRenderContext,
+  RouteRegistry,
+  RouteHandler,
+  RouteOptions,
+  DocumentRenderArgs,
+  RoutePolicy,
+} from '../core.js';
+import { AuthRequirement } from '@askrjs/auth';
+import 'node:fs/promises';
 /** Whether an SSG run rebuilds every route (`full`) or only changed ones (`incremental`). */
 type SSGMode = 'full' | 'incremental';
 /** Outcome of generating a single route's static HTML. */
 type RouteRenderStatus = 'success' | 'error' | 'skipped' | 'removed';
 /** Why a route was rendered, skipped, or removed during generation. */
-type RouteRenderReason = 'full' | 'changed-key' | 'changed-route' | 'new-route' | 'no-keys' | 'unchanged' | 'deleted' | 'runtime-only';
-type RouteConfigParams<Path extends string> = string extends Path ? Record<string, string> : RoutePathParams<Path>;
+type RouteRenderReason =
+  | 'full'
+  | 'changed-key'
+  | 'changed-route'
+  | 'new-route'
+  | 'no-keys'
+  | 'unchanged'
+  | 'deleted'
+  | 'runtime-only';
+type RouteConfigParams<Path extends string> = string extends Path
+  ? Record<string, string>
+  : RoutePathParams<Path>;
 /**
  * Route config accepted by SSG.
  *
@@ -49,7 +68,9 @@ interface RouteConfig<Path extends string = string> {
    * });
    * ```
    */
-  entries?: () => Array<RouteConfigParams<Path>> | Promise<Array<RouteConfigParams<Path>>>;
+  entries?: () =>
+    | Array<RouteConfigParams<Path>>
+    | Promise<Array<RouteConfigParams<Path>>>;
 }
 interface SSGBaseOptions {
   /** Output directory for generated HTML files */
@@ -77,10 +98,11 @@ interface SSGAssetSource {
   to?: string;
 }
 /** Options for createStaticGen */
-type SSGOptions<_TRoutes extends readonly RouteConfig[] = RouteConfig[]> = SSGBaseOptions & {
-  /** Explicit route registry captured with `createRouteRegistry()`. */
-  registry: RouteRegistry;
-};
+type SSGOptions<_TRoutes extends readonly RouteConfig[] = RouteConfig[]> =
+  SSGBaseOptions & {
+    /** Explicit route registry captured with `createRouteRegistry()`. */
+    registry: RouteRegistry;
+  };
 /** Options for a single generation run */
 interface SSGGenerateOptions {
   /** Generation mode */
@@ -206,8 +228,6 @@ interface DiscoveredResources {
     dependencies: string[];
   };
 }
-//#endregion
-//#region src/ssg/create-static-gen.d.ts
 /**
  * Create a Static Site Generator
  *
@@ -250,5 +270,21 @@ declare function createStaticGen(options: SSGOptions): {
    */
   getResult(): SSGResult | null;
 };
-//#endregion
-export { type DiscoveredResources, type DocumentRenderArgs, type DocumentRenderContext, type DocumentRenderer, type RouteConfig, type RouteRenderReason, type RouteRenderResult, type RouteRenderStatus, type SSGAssetSource, type SSGGenerateOptions, type SSGMetadata, type SSGMode, type SSGOptions, type SSGResult, type SSRStyleRegistrationValidation, createStaticGen };
+export {
+  type DiscoveredResources,
+  type DocumentRenderArgs,
+  type DocumentRenderContext,
+  type DocumentRenderer,
+  type RouteConfig,
+  type RouteRenderReason,
+  type RouteRenderResult,
+  type RouteRenderStatus,
+  type SSGAssetSource,
+  type SSGGenerateOptions,
+  type SSGMetadata,
+  type SSGMode,
+  type SSGOptions,
+  type SSGResult,
+  type SSRStyleRegistrationValidation,
+  createStaticGen,
+};