@askrjs/askr 0.0.28 → 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 ReadableSource } from './readable';
+import { ReadableSource } from "./readable.js";
+
+//#region src/runtime/state.d.ts
 /**
  * State value holder - callable to read, has set method to update
  * @example
@@ -18,11 +8,11 @@ import { type ReadableSource } from './readable';
  * count();           // read: 0
  * count.set(1);      // write: triggers re-render
  */
-export 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']>;
+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
@@ -50,5 +40,7 @@ export interface State<T> extends ReadableSource<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;AASH,OAAO,EAEL,KAAK,cAAc,EAIpB,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACjD,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;CAC3D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAqClD"}
+{"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 c}from"./scheduler.js";import{getCurrentInstance as d,claimHookIndex as u}from"./component.js";import{isBulkCommitActive as f}from"./fastlane.js";import{recordReadableRead as p,markReadableDerivedSubscribersDirty as m,markReactivePropsDirtySource as h,notifyReadableReaders as b}from"./readable.js";function I(s){const n=d();if(!n)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=u(n,"state"),r=n.stateValues;if(r[t]){const e=r[t];if(e._owner!==n)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 e}const i=y(s,n);return r[t]=i,i}function y(s,n){let t=s,r=-1;const i=new Map;function e(){return e._hasBeenRead=!0,p(e),t}return e._readers=i,e._owner=n,e.set=a=>{if(d()!==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 o;if(typeof a=="function"?o=a(t):o=a,Object.is(t,o))return;if(f()){t=o;return}t=o,m(e),h(e);const l=c.getFlushVersion();if(r===l&&!c.isExecuting())return;r=b(e)&&!c.isExecuting()?l:-1},e[Symbol.iterator]=function*(){yield e,yield e.set},e}export{I 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

@@ -1,16 +1,16 @@
-/**
- * Batch rendering of multiple routes for SSG
- */
-import type { RouteConfig, RouteRenderResult } from './types';
-import type { SSRData } from '../common/ssr';
+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;
+  seed?: number;
+  dataMap?: Record<string, SSRData>;
+  concurrency?: number;
 }
 /**
  * Render multiple routes in parallel with error handling
  */
-export declare function batchRenderRoutes(routes: RouteConfig[], options?: BatchRenderOptions): Promise<RouteRenderResult[]>;
-export {};
+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

@@ -1 +1 @@
-{"version":3,"file":"batch-render.d.ts","sourceRoot":"","sources":["../../src/ssg/batch-render.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAG9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAG7C,UAAU,kBAAkB;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,WAAW,EAAE,EACrB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAgF9B"}
+{"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

@@ -1 +1,84 @@
-import{renderResolvedToStringSync as b}from"../ssr/index.js";import{interpolateRoutePath as M,getOutputFilePath as m}from"./route-utils.js";async function k(a,u={}){const{seed:d=12345,dataMap:c={},concurrency:f=1}=u,g=Math.max(1,Math.min(f,a.length||1)),l=new Array(a.length);let h=0;const y=async e=>{const i=performance.now(),n=M(e.path,e.params),o=c[e.path]??c[n]??{},p=e.handler?e.handler:(t,r)=>{const s=e.component;return s({...e.props||{},...t||{}},r)};try{const t={path:e.path,handler:p,namespace:e.namespace},r=b({url:n,routes:[t],handler:p,params:e.params,options:{seed:d,data:o}}),s=performance.now()-i;return{path:n,filePath:m(n),html:r,fileSize:Buffer.byteLength(r,"utf8"),renderDuration:Math.round(s),resourceCount:Object.keys(o).length,status:"success",reason:"full",written:!1}}catch(t){const r=performance.now()-i;return{path:n,filePath:m(n),html:"",fileSize:0,renderDuration:Math.round(r),resourceCount:Object.keys(o).length,status:"error",reason:"full",written:!1,error:t instanceof Error?t.message:String(t)}}},w=async()=>{for(;;){const e=h;if(h+=1,e>=a.length)return;l[e]=await y(a[e])}};return await Promise.all(Array.from({length:g},()=>w())),l}export{k as batchRenderRoutes};
+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

@@ -1,9 +1,6 @@
-/**
- * Static Site Generation API
- *
- * Main orchestrator for batch rendering, file I/O, and metadata generation
- */
-import type { SSGGenerateOptions, SSGOptions, SSGResult } from './types';
+import { SSGGenerateOptions, SSGOptions, SSGResult } from "./types.js";
+
+//#region src/ssg/create-static-gen.d.ts
 /**
  * Create a Static Site Generator
  *
@@ -24,28 +21,30 @@ import type { SSGGenerateOptions, SSGOptions, SSGResult } from './types';
  * console.log(`Generated ${result.successful}/${result.totalRoutes} routes`);
  * ```
  */
-export 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;
+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

@@ -1 +1 @@
-{"version":3,"file":"create-static-gen.d.ts","sourceRoot":"","sources":["../../src/ssg/create-static-gen.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAGV,kBAAkB,EAElB,UAAU,EACV,SAAS,EACV,MAAM,SAAS,CAAC;AAyDjB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,UAAU;IAkB/C;;;;OAIG;+BAEgB,kBAAkB,GAClC,OAAO,CAAC,SAAS,CAAC;IAkMrB;;OAEG;;;;;;;;;IAYH;;;OAGG;iBACU,SAAS,GAAG,IAAI;EAIhC"}
+{"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"}