@askrjs/askr 0.0.27 → 0.0.29

package/dist/runtime/state.d.ts

@@ -1,16 +1,6 @@
-/**
- * State primitive for Askr components
- * Optimized for minimal overhead and fast updates
- *
- * INVARIANTS ENFORCED:
- * - state() only callable during component render (currentInstance exists)
- * - state() called at top-level only (indices must be monotonically increasing)
- * - state values persist across re-renders (stored in stateValues array)
- * - state.set() cannot be called during render (causes infinite loops)
- * - state.set() always enqueues through scheduler (never direct mutation)
- * - state.set() callback (notifyUpdate) always available
- */
-import { type ComponentInstance } from './component';
+import { ReadableSource } from "./readable.js";
+
+//#region src/runtime/state.d.ts
 /**
  * State value holder - callable to read, has set method to update
  * @example
@@ -18,13 +8,11 @@ import { type ComponentInstance } from './component';
  * count();           // read: 0
  * count.set(1);      // write: triggers re-render
  */
-export interface State<T> {
-    (): T;
-    set(value: T): void;
-    set(updater: (prev: T) => T): void;
-    [Symbol.iterator](): Iterator<State<T> | State<T>['set']>;
-    _hasBeenRead?: boolean;
-    _readers?: Map<ComponentInstance, number>;
+interface State<T> extends ReadableSource<T> {
+  (): T;
+  set(value: T): void;
+  set(updater: (prev: T) => T): void;
+  [Symbol.iterator](): Iterator<State<T> | State<T>['set']>;
 }
 /**
  * Creates a local state value for a component
@@ -52,5 +40,7 @@ export interface State<T> {
  * }
  * ```
  */
-export declare function state<T>(initialValue: T): State<T>;
+declare function state<T>(initialValue: T): State<T>;
+//#endregion
+export { State, state };
 //# sourceMappingURL=state.d.ts.map

package/dist/runtime/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/runtime/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,aAAa,CAAC;AAIrB;;;;;;GAMG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC;IACtB,IAAI,CAAC,CAAC;IACN,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACpB,GAAG,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IACnC,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1D,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,GAAG,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAwElD"}
+{"version":3,"file":"state.d.ts","names":[],"sources":["../../src/runtime/state.ts"],"mappings":";;;;;;;;;;UAmCiB,KAAA,YAAiB,cAAA,CAAe,CAAA;EAAA,IAC3C,CAAA;EACJ,GAAA,CAAI,KAAA,EAAO,CAAA;EACX,GAAA,CAAI,OAAA,GAAU,IAAA,EAAM,CAAA,KAAM,CAAA;EAAA,CACzB,MAAA,CAAO,QAAP,KAAoB,QAAA,CAAS,KAAA,CAAM,CAAA,IAAK,KAAA,CAAM,CAAA;AAAA;;;;;;;;;;;;;;;;AA6BjD;;;;;;;;;;;iBAAgB,KAAA,GAAA,CAAS,YAAA,EAAc,CAAA,GAAI,KAAA,CAAM,CAAA"}

package/dist/runtime/state.js

@@ -1 +1,99 @@
-import{globalScheduler as i}from"./scheduler.js";import{getCurrentInstance as c,getNextStateIndex as h}from"./component.js";import{invariant as m}from"../dev/invariant.js";import{isBulkCommitActive as w}from"./fastlane.js";function _(d){const e=c();if(!e)throw new Error("state() can only be called during component render execution. Move state() calls to the top level of your component function.");const t=h(),r=e.stateValues;if(t<e.stateIndexCheck)throw new Error(`State index violation: state() call at index ${t}, but previously saw index ${e.stateIndexCheck}. This happens when state() is called conditionally (inside if/for/etc). Move all state() calls to the top level of your component function, before any conditionals.`);if(m(t>=e.stateIndexCheck,"[State] State indices must increase monotonically"),e.stateIndexCheck=t,e.firstRenderComplete){if(!e.expectedStateIndices.includes(t))throw new Error(`Hook order violation: state() called at index ${t}, but this index was not in the first render's sequence [${e.expectedStateIndices.join(", ")}]. This usually means state() is inside a conditional or loop. Move all state() calls to the top level of your component function.`)}else e.expectedStateIndices.push(t);if(r[t]){const o=r[t];if(o._owner!==e)throw new Error(`State ownership violation: state() called at index ${t} is owned by a different component instance. State ownership is positional and immutable.`);return o}const n=g(d,e);return r[t]=n,n}function g(d,e){let t=d;const r=new Map;function n(){n._hasBeenRead=!0;const o=c();return o&&o._currentRenderToken!==void 0&&(o._pendingReadStates||(o._pendingReadStates=new Set),o._pendingReadStates.add(n)),t}return n._readers=r,n._owner=e,n.set=o=>{if(c()!==null)throw new Error("[Askr] state.set() cannot be called during component render. State mutations during render break the actor model and cause infinite loops. Move state updates to event handlers or use conditional rendering instead.");let s;if(typeof o=="function"?s=o(t):s=o,Object.is(t,s))return;if(w()){t=s;return}t=s;const l=n._readers;if(l){for(const[a,p]of l)if(a.lastRenderToken===p&&!a.hasPendingUpdate){a.hasPendingUpdate=!0;const f=a._pendingFlushTask;f?i.enqueue(f):i.enqueue(()=>{a.hasPendingUpdate=!1,a.notifyUpdate?.()})}}const u=l?.get(e);if(u!==void 0&&e.lastRenderToken===u&&!e.hasPendingUpdate){e.hasPendingUpdate=!0;const a=e._pendingFlushTask;a?i.enqueue(a):i.enqueue(()=>{e.hasPendingUpdate=!1,e.notifyUpdate?.()})}},n[Symbol.iterator]=function*(){yield n,yield n.set},n}export{_ as state};
+import { globalScheduler } from "./scheduler.js";
+import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead } from "./readable.js";
+import { isBulkCommitActive } from "./fastlane.js";
+import { claimHookIndex, getCurrentInstance } from "./component.js";
+//#region src/runtime/state.ts
+/**
+* State primitive for Askr components
+* Optimized for minimal overhead and fast updates
+*
+* INVARIANTS ENFORCED:
+* - state() only callable during component render (currentInstance exists)
+* - state() called at top-level only (indices must be monotonically increasing)
+* - state values persist across re-renders (stored in stateValues array)
+* - state.set() cannot be called during render (causes infinite loops)
+* - state.set() always enqueues through scheduler (never direct mutation)
+* - state.set() callback (notifyUpdate) always available
+*/
+/**
+* Creates a local state value for a component
+* Optimized for:
+* - O(1) read performance
+* - Minimal allocation per state
+* - Fast scheduler integration
+*
+* IMPORTANT: state() must be called during component render execution.
+* It captures the current component instance from context.
+* Calling outside a component function will throw an error.
+*
+* @example
+* ```ts
+* // ✅ Correct: called during render
+* export function Counter() {
+*   const count = state(0);
+*   return { type: 'button', children: [count()] };
+* }
+*
+* // ❌ Wrong: called outside component
+* const count = state(0);
+* export function BadComponent() {
+*   return { type: 'div' };
+* }
+* ```
+*/
+function state(initialValue) {
+	const instance = getCurrentInstance();
+	if (!instance) throw new Error("state() can only be called during component render execution. Move state() calls to the top level of your component function.");
+	const index = claimHookIndex(instance, "state");
+	const stateValues = instance.stateValues;
+	if (stateValues[index]) {
+		const existing = stateValues[index];
+		if (existing._owner !== instance) throw new Error(`State ownership violation: state() called at index ${index} is owned by a different component instance. State ownership is positional and immutable.`);
+		return existing;
+	}
+	const cell = createStateCell(initialValue, instance);
+	stateValues[index] = cell;
+	return cell;
+}
+/**
+* Internal helper: create the backing state cell (value + readers + set semantics)
+* This extraction makes it easier to later split hook wiring from storage.
+*/
+function createStateCell(initialValue, instance) {
+	let value = initialValue;
+	let pendingNotifyFlushVersion = -1;
+	const readers = /* @__PURE__ */ new Map();
+	function read() {
+		read._hasBeenRead = true;
+		recordReadableRead(read);
+		return value;
+	}
+	read._readers = readers;
+	read._owner = instance;
+	read.set = (newValueOrUpdater) => {
+		if (getCurrentInstance() !== null) throw new Error("[Askr] state.set() cannot be called during component render. State mutations during render break the actor model and cause infinite loops. Move state updates to event handlers or use conditional rendering instead.");
+		let newValue;
+		if (typeof newValueOrUpdater === "function") newValue = newValueOrUpdater(value);
+		else newValue = newValueOrUpdater;
+		if (Object.is(value, newValue)) return;
+		if (isBulkCommitActive()) {
+			value = newValue;
+			return;
+		}
+		value = newValue;
+		markReadableDerivedSubscribersDirty(read);
+		markReactivePropsDirtySource(read);
+		const flushVersion = globalScheduler.getFlushVersion();
+		if (pendingNotifyFlushVersion === flushVersion && !globalScheduler.isExecuting()) return;
+		pendingNotifyFlushVersion = notifyReadableReaders(read) && !globalScheduler.isExecuting() ? flushVersion : -1;
+	};
+	read[Symbol.iterator] = function* () {
+		yield read;
+		yield read.set;
+	};
+	return read;
+}
+//#endregion
+export { state };
+
+//# sourceMappingURL=state.js.map

package/dist/runtime/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","names":[],"sources":["../../src/runtime/state.ts"],"sourcesContent":["/**\n * State primitive for Askr components\n * Optimized for minimal overhead and fast updates\n *\n * INVARIANTS ENFORCED:\n * - state() only callable during component render (currentInstance exists)\n * - state() called at top-level only (indices must be monotonically increasing)\n * - state values persist across re-renders (stored in stateValues array)\n * - state.set() cannot be called during render (causes infinite loops)\n * - state.set() always enqueues through scheduler (never direct mutation)\n * - state.set() callback (notifyUpdate) always available\n */\n\nimport { globalScheduler } from './scheduler';\nimport {\n  claimHookIndex,\n  getCurrentInstance,\n  type ComponentInstance,\n} from './component';\nimport { isBulkCommitActive } from './fastlane';\nimport {\n  recordReadableRead,\n  type ReadableSource,\n  markReadableDerivedSubscribersDirty,\n  markReactivePropsDirtySource,\n  notifyReadableReaders,\n} from './readable';\n\n/**\n * State value holder - callable to read, has set method to update\n * @example\n * const count = state(0);\n * count();           // read: 0\n * count.set(1);      // write: triggers re-render\n */\nexport interface State<T> extends ReadableSource<T> {\n  (): T;\n  set(value: T): void;\n  set(updater: (prev: T) => T): void;\n  [Symbol.iterator](): Iterator<State<T> | State<T>['set']>; // Allows destructuring: const [get, set] = state(0)\n}\n\n/**\n * Creates a local state value for a component\n * Optimized for:\n * - O(1) read performance\n * - Minimal allocation per state\n * - Fast scheduler integration\n *\n * IMPORTANT: state() must be called during component render execution.\n * It captures the current component instance from context.\n * Calling outside a component function will throw an error.\n *\n * @example\n * ```ts\n * // ✅ Correct: called during render\n * export function Counter() {\n *   const count = state(0);\n *   return { type: 'button', children: [count()] };\n * }\n *\n * // ❌ Wrong: called outside component\n * const count = state(0);\n * export function BadComponent() {\n *   return { type: 'div' };\n * }\n * ```\n */\nexport function state<T>(initialValue: T): State<T> {\n  // INVARIANT: state() must be called during component render\n  const instance = getCurrentInstance();\n  if (!instance) {\n    throw new Error(\n      'state() can only be called during component render execution. ' +\n        'Move state() calls to the top level of your component function.'\n    );\n  }\n\n  const index = claimHookIndex(instance, 'state');\n  const stateValues = instance.stateValues;\n\n  // INVARIANT: Reuse existing state if it exists (fast path on re-renders)\n  // This ensures state identity and persistence and enforces ownership stability\n  if (stateValues[index]) {\n    const existing = stateValues[index] as State<T> & {\n      _owner?: ComponentInstance;\n    };\n    // Ownership must be stable: the state cell belongs to the instance that\n    // created it and must never change. This checks for accidental reuse.\n    if (existing._owner !== instance) {\n      throw new Error(\n        `State ownership violation: state() called at index ${index} is owned by a different component instance. ` +\n          `State ownership is positional and immutable.`\n      );\n    }\n    return existing as State<T>;\n  }\n\n  // Create new state (slow path, only on first render) — delegated to helper\n  const cell = createStateCell(initialValue, instance);\n\n  // INVARIANT: Store state in instance for persistence across renders\n  stateValues[index] = cell;\n\n  return cell;\n}\n\n/**\n * Internal helper: create the backing state cell (value + readers + set semantics)\n * This extraction makes it easier to later split hook wiring from storage.\n */\nfunction createStateCell<T>(\n  initialValue: T,\n  instance: ComponentInstance\n): State<T> {\n  let value = initialValue;\n  let pendingNotifyFlushVersion = -1;\n\n  // Per-state reader map: component -> last-committed render token\n  const readers = new Map<ComponentInstance, number>();\n\n  // Use a function as the state object (callable directly)\n  function read(): T {\n    (read as State<T>)._hasBeenRead = true;\n    recordReadableRead(read as State<T>);\n\n    return value;\n  }\n\n  // Attach the readers map to the callable so other runtime parts can access it\n  (read as State<T>)._readers = readers;\n\n  // Record explicit ownership of this state cell. Ownership is the component\n  // instance that created the state cell and must never change for the life\n  // of the cell. We expose this for runtime invariant checks/tests.\n  (read as State<T> & { _owner?: ComponentInstance })._owner = instance;\n\n  // Attach set method directly to function\n  read.set = (newValueOrUpdater: T | ((prev: T) => T)): void => {\n    // INVARIANT: State cannot be mutated during component render\n    // (when currentInstance is non-null). It must be scheduled for consistency.\n    const currentInst = getCurrentInstance();\n    if (currentInst !== null) {\n      throw new Error(\n        `[Askr] state.set() cannot be called during component render. ` +\n          `State mutations during render break the actor model and cause infinite loops. ` +\n          `Move state updates to event handlers or use conditional rendering instead.`\n      );\n    }\n\n    // Compute new value if an updater was provided\n    let newValue: T;\n    if (typeof newValueOrUpdater === 'function') {\n      // Note: function-valued state cannot be set directly via a function argument;\n      // such an argument is treated as a functional updater (this follows the common\n      // convention from other libraries). If you need to store a function as state,\n      // wrap it in an object.\n      const updater = newValueOrUpdater as (prev: T) => T;\n      newValue = updater(value);\n    } else {\n      newValue = newValueOrUpdater as T;\n    }\n\n    // Skip work if value didn't change\n    if (Object.is(value, newValue)) return;\n\n    // If a bulk commit is active, update backing value only and DO NOT notify or enqueue.\n    // Bulk commits must be side-effect silent with respect to runtime notifications.\n    if (isBulkCommitActive()) {\n      // In bulk commit mode we must be side-effect free: update backing\n      // value only and do not notify, enqueue, or log.\n      value = newValue;\n      return;\n    }\n\n    // INVARIANT: Update the value\n    value = newValue;\n\n    markReadableDerivedSubscribersDirty(read as State<T>);\n    markReactivePropsDirtySource(read as State<T>);\n\n    // notifyUpdate may be temporarily unavailable (e.g. during hydration).\n    // We intentionally avoid logging here to keep the state mutation path\n    // side-effect free. The scheduler will process updates when the system\n    // is stable.\n    const flushVersion = globalScheduler.getFlushVersion();\n    const canSkipNotifyPass =\n      pendingNotifyFlushVersion === flushVersion &&\n      !globalScheduler.isExecuting();\n\n    if (canSkipNotifyPass) {\n      return;\n    }\n\n    // After value change, notify only components that *read* this state in their last committed render.\n    const didScheduleUpdate = notifyReadableReaders(read as State<T>);\n\n    pendingNotifyFlushVersion =\n      didScheduleUpdate && !globalScheduler.isExecuting() ? flushVersion : -1;\n  };\n\n  // Allow destructuring assignment: const [get, set] = state(0);\n  // The state function is iterable and yields the getter then the setter\n  (\n    read as unknown as {\n      [Symbol.iterator]?: () => Iterator<State<T> | State<T>['set']>;\n    }\n  )[Symbol.iterator] = function* (): Generator<\n    State<T> | State<T>['set'],\n    void,\n    unknown\n  > {\n    yield read;\n    yield read.set;\n  };\n\n  return read as State<T>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,SAAgB,MAAS,cAA2B;CAElD,MAAM,WAAW,oBAAoB;AACrC,KAAI,CAAC,SACH,OAAM,IAAI,MACR,gIAED;CAGH,MAAM,QAAQ,eAAe,UAAU,QAAQ;CAC/C,MAAM,cAAc,SAAS;AAI7B,KAAI,YAAY,QAAQ;EACtB,MAAM,WAAW,YAAY;AAK7B,MAAI,SAAS,WAAW,SACtB,OAAM,IAAI,MACR,sDAAsD,MAAM,2FAE7D;AAEH,SAAO;;CAIT,MAAM,OAAO,gBAAgB,cAAc,SAAS;AAGpD,aAAY,SAAS;AAErB,QAAO;;;;;;AAOT,SAAS,gBACP,cACA,UACU;CACV,IAAI,QAAQ;CACZ,IAAI,4BAA4B;CAGhC,MAAM,0BAAU,IAAI,KAAgC;CAGpD,SAAS,OAAU;AAChB,OAAkB,eAAe;AAClC,qBAAmB,KAAiB;AAEpC,SAAO;;AAIR,MAAkB,WAAW;AAK7B,MAAmD,SAAS;AAG7D,MAAK,OAAO,sBAAkD;AAI5D,MADoB,oBAChB,KAAgB,KAClB,OAAM,IAAI,MACR,wNAGD;EAIH,IAAI;AACJ,MAAI,OAAO,sBAAsB,WAM/B,YAAW,kBAAQ,MAAM;MAEzB,YAAW;AAIb,MAAI,OAAO,GAAG,OAAO,SAAS,CAAE;AAIhC,MAAI,oBAAoB,EAAE;AAGxB,WAAQ;AACR;;AAIF,UAAQ;AAER,sCAAoC,KAAiB;AACrD,+BAA6B,KAAiB;EAM9C,MAAM,eAAe,gBAAgB,iBAAiB;AAKtD,MAHE,8BAA8B,gBAC9B,CAAC,gBAAgB,aAAa,CAG9B;AAMF,8BAF0B,sBAAsB,KAG9C,IAAqB,CAAC,gBAAgB,aAAa,GAAG,eAAe;;AAMvE,MAGA,OAAO,YAAY,aAInB;AACA,QAAM;AACN,QAAM,KAAK;;AAGb,QAAO"}

package/dist/ssg/batch-render.d.ts

@@ -0,0 +1,16 @@
+import { RouteConfig, RouteRenderResult } from "./types.js";
+import { SSRData } from "../common/ssr.js";
+
+//#region src/ssg/batch-render.d.ts
+interface BatchRenderOptions {
+  seed?: number;
+  dataMap?: Record<string, SSRData>;
+  concurrency?: number;
+}
+/**
+ * Render multiple routes in parallel with error handling
+ */
+declare function batchRenderRoutes(routes: RouteConfig[], options?: BatchRenderOptions): Promise<RouteRenderResult[]>;
+//#endregion
+export { batchRenderRoutes };
+//# sourceMappingURL=batch-render.d.ts.map

package/dist/ssg/batch-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-render.d.ts","names":[],"sources":["../../src/ssg/batch-render.ts"],"mappings":";;;;UAWU,kBAAA;EACR,IAAA;EACA,OAAA,GAAU,MAAA,SAAe,OAAA;EACzB,WAAA;AAAA;;;;iBAMoB,iBAAA,CACpB,MAAA,EAAQ,WAAA,IACR,OAAA,GAAS,kBAAA,GACR,OAAA,CAAQ,iBAAA"}

package/dist/ssg/batch-render.js

@@ -0,0 +1,84 @@
+import { renderResolvedToStringSync } from "../ssr/index.js";
+import { getOutputFilePath, interpolateRoutePath } from "./route-utils.js";
+//#region src/ssg/batch-render.ts
+/**
+* Batch rendering of multiple routes for SSG
+*/
+/**
+* Render multiple routes in parallel with error handling
+*/
+async function batchRenderRoutes(routes, options = {}) {
+	const { seed = 12345, dataMap = {}, concurrency = 1 } = options;
+	const workerCount = Math.max(1, Math.min(concurrency, routes.length || 1));
+	const results = [];
+	results.length = routes.length;
+	let nextIndex = 0;
+	const renderOne = async (route) => {
+		const startTime = performance.now();
+		const url = interpolateRoutePath(route.path, route.params);
+		const baseData = dataMap[route.path] ?? dataMap[url] ?? {};
+		const mergedHandler = route.handler ? route.handler : (params, ctx) => {
+			const component = route.component;
+			return component({
+				...route.props,
+				...params
+			}, ctx);
+		};
+		try {
+			const html = renderResolvedToStringSync({
+				url,
+				routes: [{
+					path: route.path,
+					handler: mergedHandler,
+					namespace: route.namespace
+				}],
+				handler: mergedHandler,
+				params: route.params,
+				options: {
+					seed,
+					data: baseData
+				}
+			});
+			const duration = performance.now() - startTime;
+			return {
+				path: url,
+				filePath: getOutputFilePath(url),
+				html,
+				fileSize: Buffer.byteLength(html, "utf8"),
+				renderDuration: Math.round(duration),
+				resourceCount: Object.keys(baseData).length,
+				status: "success",
+				reason: "full",
+				written: false
+			};
+		} catch (error) {
+			const duration = performance.now() - startTime;
+			return {
+				path: url,
+				filePath: getOutputFilePath(url),
+				html: "",
+				fileSize: 0,
+				renderDuration: Math.round(duration),
+				resourceCount: Object.keys(baseData).length,
+				status: "error",
+				reason: "full",
+				written: false,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+	};
+	const worker = async () => {
+		while (true) {
+			const current = nextIndex;
+			nextIndex += 1;
+			if (current >= routes.length) return;
+			results[current] = await renderOne(routes[current]);
+		}
+	};
+	await Promise.all(Array.from({ length: workerCount }, () => worker()));
+	return results;
+}
+//#endregion
+export { batchRenderRoutes };
+
+//# sourceMappingURL=batch-render.js.map

package/dist/ssg/batch-render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-render.js","names":[],"sources":["../../src/ssg/batch-render.ts"],"sourcesContent":["/**\n * Batch rendering of multiple routes for SSG\n */\n\nimport { renderResolvedToStringSync } from '../ssr';\nimport type { RouteConfig, RouteRenderResult } from './types';\nimport type { RouteHandler } from '../common/router';\nimport type { ComponentFunction } from '../common/component';\nimport type { SSRData } from '../common/ssr';\nimport { getOutputFilePath, interpolateRoutePath } from './route-utils';\n\ninterface BatchRenderOptions {\n  seed?: number;\n  dataMap?: Record<string, SSRData>;\n  concurrency?: number;\n}\n\n/**\n * Render multiple routes in parallel with error handling\n */\nexport async function batchRenderRoutes(\n  routes: RouteConfig[],\n  options: BatchRenderOptions = {}\n): Promise<RouteRenderResult[]> {\n  const { seed = 12345, dataMap = {}, concurrency = 1 } = options;\n\n  const workerCount = Math.max(1, Math.min(concurrency, routes.length || 1));\n  const results: RouteRenderResult[] = [];\n  results.length = routes.length;\n  let nextIndex = 0;\n\n  const renderOne = async (route: RouteConfig): Promise<RouteRenderResult> => {\n    const startTime = performance.now();\n    const url = interpolateRoutePath(route.path, route.params);\n    const baseData = dataMap[route.path] ?? dataMap[url] ?? {};\n\n    const mergedHandler: RouteHandler = route.handler\n      ? route.handler\n      : (params, ctx?: unknown) => {\n          const component = route.component as ComponentFunction;\n          return component(\n            { ...route.props, ...params },\n            ctx as { signal: AbortSignal; ssr?: unknown }\n          );\n        };\n\n    try {\n      const routeEntry = {\n        path: route.path,\n        handler: mergedHandler,\n        namespace: route.namespace,\n      };\n\n      const html = renderResolvedToStringSync({\n        url,\n        routes: [routeEntry],\n        handler: mergedHandler,\n        params: route.params,\n        options: {\n          seed,\n          data: baseData,\n        },\n      });\n\n      const duration = performance.now() - startTime;\n      return {\n        path: url,\n        filePath: getOutputFilePath(url),\n        html,\n        fileSize: Buffer.byteLength(html, 'utf8'),\n        renderDuration: Math.round(duration),\n        resourceCount: Object.keys(baseData).length,\n        status: 'success',\n        reason: 'full',\n        written: false,\n      };\n    } catch (error) {\n      const duration = performance.now() - startTime;\n      return {\n        path: url,\n        filePath: getOutputFilePath(url),\n        html: '',\n        fileSize: 0,\n        renderDuration: Math.round(duration),\n        resourceCount: Object.keys(baseData).length,\n        status: 'error',\n        reason: 'full',\n        written: false,\n        error: error instanceof Error ? error.message : String(error),\n      };\n    }\n  };\n\n  const worker = async () => {\n    while (true) {\n      const current = nextIndex;\n      nextIndex += 1;\n      if (current >= routes.length) return;\n      results[current] = await renderOne(routes[current]);\n    }\n  };\n\n  await Promise.all(Array.from({ length: workerCount }, () => worker()));\n  return results;\n}\n"],"mappings":";;;;;;;;;AAoBA,eAAsB,kBACpB,QACA,UAA8B,EAAE,EACF;CAC9B,MAAM,EAAE,OAAO,OAAO,UAAU,EAAE,EAAE,cAAc,MAAM;CAExD,MAAM,cAAc,KAAK,IAAI,GAAG,KAAK,IAAI,aAAa,OAAO,UAAU,EAAE,CAAC;CAC1E,MAAM,UAA+B,EAAE;AACvC,SAAQ,SAAS,OAAO;CACxB,IAAI,YAAY;CAEhB,MAAM,YAAY,OAAO,UAAmD;EAC1E,MAAM,YAAY,YAAY,KAAK;EACnC,MAAM,MAAM,qBAAqB,MAAM,MAAM,MAAM,OAAO;EAC1D,MAAM,WAAW,QAAQ,MAAM,SAAS,QAAQ,QAAQ,EAAE;EAE1D,MAAM,gBAA8B,MAAM,UACtC,MAAM,WACL,QAAQ,QAAkB;GACzB,MAAM,YAAY,MAAM;AACxB,UAAO,UACL;IAAE,GAAG,MAAM;IAAO,GAAG;IAAQ,EAC7B,IACD;;AAGP,MAAI;GAOF,MAAM,OAAO,2BAA2B;IACtC;IACA,QAAQ,CAAC;KAPT,MAAM,MAAM;KACZ,SAAS;KACT,WAAW,MAAM;KAKR,CAAW;IACpB,SAAS;IACT,QAAQ,MAAM;IACd,SAAS;KACP;KACA,MAAM;KACP;IACF,CAAC;GAEF,MAAM,WAAW,YAAY,KAAK,GAAG;AACrC,UAAO;IACL,MAAM;IACN,UAAU,kBAAkB,IAAI;IAChC;IACA,UAAU,OAAO,WAAW,MAAM,OAAO;IACzC,gBAAgB,KAAK,MAAM,SAAS;IACpC,eAAe,OAAO,KAAK,SAAS,CAAC;IACrC,QAAQ;IACR,QAAQ;IACR,SAAS;IACV;WACM,OAAO;GACd,MAAM,WAAW,YAAY,KAAK,GAAG;AACrC,UAAO;IACL,MAAM;IACN,UAAU,kBAAkB,IAAI;IAChC,MAAM;IACN,UAAU;IACV,gBAAgB,KAAK,MAAM,SAAS;IACpC,eAAe,OAAO,KAAK,SAAS,CAAC;IACrC,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;IAC9D;;;CAIL,MAAM,SAAS,YAAY;AACzB,SAAO,MAAM;GACX,MAAM,UAAU;AAChB,gBAAa;AACb,OAAI,WAAW,OAAO,OAAQ;AAC9B,WAAQ,WAAW,MAAM,UAAU,OAAO,SAAS;;;AAIvD,OAAM,QAAQ,IAAI,MAAM,KAAK,EAAE,QAAQ,aAAa,QAAQ,QAAQ,CAAC,CAAC;AACtE,QAAO"}

package/dist/ssg/create-static-gen.d.ts

@@ -0,0 +1,50 @@
+import { SSGGenerateOptions, SSGOptions, SSGResult } from "./types.js";
+
+//#region src/ssg/create-static-gen.d.ts
+/**
+ * Create a Static Site Generator
+ *
+ * Usage:
+ * ```ts
+ * const ssg = createStaticGen({
+ *   routes: [
+ *     { path: '/', component: HomePage },
+ *     { path: '/about', component: AboutPage },
+ *   ],
+ *   outputDir: './dist',
+ *   dataOverrides: {
+ *     '/api/posts': { posts: [...] }
+ *   }
+ * });
+ *
+ * const result = await ssg.generate();
+ * console.log(`Generated ${result.successful}/${result.totalRoutes} routes`);
+ * ```
+ */
+declare function createStaticGen(options: SSGOptions): {
+  /**
+   * Generate static HTML for all routes
+   * Writes to outputDir with metadata.json
+   * Returns detailed results
+   */
+  generate(generateOptions?: SSGGenerateOptions): Promise<SSGResult>;
+  /**
+   * Get effective config in a serializable form for diagnostics.
+   */
+  getConfig(): {
+    routeCount: number;
+    outputDir: string;
+    seed: number;
+    concurrency: number;
+    parallelism: number;
+    hasDataOverrides: boolean;
+  };
+  /**
+   * Get the last generation result
+   * Returns null if generate() hasn't been called
+   */
+  getResult(): SSGResult | null;
+};
+//#endregion
+export { createStaticGen };
+//# sourceMappingURL=create-static-gen.d.ts.map

package/dist/ssg/create-static-gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-static-gen.d.ts","names":[],"sources":["../../src/ssg/create-static-gen.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAkHgB,eAAA,CAAgB,OAAA,EAAS,UAAA;;;;;;6BAwBlB,kBAAA,GAChB,OAAA,CAAQ,SAAA;;;;;;;;;;;;;;;;eAmPE,SAAA;AAAA"}

package/dist/ssg/create-static-gen.js

@@ -0,0 +1,282 @@
+import { addPerfDuration, incrementPerfMetric } from "../runtime/perf-metrics.js";
+import { resolveSsgData, validateRoutes } from "./resolve-ssg-data.js";
+import { resolveRouteDescriptor } from "./route-utils.js";
+import { batchRenderRoutes } from "./batch-render.js";
+import { writeStaticFiles } from "./write-static-files.js";
+import { generateSSGResult, resultToMetadata, writeMetadata } from "./generate-metadata.js";
+import { getExistingOutputFileSize, hashHtml, outputFileExists, readIncrementalManifest, writeIncrementalManifest } from "./incremental-manifest.js";
+//#region src/ssg/create-static-gen.ts
+function getRuntimeOnlyDiagnostic(descriptor) {
+	const { route } = descriptor;
+	if (route.auth === true) return `Skipped prerender for "${descriptor.path}": authenticated routes are runtime-only by default.`;
+	if (route.role) return `Skipped prerender for "${descriptor.path}": role-gated routes are runtime-only by default.`;
+	if (route.permission) return `Skipped prerender for "${descriptor.path}": permission-gated routes are runtime-only by default.`;
+	if (route.policies && route.policies.length > 0) return `Skipped prerender for "${descriptor.path}": routes with custom policies are runtime-only by default.`;
+	return null;
+}
+function resolveParallelism(requested) {
+	if (requested !== "auto") return Math.max(1, requested ?? 1);
+	const maybeNavigator = globalThis;
+	const envWorkers = Number(maybeNavigator.process?.env?.ASKR_SSG_WORKERS ?? maybeNavigator.process?.env?.NUMBER_OF_PROCESSORS ?? maybeNavigator.process?.env?.UV_THREADPOOL_SIZE);
+	if (Number.isFinite(envWorkers) && envWorkers > 0) return Math.max(1, Math.trunc(envWorkers));
+	if (typeof maybeNavigator.navigator?.hardwareConcurrency === "number") return Math.max(1, maybeNavigator.navigator.hardwareConcurrency);
+	return 1;
+}
+/**
+* Create a Static Site Generator
+*
+* Usage:
+* ```ts
+* const ssg = createStaticGen({
+*   routes: [
+*     { path: '/', component: HomePage },
+*     { path: '/about', component: AboutPage },
+*   ],
+*   outputDir: './dist',
+*   dataOverrides: {
+*     '/api/posts': { posts: [...] }
+*   }
+* });
+*
+* const result = await ssg.generate();
+* console.log(`Generated ${result.successful}/${result.totalRoutes} routes`);
+* ```
+*/
+function createStaticGen(options) {
+	let result = null;
+	const seed = options.seed ?? 12345;
+	const resolvedParallelism = resolveParallelism(options.parallelism);
+	const resolvedConcurrency = Math.max(1, options.concurrency ?? resolvedParallelism);
+	if (!Array.isArray(options.routes) || options.routes.length === 0) throw new Error("routes array is required");
+	if (!options.outputDir || options.outputDir.trim().length === 0) throw new Error("outputDir is required");
+	return {
+		/**
+		* Generate static HTML for all routes
+		* Writes to outputDir with metadata.json
+		* Returns detailed results
+		*/
+		async generate(generateOptions = {}) {
+			validateRoutes(options.routes);
+			const changedKeys = dedupeStrings(generateOptions.changedKeys);
+			const changedRoutes = dedupeStrings(generateOptions.changedRoutes);
+			const requestedMode = generateOptions.mode ?? "full";
+			const previousManifest = !generateOptions.forceFull && requestedMode === "incremental" ? readIncrementalManifest(options.outputDir, seed) : null;
+			const effectiveMode = generateOptions.forceFull || requestedMode !== "incremental" || previousManifest === null ? "full" : "incremental";
+			const dataMap = resolveSsgData(options.routes, { dataOverrides: options.dataOverrides });
+			const descriptors = options.routes.map(resolveRouteDescriptor);
+			const routeResultsById = /* @__PURE__ */ new Map();
+			const eligibleDescriptors = [];
+			for (const descriptor of descriptors) {
+				const diagnostic = getRuntimeOnlyDiagnostic(descriptor);
+				if (diagnostic) {
+					routeResultsById.set(descriptor.routeId, {
+						path: descriptor.path,
+						filePath: descriptor.filePath,
+						html: "",
+						fileSize: 0,
+						renderDuration: 0,
+						resourceCount: 0,
+						status: "skipped",
+						reason: "runtime-only",
+						written: false,
+						error: diagnostic
+					});
+					continue;
+				}
+				eligibleDescriptors.push(descriptor);
+			}
+			const previousEntries = new Map((previousManifest?.routes ?? []).map((entry) => [entry.routeId, entry]));
+			const currentRouteIds = new Set(eligibleDescriptors.map((descriptor) => descriptor.routeId));
+			const selected = [];
+			const routesToRender = [];
+			for (let index = 0; index < eligibleDescriptors.length; index += 1) {
+				const descriptor = eligibleDescriptors[index];
+				const entry = selectRouteForGeneration(descriptor, previousEntries.get(descriptor.routeId) ?? null, effectiveMode, changedKeys, changedRoutes);
+				selected.push(entry);
+				if (entry.reason !== "unchanged") routesToRender.push(entry);
+			}
+			const renderStartTime = performance.now();
+			incrementPerfMetric("ssgWorkerCount", resolvedParallelism);
+			const renderedResults = routesToRender.length > 0 ? await batchRenderRoutes(getRoutesToRender(routesToRender), {
+				seed,
+				dataMap,
+				concurrency: resolvedConcurrency
+			}) : [];
+			addPerfDuration("ssgRenderTimeMs", performance.now() - renderStartTime);
+			const renderedByRouteId = /* @__PURE__ */ new Map();
+			for (let index = 0; index < renderedResults.length; index += 1) renderedByRouteId.set(routesToRender[index].descriptor.routeId, renderedResults[index]);
+			let cacheHits = 0;
+			const nextManifestRoutes = [];
+			for (const entry of selected) {
+				const { descriptor, previous, reason } = entry;
+				const baseData = dataMap[descriptor.route.path] ?? dataMap[descriptor.path] ?? {};
+				const resourceCount = Object.keys(baseData).length;
+				if (reason === "unchanged") {
+					routeResultsById.set(descriptor.routeId, {
+						path: descriptor.path,
+						filePath: descriptor.filePath,
+						html: "",
+						fileSize: previous?.htmlHash !== null && previous !== null ? getExistingOutputFileSize(options.outputDir, descriptor.filePath) : 0,
+						renderDuration: 0,
+						resourceCount,
+						status: "skipped",
+						reason: "unchanged",
+						written: false
+					});
+					if (previous) nextManifestRoutes.push({
+						...previous,
+						path: descriptor.path,
+						filePath: descriptor.filePath,
+						invalidationKeys: descriptor.invalidationKeys.slice()
+					});
+					continue;
+				}
+				const rendered = renderedByRouteId.get(descriptor.routeId);
+				if (!rendered) throw new Error(`Missing rendered result for route "${descriptor.path}"`);
+				const nextResult = {
+					...rendered,
+					path: descriptor.path,
+					filePath: descriptor.filePath,
+					resourceCount,
+					reason,
+					written: false
+				};
+				if (nextResult.status === "success") {
+					const htmlDigest = hashHtml(nextResult.html);
+					const shouldWrite = effectiveMode === "full" || !previous || previous.htmlHash !== htmlDigest || !outputFileExists(options.outputDir, descriptor.filePath);
+					nextResult.written = shouldWrite;
+					if (!shouldWrite) cacheHits += 1;
+					nextManifestRoutes.push({
+						routeId: descriptor.routeId,
+						path: descriptor.path,
+						filePath: descriptor.filePath,
+						invalidationKeys: descriptor.invalidationKeys.slice(),
+						htmlHash: htmlDigest,
+						lastStatus: "success"
+					});
+				} else nextManifestRoutes.push({
+					routeId: descriptor.routeId,
+					path: descriptor.path,
+					filePath: descriptor.filePath,
+					invalidationKeys: descriptor.invalidationKeys.slice(),
+					htmlHash: previous?.htmlHash ?? null,
+					lastStatus: "error"
+				});
+				routeResultsById.set(descriptor.routeId, nextResult);
+			}
+			const removedResults = collectRemovedRouteResults(previousManifest, currentRouteIds);
+			const routeResults = [];
+			for (let index = 0; index < descriptors.length; index += 1) {
+				const routeResult = routeResultsById.get(descriptors[index].routeId);
+				if (routeResult) routeResults.push(routeResult);
+			}
+			routeResults.push(...removedResults);
+			const writeStartTime = performance.now();
+			await writeStaticFiles(routeResults, options.outputDir, { concurrency: resolvedConcurrency });
+			addPerfDuration("ssgWriteTimeMs", performance.now() - writeStartTime);
+			result = generateSSGResult(routeResults, {
+				mode: effectiveMode,
+				cacheHits,
+				invalidatedKeys: changedKeys,
+				invalidatedRoutes: changedRoutes
+			});
+			await writeMetadata(resultToMetadata(result), options.outputDir);
+			await writeIncrementalManifest({
+				schemaVersion: 1,
+				seed,
+				mode: effectiveMode,
+				routes: nextManifestRoutes
+			}, options.outputDir);
+			return result;
+		},
+		/**
+		* Get effective config in a serializable form for diagnostics.
+		*/
+		getConfig() {
+			return {
+				routeCount: options.routes.length,
+				outputDir: options.outputDir,
+				seed,
+				concurrency: resolvedConcurrency,
+				parallelism: resolvedParallelism,
+				hasDataOverrides: !!options.dataOverrides
+			};
+		},
+		/**
+		* Get the last generation result
+		* Returns null if generate() hasn't been called
+		*/
+		getResult() {
+			return result;
+		}
+	};
+}
+function dedupeStrings(values) {
+	return values ? Array.from(new Set(values)) : [];
+}
+function getRoutesToRender(selected) {
+	const routes = [];
+	for (let index = 0; index < selected.length; index += 1) routes.push(selected[index].descriptor.route);
+	return routes;
+}
+function selectRouteForGeneration(descriptor, previous, mode, changedKeys, changedRoutes) {
+	if (mode === "full") return {
+		descriptor,
+		reason: "full",
+		previous
+	};
+	if (!previous) return {
+		descriptor,
+		reason: "new-route",
+		previous
+	};
+	if (previous.lastStatus === "error" || previous.htmlHash === null) return {
+		descriptor,
+		reason: "new-route",
+		previous
+	};
+	if (descriptor.invalidationKeys.length === 0) return {
+		descriptor,
+		reason: "no-keys",
+		previous
+	};
+	if (changedRoutes.includes(descriptor.path)) return {
+		descriptor,
+		reason: "changed-route",
+		previous
+	};
+	if (descriptor.invalidationKeys.some((key) => changedKeys.includes(key))) return {
+		descriptor,
+		reason: "changed-key",
+		previous
+	};
+	return {
+		descriptor,
+		reason: "unchanged",
+		previous
+	};
+}
+function collectRemovedRouteResults(manifest, currentRouteIds) {
+	if (!manifest) return [];
+	const results = [];
+	for (let index = 0; index < manifest.routes.length; index += 1) {
+		const entry = manifest.routes[index];
+		if (currentRouteIds.has(entry.routeId)) continue;
+		results.push({
+			path: entry.path,
+			filePath: entry.filePath,
+			html: "",
+			fileSize: 0,
+			renderDuration: 0,
+			resourceCount: 0,
+			status: "removed",
+			reason: "deleted",
+			written: false
+		});
+	}
+	return results;
+}
+//#endregion
+export { createStaticGen };
+
+//# sourceMappingURL=create-static-gen.js.map