@askrjs/askr 0.0.47 → 0.0.49

package/dist/runtime/component-contracts.js

@@ -0,0 +1,5 @@
+import { getCurrentInstance } from "./component-scope.js";
+import { cleanupComponent } from "./component-cleanup.js";
+import { captureInlineRenderSnapshot, createComponentInstance, mountInstanceInline, renderComponentInline, warnUnusedStateReads } from "./component-internal.js";
+import "./component.js";
+export { captureInlineRenderSnapshot, cleanupComponent, createComponentInstance, getCurrentInstance, mountInstanceInline, renderComponentInline, warnUnusedStateReads };

package/dist/runtime/component-facade.d.ts

@@ -0,0 +1,5 @@
+import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
+import { ComponentInstance } from "./component-internal.js";
+import { getSignal } from "./component-scope.js";
+import { ComponentFunction } from "../common/component.js";
+export { type ComponentFunction, type ComponentInstance, getSignal };

package/dist/runtime/component-facade.js

@@ -0,0 +1,4 @@
+import { claimHookIndex, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, setCurrentComponentInstance } from "./component-scope.js";
+import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
+import { captureInlineRenderSnapshot, createComponentInstance, finalizeReadSubscriptions, mountComponent, mountInstanceInline, registerCommitOperation, renderComponentInline, renderScopedComponent, warnUnusedStateReads } from "./component-internal.js";
+export { captureInlineRenderSnapshot, claimHookIndex, cleanupComponent, createComponentInstance, finalizeReadSubscriptions, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, mountComponent, mountInstanceInline, registerCommitOperation, registerOwnedChildScope, renderComponentInline, renderScopedComponent, setCurrentComponentInstance, unregisterOwnedChildScope, warnUnusedStateReads };

package/dist/runtime/component-internal.d.ts

@@ -0,0 +1,100 @@
+import { Props } from "../common/props.js";
+import { ReadableSource } from "./readable.js";
+import { State } from "./state.js";
+import { ContextFrame } from "./context.js";
+import { OwnedChildScope, cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
+import { LifecycleOperation } from "./component-lifecycle.js";
+import { ComponentFunction } from "../common/component.js";
+
+//#region src/runtime/component-internal.d.ts
+interface ComponentInstance {
+  id: string;
+  fn: ComponentFunction;
+  props: Props;
+  target: Element | null;
+  parentInstance: ComponentInstance | null;
+  portalScope: object | null;
+  mounted: boolean;
+  abortController: AbortController | null;
+  ssr?: boolean;
+  cleanupStrict?: boolean;
+  stateValues: State<unknown>[];
+  evaluationGeneration: number;
+  notifyUpdate: (() => void) | null;
+  _pendingFlushTask?: () => void;
+  _pendingRunTask?: () => void;
+  _enqueueRun?: () => void;
+  stateIndexCheck: number;
+  expectedStateIndices: number[];
+  firstRenderComplete: boolean;
+  mountOperations: Array<() => void | (() => void) | PromiseLike<void | (() => void)>>;
+  commitOperations: Array<() => void | (() => void) | PromiseLike<void | (() => void)>>;
+  cleanupFns: Array<() => void>;
+  lifecycleSlots: unknown[];
+  lifecycleGeneration: number;
+  hasPendingUpdate: boolean;
+  ownerFrame: ContextFrame | null;
+  isRoot?: boolean;
+  _currentRenderToken?: number;
+  lastRenderToken?: number;
+  _pendingReadSources?: Set<ReadableSource<unknown>>;
+  _pendingReadSourceVersions?: Map<ReadableSource<unknown>, number>;
+  _lastReadSources?: Set<ReadableSource<unknown>>;
+  devWarningsEmitted?: Set<string>;
+  _placeholder?: Comment;
+  _ownedChildScopes?: Set<OwnedChildScope>;
+  errorBoundaryState?: {
+    error: unknown | null;
+    resetKey: unknown;
+    notified: boolean;
+  };
+}
+declare function createComponentInstance(id: string, fn: ComponentFunction, props: Props, target: Element | null): ComponentInstance;
+/**
+ * Register a mount operation that will run after the component is mounted
+ * Used by operations (task, on, timer, etc) to execute after render completes
+ */
+declare function captureInlineRenderSnapshot(instance: ComponentInstance): void;
+declare function registerMountOperation(operation: LifecycleOperation): void;
+declare function registerCommitOperation(operation: LifecycleOperation): void;
+declare function commitRenderedComponent(instance: ComponentInstance): void;
+declare function mountInstanceInline(instance: ComponentInstance, target: Element | null): void;
+/**
+ * Run a component synchronously: execute function, handle result
+ * This is the internal workhorse that manages async continuations and generation tracking.
+ * Must always be called through the scheduler.
+ *
+ * ACTOR INVARIANT: This function is enqueued as a task, never called directly.
+ */
+declare function renderScopedComponent<T>(instance: ComponentInstance, startStateIndex: number, render: () => T): T;
+/**
+ * Execute a component's render function synchronously.
+ * Returns either a vnode/promise immediately (does NOT render).
+ * Rendering happens separately through the scheduled commit helper.
+ */
+declare function renderComponentInline(instance: ComponentInstance): unknown | Promise<unknown>;
+declare function warnUnusedStateReads(instance: ComponentInstance): void;
+/**
+ * Public entry point: Execute component with full lifecycle (execute + render)
+ * Handles both initial mount and re-execution. Always enqueues through scheduler.
+ * Single entry point to avoid lifecycle divergence.
+ */
+declare function executeComponent(instance: ComponentInstance): void;
+/**
+ * Finalize read subscriptions for an instance after a successful commit.
+ * - Update per-state readers map to point to this instance's last committed token
+ * - Remove this instance from states it no longer reads
+ * This is deterministic and runs synchronously with commit to ensure
+ * subscribers are only notified when they actually read a state in their
+ * last committed render.
+ */
+declare function finalizeReadSubscriptions(instance: ComponentInstance): void;
+/**
+ * Mount a component instance.
+ * This is just an alias to executeComponent() to maintain API compatibility.
+ * All lifecycle logic is unified in executeComponent().
+ */
+declare function mountComponent(instance: ComponentInstance): void;
+//#endregion
+export { type ComponentFunction, ComponentInstance, cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope };
+//# sourceMappingURL=component-internal.d.ts.map

package/dist/runtime/component-internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-internal.d.ts","names":[],"sources":["../../src/runtime/component-internal.ts"],"mappings":";;;;;;;;;UA2DiB,iBAAA;EACf,EAAA;EACA,EAAA,EAAI,iBAAA;EACJ,KAAA,EAAO,KAAA;EACP,MAAA,EAAQ,OAAA;EACR,cAAA,EAAgB,iBAAA;EAChB,WAAA;EACA,OAAA;EACA,eAAA,EAAiB,eAAA;EACjB,GAAA;EAEA,aAAA;EACA,WAAA,EAAa,KAAA;EACb,oBAAA;EACA,YAAA;EAEA,iBAAA;EACA,eAAA;EACA,WAAA;EACA,eAAA;EACA,oBAAA;EACA,mBAAA;EACA,eAAA,EAAiB,KAAA,6BACa,WAAA;EAE9B,gBAAA,EAAkB,KAAA,6BACY,WAAA;EAE9B,UAAA,EAAY,KAAA;EACZ,cAAA;EACA,mBAAA;EACA,gBAAA;EACA,UAAA,EAAY,YAAA;EACZ,MAAA;EAGA,mBAAA;EACA,eAAA;EACA,mBAAA,GAAsB,GAAA,CAAI,cAAA;EAC1B,0BAAA,GAA6B,GAAA,CAAI,cAAA;EACjC,gBAAA,GAAmB,GAAA,CAAI,cAAA;EACvB,kBAAA,GAAqB,GAAA;EAIrB,YAAA,GAAe,OAAA;EACf,iBAAA,GAAoB,GAAA,CAAI,eAAA;EACxB,kBAAA;IACE,KAAA;IACA,QAAA;IACA,QAAA;EAAA;AAAA;AAAA,iBAIY,uBAAA,CACd,EAAA,UACA,EAAA,EAAI,iBAAA,EACJ,KAAA,EAAO,KAAA,EACP,MAAA,EAAQ,OAAA,UACP,iBAAA;;;;;iBA6Ea,2BAAA,CAA4B,QAA2B,EAAjB,iBAAiB;AAAA,iBAIvD,sBAAA,CAAuB,SAA6B,EAAlB,kBAAkB;AAAA,iBAIpD,uBAAA,CAAwB,SAA6B,EAAlB,kBAAkB;AAAA,iBAIrD,uBAAA,CAAwB,QAA2B,EAAjB,iBAAiB;AAAA,iBAInD,mBAAA,CACd,QAAA,EAAU,iBAAA,EACV,MAAA,EAAQ,OAAO;;;;;;;;iBAuCD,qBAAA,IACd,QAAA,EAAU,iBAAA,EACV,eAAA,UACA,MAAA,QAAc,CAAA,GACb,CAAA;;;;;;iBA6Ba,qBAAA,CACd,QAAA,EAAU,iBAAA,aACC,OAAO;AAAA,iBAwCJ,oBAAA,CAAqB,QAA2B,EAAjB,iBAAiB;;;;;;iBAmGhD,gBAAA,CAAiB,QAA2B,EAAjB,iBAAiB;;;;;;;;;iBAmB5C,yBAAA,CAA0B,QAA2B,EAAjB,iBAAiB;;;;AAhVzD;AAIZ;iBAqVgB,cAAA,CAAe,QAA2B,EAAjB,iBAAiB"}

package/dist/runtime/component-internal.js

@@ -0,0 +1,219 @@
+import { isDevelopmentEnvironment, isProductionEnvironment } from "../common/env.js";
+import { logger } from "../dev/logger.js";
+import { enqueueRuntimeTask } from "./access.js";
+import { withContext } from "./context.js";
+import { finalizeReadableSubscriptions } from "./readable.js";
+import { incDevCounter } from "./dev-namespace.js";
+import { beginRenderTracking, captureInlineComponentScope, captureInlineRenderTracking, clearRenderTracking, enterComponentExecutionScope, enterRenderScopedComponent, exitComponentExecutionScope, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getSignalForInstance, resetRenderState, restoreInlineComponentScope, restoreInlineRenderTracking, restoreRenderScopedComponent } from "./component-scope.js";
+import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
+import { captureInlineRenderSnapshot as captureInlineRenderSnapshot$1, commitLifecycleForInstance, commitRenderedComponent as commitRenderedComponent$1, discardCommitOperations, finalizeInlineReadSubscriptions, registerCommitOperationForInstance } from "./component-lifecycle.js";
+import { runScheduledComponent } from "./component-commit.js";
+//#region src/runtime/component-internal.ts
+function createComponentInstance(id, fn, props, target) {
+	const parentInstance = getCurrentInstance();
+	const instance = {
+		id,
+		fn,
+		props,
+		target,
+		parentInstance,
+		portalScope: parentInstance?.portalScope ?? getCurrentPortalScope() ?? null,
+		mounted: false,
+		abortController: null,
+		stateValues: [],
+		evaluationGeneration: 0,
+		notifyUpdate: null,
+		_pendingFlushTask: void 0,
+		_pendingRunTask: void 0,
+		_enqueueRun: void 0,
+		stateIndexCheck: -1,
+		expectedStateIndices: [],
+		firstRenderComplete: false,
+		mountOperations: [],
+		commitOperations: [],
+		cleanupFns: [],
+		lifecycleSlots: [],
+		lifecycleGeneration: 0,
+		hasPendingUpdate: false,
+		ownerFrame: null,
+		ssr: false,
+		cleanupStrict: false,
+		isRoot: false,
+		_currentRenderToken: void 0,
+		lastRenderToken: 0,
+		_pendingReadSources: void 0,
+		_pendingReadSourceVersions: void 0,
+		_lastReadSources: void 0,
+		devWarningsEmitted: void 0
+	};
+	instance._pendingRunTask = () => {
+		instance.hasPendingUpdate = false;
+		if (instance.notifyUpdate === null) return;
+		runScheduledComponent(instance, {
+			execute: executeComponentSync,
+			finalizeReadSubscriptions,
+			warnUnusedStateReads,
+			commitRenderedComponent
+		});
+	};
+	instance._enqueueRun = () => {
+		if (!instance.hasPendingUpdate) {
+			instance.hasPendingUpdate = true;
+			enqueueRuntimeTask(instance._pendingRunTask);
+		}
+	};
+	instance._pendingFlushTask = instance._pendingRunTask;
+	return instance;
+}
+/**
+* Register a mount operation that will run after the component is mounted
+* Used by operations (task, on, timer, etc) to execute after render completes
+*/
+function captureInlineRenderSnapshot(instance) {
+	captureInlineRenderSnapshot$1(instance);
+}
+function registerCommitOperation(operation) {
+	registerCommitOperationForInstance(getCurrentComponentInstance(), operation);
+}
+function commitRenderedComponent(instance) {
+	commitRenderedComponent$1(instance);
+}
+function mountInstanceInline(instance, target) {
+	instance.target = target;
+	try {
+		if (target instanceof Element) {
+			const host = target;
+			const nextInstances = (host.__ASKR_INSTANCES ?? []).filter((entry) => entry !== instance);
+			nextInstances.push(instance);
+			host.__ASKR_INSTANCES = nextInstances;
+			host.__ASKR_INSTANCE = nextInstances[0] ?? instance;
+		}
+	} catch (err) {}
+	instance.notifyUpdate = instance._enqueueRun;
+	const wasFirstMount = !instance.mounted;
+	instance.mounted = true;
+	commitLifecycleForInstance(instance, wasFirstMount);
+}
+/**
+* Run a component synchronously: execute function, handle result
+* This is the internal workhorse that manages async continuations and generation tracking.
+* Must always be called through the scheduler.
+*
+* ACTOR INVARIANT: This function is enqueued as a task, never called directly.
+*/
+function renderScopedComponent(instance, startStateIndex, render) {
+	instance.notifyUpdate = instance._enqueueRun;
+	resetRenderState(instance);
+	beginRenderTracking(instance);
+	const savedScope = enterRenderScopedComponent(instance, startStateIndex);
+	let didComplete = false;
+	try {
+		const result = withContext({
+			parent: instance.ownerFrame,
+			values: null
+		}, render);
+		didComplete = true;
+		return result;
+	} finally {
+		if (!didComplete) clearRenderTracking(instance);
+		restoreRenderScopedComponent(savedScope);
+	}
+}
+/**
+* Execute a component's render function synchronously.
+* Returns either a vnode/promise immediately (does NOT render).
+* Rendering happens separately through the scheduled commit helper.
+*/
+function renderComponentInline(instance) {
+	instance.notifyUpdate = instance._enqueueRun;
+	const trackingSnapshot = captureInlineRenderTracking(instance);
+	const scopeSnapshot = captureInlineComponentScope();
+	const hadToken = trackingSnapshot.currentRenderToken !== void 0;
+	if (!hadToken) beginRenderTracking(instance);
+	try {
+		const result = executeComponentSync(instance);
+		if (!hadToken) finalizeInlineReadSubscriptions(instance, instance._currentRenderToken, instance._pendingReadSources, instance._pendingReadSourceVersions);
+		commitRenderedComponent(instance);
+		return result;
+	} finally {
+		restoreInlineRenderTracking(instance, trackingSnapshot);
+		restoreInlineComponentScope(scopeSnapshot);
+	}
+}
+function warnUnusedStateReads(instance) {
+	for (let i = 0; i < instance.stateValues.length; i++) {
+		const state = instance.stateValues[i];
+		const hasCommittedUsage = (state?._readers?.size ?? 0) > 0 || (state?._derivedSubscribers?.size ?? 0) > 0;
+		if (state && !state._hasBeenRead && !state._hasEverBeenRead && !hasCommittedUsage) try {
+			const name = instance.fn?.name || "<anonymous>";
+			warnInstanceOnce(instance, `unused-state:${i}`, `[askr] Unused state variable detected in ${name} at index ${i}. State should be read during render or removed.`);
+		} catch {
+			warnInstanceOnce(instance, `unused-state:${i}`, `[askr] Unused state variable detected. State should be read during render or removed.`);
+		}
+	}
+}
+function executeComponentSync(instance) {
+	resetRenderState(instance);
+	incDevCounter("componentRuns");
+	incDevCounter("componentReruns");
+	const savedPortalScope = enterComponentExecutionScope(instance);
+	let didComplete = false;
+	try {
+		const renderStartTime = isDevelopmentEnvironment() ? Date.now() : 0;
+		const context = { get signal() {
+			return getSignalForInstance(instance);
+		} };
+		const result = withContext({
+			parent: instance.ownerFrame,
+			values: null
+		}, () => instance.fn(instance.props, context));
+		const renderTime = Date.now() - renderStartTime;
+		if (renderTime > 5) warnInstanceOnce(instance, "slow-render", `[askr] Slow render detected: ${renderTime}ms. Consider optimizing component performance.`);
+		if (!instance.firstRenderComplete) instance.firstRenderComplete = true;
+		didComplete = true;
+		return result;
+	} finally {
+		if (!didComplete) discardCommitOperations(instance);
+		exitComponentExecutionScope(savedPortalScope);
+	}
+}
+/**
+* Public entry point: Execute component with full lifecycle (execute + render)
+* Handles both initial mount and re-execution. Always enqueues through scheduler.
+* Single entry point to avoid lifecycle divergence.
+*/
+function executeComponent(instance) {
+	instance.abortController = null;
+	instance.notifyUpdate = instance._enqueueRun;
+	enqueueRuntimeTask(instance._pendingRunTask);
+}
+/**
+* Finalize read subscriptions for an instance after a successful commit.
+* - Update per-state readers map to point to this instance's last committed token
+* - Remove this instance from states it no longer reads
+* This is deterministic and runs synchronously with commit to ensure
+* subscribers are only notified when they actually read a state in their
+* last committed render.
+*/
+function finalizeReadSubscriptions(instance) {
+	finalizeReadableSubscriptions(instance);
+}
+/**
+* Mount a component instance.
+* This is just an alias to executeComponent() to maintain API compatibility.
+* All lifecycle logic is unified in executeComponent().
+*/
+function mountComponent(instance) {
+	executeComponent(instance);
+}
+function warnInstanceOnce(instance, key, message) {
+	if (isProductionEnvironment()) return;
+	const warnings = instance.devWarningsEmitted ??= /* @__PURE__ */ new Set();
+	if (warnings.has(key)) return;
+	warnings.add(key);
+	logger.warn(message);
+}
+//#endregion
+export { captureInlineRenderSnapshot, cleanupComponent, commitRenderedComponent, createComponentInstance, executeComponent, finalizeReadSubscriptions, mountComponent, mountInstanceInline, registerCommitOperation, registerOwnedChildScope, renderComponentInline, renderScopedComponent, unregisterOwnedChildScope, warnUnusedStateReads };
+
+//# sourceMappingURL=component-internal.js.map

package/dist/runtime/component-internal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-internal.js","names":[],"sources":["../../src/runtime/component-internal.ts"],"sourcesContent":["/**\n * Component instance lifecycle management\n * Internal only — users never see this\n */\n\nimport { type State } from './state';\nimport { enqueueRuntimeTask } from './access';\nimport type { Props } from '../common/props';\nimport type { ComponentFunction } from '../common/component';\nimport {\n  // withContext is the sole primitive for context restoration\n  withContext,\n  type ContextFrame,\n} from './context';\nimport { type ReadableSource, finalizeReadableSubscriptions } from './readable';\nimport {\n  isDevelopmentEnvironment,\n  isProductionEnvironment,\n} from '../common/env';\nimport { logger } from '../dev/logger';\nimport { incDevCounter } from './dev-namespace';\nimport {\n  cleanupComponent,\n  registerOwnedChildScope,\n  unregisterOwnedChildScope,\n  type OwnedChildScope,\n} from './component-cleanup';\nimport { runScheduledComponent } from './component-commit';\nimport {\n  captureInlineRenderSnapshot as captureLifecycleInlineRenderSnapshot,\n  commitLifecycleForInstance,\n  commitRenderedComponent as commitRenderedLifecycleComponent,\n  discardCommitOperations,\n  finalizeInlineReadSubscriptions,\n  registerCommitOperationForInstance,\n  registerMountOperationForInstance,\n  type LifecycleOperation,\n} from './component-lifecycle';\nimport {\n  beginRenderTracking,\n  captureInlineComponentScope,\n  captureInlineRenderTracking,\n  clearRenderTracking,\n  enterComponentExecutionScope,\n  enterRenderScopedComponent,\n  exitComponentExecutionScope,\n  getCurrentComponentInstance,\n  getCurrentInstance,\n  getCurrentPortalScope,\n  getSignalForInstance,\n  resetRenderState,\n  restoreInlineComponentScope,\n  restoreInlineRenderTracking,\n  restoreRenderScopedComponent,\n} from './component-scope';\n\nexport type { ComponentFunction } from '../common/component';\nexport { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope };\n\nexport interface ComponentInstance {\n  id: string;\n  fn: ComponentFunction;\n  props: Props;\n  target: Element | null;\n  parentInstance: ComponentInstance | null;\n  portalScope: object | null;\n  mounted: boolean;\n  abortController: AbortController | null; // Lazily created per-component abort lifecycle\n  ssr?: boolean; // Set to true for SSR temporary instances\n  // Opt-in strict cleanup mode: when true cleanup errors are aggregated and re-thrown\n  cleanupStrict?: boolean;\n  stateValues: State<unknown>[]; // Persistent state storage across renders\n  evaluationGeneration: number; // Prevents stale async evaluation completions\n  notifyUpdate: (() => void) | null; // Callback for state updates (persisted on instance)\n  // Internal: prebound helpers to avoid per-update closures (allocation hot-path)\n  _pendingFlushTask?: () => void; // Clears hasPendingUpdate and triggers notifyUpdate\n  _pendingRunTask?: () => void; // Clears hasPendingUpdate and runs component\n  _enqueueRun?: () => void; // Batches run requests and enqueues _pendingRunTask\n  stateIndexCheck: number; // Track state indices to catch conditional calls\n  expectedStateIndices: number[]; // Expected sequence of render-scoped hook indices (frozen after first render)\n  firstRenderComplete: boolean; // Flag to detect transition from first to subsequent renders\n  mountOperations: Array<\n    () => void | (() => void) | PromiseLike<void | (() => void)>\n  >; // Operations to run when component mounts\n  commitOperations: Array<\n    () => void | (() => void) | PromiseLike<void | (() => void)>\n  >; // Operations to run after a successful committed render\n  cleanupFns: Array<() => void>; // Cleanup functions to run on unmount\n  lifecycleSlots: unknown[]; // Render-scoped lifecycle primitive storage\n  lifecycleGeneration: number; // Invalidates async mount-operation settlement after disposal\n  hasPendingUpdate: boolean; // Flag to batch state updates (coalescing)\n  ownerFrame: ContextFrame | null; // Provider chain for this component (set by Scope, never overwritten)\n  isRoot?: boolean;\n\n  // Render-tracking for precise subscriptions (internal)\n  _currentRenderToken?: number; // Token for the in-progress render (set before render)\n  lastRenderToken?: number; // Token of the last *committed* render\n  _pendingReadSources?: Set<ReadableSource<unknown>>; // Readables read during the in-progress render\n  _pendingReadSourceVersions?: Map<ReadableSource<unknown>, number>; // Source versions captured during the in-progress render\n  _lastReadSources?: Set<ReadableSource<unknown>>; // Readables read during the last committed render\n  devWarningsEmitted?: Set<string>; // Dev-only warning dedupe for this instance\n\n  // Placeholder for null-returning components. When a component initially returns\n  // null, we create a comment placeholder so updates can replace it with content.\n  _placeholder?: Comment;\n  _ownedChildScopes?: Set<OwnedChildScope>;\n  errorBoundaryState?: {\n    error: unknown | null;\n    resetKey: unknown;\n    notified: boolean;\n  };\n}\n\nexport function createComponentInstance(\n  id: string,\n  fn: ComponentFunction,\n  props: Props,\n  target: Element | null\n): ComponentInstance {\n  const parentInstance = getCurrentInstance();\n  const portalScope = parentInstance?.portalScope ?? getCurrentPortalScope();\n  const instance: ComponentInstance = {\n    id,\n    fn,\n    props,\n    target,\n    parentInstance,\n    portalScope: portalScope ?? null,\n    mounted: false,\n    abortController: null,\n    stateValues: [],\n    evaluationGeneration: 0,\n    notifyUpdate: null,\n    // Prebound helpers (initialized below) to avoid per-update allocations\n    _pendingFlushTask: undefined,\n    _pendingRunTask: undefined,\n    _enqueueRun: undefined,\n    stateIndexCheck: -1,\n    expectedStateIndices: [],\n    firstRenderComplete: false,\n    mountOperations: [],\n    commitOperations: [],\n    cleanupFns: [],\n    lifecycleSlots: [],\n    lifecycleGeneration: 0,\n    hasPendingUpdate: false,\n    ownerFrame: null, // Will be set by renderer when vnode is marked\n    ssr: false,\n    cleanupStrict: false,\n    isRoot: false,\n\n    // Render-tracking (for precise state subscriptions)\n    _currentRenderToken: undefined,\n    lastRenderToken: 0,\n    _pendingReadSources: undefined,\n    _pendingReadSourceVersions: undefined,\n    _lastReadSources: undefined,\n    devWarningsEmitted: undefined,\n  };\n\n  // Initialize prebound helper tasks once per instance to avoid allocations\n  instance._pendingRunTask = () => {\n    // Clear pending flag when the run task executes\n    instance.hasPendingUpdate = false;\n    if (instance.notifyUpdate === null) {\n      return;\n    }\n    // Execute component run (will set up notifyUpdate before render)\n    runScheduledComponent(instance, {\n      execute: executeComponentSync,\n      finalizeReadSubscriptions,\n      warnUnusedStateReads,\n      commitRenderedComponent,\n    });\n  };\n\n  instance._enqueueRun = () => {\n    if (!instance.hasPendingUpdate) {\n      instance.hasPendingUpdate = true;\n      // Enqueue single run task (coalesces multiple writes)\n      enqueueRuntimeTask(instance._pendingRunTask!);\n    }\n  };\n\n  // Default state-driven updates enqueue the run task directly. Specialized\n  // runtimes (for example `For` item instances) can still override this hook.\n  instance._pendingFlushTask = instance._pendingRunTask;\n\n  return instance;\n}\n\n/**\n * Register a mount operation that will run after the component is mounted\n * Used by operations (task, on, timer, etc) to execute after render completes\n */\nexport function captureInlineRenderSnapshot(instance: ComponentInstance): void {\n  captureLifecycleInlineRenderSnapshot(instance);\n}\n\nexport function registerMountOperation(operation: LifecycleOperation): void {\n  registerMountOperationForInstance(getCurrentComponentInstance(), operation);\n}\n\nexport function registerCommitOperation(operation: LifecycleOperation): void {\n  registerCommitOperationForInstance(getCurrentComponentInstance(), operation);\n}\n\nexport function commitRenderedComponent(instance: ComponentInstance): void {\n  commitRenderedLifecycleComponent(instance);\n}\n\nexport function mountInstanceInline(\n  instance: ComponentInstance,\n  target: Element | null\n): void {\n  instance.target = target;\n  // Record backref on host element so renderer can clean up when the\n  // node is removed. Avoids leaks if the node is detached or replaced.\n  try {\n    if (target instanceof Element) {\n      const host = target as Element & {\n        __ASKR_INSTANCE?: ComponentInstance;\n        __ASKR_INSTANCES?: ComponentInstance[];\n      };\n      const instances = host.__ASKR_INSTANCES ?? [];\n      const nextInstances = instances.filter((entry) => entry !== instance);\n      nextInstances.push(instance);\n      host.__ASKR_INSTANCES = nextInstances;\n      host.__ASKR_INSTANCE = nextInstances[0] ?? instance;\n    }\n  } catch (err) {\n    void err;\n  }\n\n  // Ensure notifyUpdate is available for async resource completions that may\n  // try to trigger re-render. This mirrors the setup in executeComponent().\n  // Use prebound enqueue helper to avoid allocating a new closure\n  instance.notifyUpdate = instance._enqueueRun!;\n\n  const wasFirstMount = !instance.mounted;\n  instance.mounted = true;\n  commitLifecycleForInstance(instance, wasFirstMount);\n}\n\n/**\n * Run a component synchronously: execute function, handle result\n * This is the internal workhorse that manages async continuations and generation tracking.\n * Must always be called through the scheduler.\n *\n * ACTOR INVARIANT: This function is enqueued as a task, never called directly.\n */\n\nexport function renderScopedComponent<T>(\n  instance: ComponentInstance,\n  startStateIndex: number,\n  render: () => T\n): T {\n  instance.notifyUpdate = instance._enqueueRun!;\n  resetRenderState(instance);\n  beginRenderTracking(instance);\n  const savedScope = enterRenderScopedComponent(instance, startStateIndex);\n\n  let didComplete = false;\n\n  try {\n    const executionFrame: ContextFrame = {\n      parent: instance.ownerFrame,\n      values: null,\n    };\n    const result = withContext(executionFrame, render);\n    didComplete = true;\n    return result;\n  } finally {\n    if (!didComplete) {\n      clearRenderTracking(instance);\n    }\n    restoreRenderScopedComponent(savedScope);\n  }\n}\n\n/**\n * Execute a component's render function synchronously.\n * Returns either a vnode/promise immediately (does NOT render).\n * Rendering happens separately through the scheduled commit helper.\n */\nexport function renderComponentInline(\n  instance: ComponentInstance\n): unknown | Promise<unknown> {\n  // Reused inline instances can cross renderer cleanup boundaries while their\n  // host node is retained. Make sure state writes still enqueue this instance.\n  instance.notifyUpdate = instance._enqueueRun!;\n\n  // Ensure inline executions (rendered during parent's evaluate) still\n  // receive a render token and have their state reads finalized so\n  // subscriptions are correctly recorded. If this function is called\n  // as part of a scheduled run, the token will already be set by\n  // runComponent and we should not overwrite it.\n  const trackingSnapshot = captureInlineRenderTracking(instance);\n  const scopeSnapshot = captureInlineComponentScope();\n  const hadToken = trackingSnapshot.currentRenderToken !== undefined;\n\n  if (!hadToken) {\n    beginRenderTracking(instance);\n  }\n\n  try {\n    const result = executeComponentSync(instance);\n    // If we set the token for inline execution, finalize subscriptions now\n    // unless the parent DOM commit is still provisional. Renderer commit\n    // batches flush these reads only after DOM evaluation succeeds.\n    if (!hadToken) {\n      finalizeInlineReadSubscriptions(\n        instance,\n        instance._currentRenderToken!,\n        instance._pendingReadSources,\n        instance._pendingReadSourceVersions\n      );\n    }\n    commitRenderedComponent(instance);\n    return result;\n  } finally {\n    // Restore previous token/read states for nested inline render scenarios\n    restoreInlineRenderTracking(instance, trackingSnapshot);\n    restoreInlineComponentScope(scopeSnapshot);\n  }\n}\n\nexport function warnUnusedStateReads(instance: ComponentInstance): void {\n  for (let i = 0; i < instance.stateValues.length; i++) {\n    const state = instance.stateValues[i];\n    const hasCommittedUsage =\n      (state?._readers?.size ?? 0) > 0 ||\n      ((state as { _derivedSubscribers?: Set<unknown> } | undefined)\n        ?._derivedSubscribers?.size ?? 0) > 0;\n\n    if (\n      state &&\n      !state._hasBeenRead &&\n      !state._hasEverBeenRead &&\n      !hasCommittedUsage\n    ) {\n      try {\n        const name = instance.fn?.name || '<anonymous>';\n        warnInstanceOnce(\n          instance,\n          `unused-state:${i}`,\n          `[askr] Unused state variable detected in ${name} at index ${i}. State should be read during render or removed.`\n        );\n      } catch {\n        warnInstanceOnce(\n          instance,\n          `unused-state:${i}`,\n          `[askr] Unused state variable detected. State should be read during render or removed.`\n        );\n      }\n    }\n  }\n}\n\nfunction executeComponentSync(\n  instance: ComponentInstance\n): unknown | Promise<unknown> {\n  resetRenderState(instance);\n  incDevCounter('componentRuns');\n  incDevCounter('componentReruns');\n\n  const savedPortalScope = enterComponentExecutionScope(instance);\n\n  let didComplete = false;\n\n  try {\n    // Track render time in dev mode\n    const renderStartTime = isDevelopmentEnvironment() ? Date.now() : 0;\n\n    // Create context object with abort signal\n    const context = {\n      get signal(): AbortSignal {\n        return getSignalForInstance(instance);\n      },\n    };\n\n    // Execute component within its owner frame (provider chain).\n    // This ensures all context reads see the correct provider values.\n    // We create a new execution frame whose parent is the ownerFrame. The\n    // `values` map is lazily allocated to avoid per-render Map allocations\n    // for components that do not use context.\n    const executionFrame: ContextFrame = {\n      parent: instance.ownerFrame,\n      values: null,\n    };\n    const result = withContext(executionFrame, () =>\n      instance.fn(instance.props, context)\n    );\n\n    // Check render time\n    const renderTime = Date.now() - renderStartTime;\n    if (renderTime > 5) {\n      warnInstanceOnce(\n        instance,\n        'slow-render',\n        `[askr] Slow render detected: ${renderTime}ms. Consider optimizing component performance.`\n      );\n    }\n\n    // Mark first render complete after successful execution\n    // This enables hook order validation on subsequent renders\n    if (!instance.firstRenderComplete) {\n      instance.firstRenderComplete = true;\n    }\n\n    didComplete = true;\n    return result;\n  } finally {\n    if (!didComplete) {\n      discardCommitOperations(instance);\n    }\n    // Synchronous path: we did not push a fresh frame, so nothing to pop here.\n    exitComponentExecutionScope(savedPortalScope);\n  }\n}\n\n/**\n * Public entry point: Execute component with full lifecycle (execute + render)\n * Handles both initial mount and re-execution. Always enqueues through scheduler.\n * Single entry point to avoid lifecycle divergence.\n */\nexport function executeComponent(instance: ComponentInstance): void {\n  // Lazily recreate abort controller only when signal is actually requested.\n  instance.abortController = null;\n\n  // Setup notifyUpdate callback using prebound helper to avoid per-call closures\n  instance.notifyUpdate = instance._enqueueRun!;\n\n  // Enqueue the initial component run\n  enqueueRuntimeTask(instance._pendingRunTask!);\n}\n\n/**\n * Finalize read subscriptions for an instance after a successful commit.\n * - Update per-state readers map to point to this instance's last committed token\n * - Remove this instance from states it no longer reads\n * This is deterministic and runs synchronously with commit to ensure\n * subscribers are only notified when they actually read a state in their\n * last committed render.\n */\nexport function finalizeReadSubscriptions(instance: ComponentInstance): void {\n  finalizeReadableSubscriptions(instance);\n}\n\n/**\n * Mount a component instance.\n * This is just an alias to executeComponent() to maintain API compatibility.\n * All lifecycle logic is unified in executeComponent().\n */\nexport function mountComponent(instance: ComponentInstance): void {\n  executeComponent(instance);\n}\n\nfunction warnInstanceOnce(\n  instance: ComponentInstance,\n  key: string,\n  message: string\n): void {\n  if (isProductionEnvironment()) return;\n  const warnings = (instance.devWarningsEmitted ??= new Set());\n  if (warnings.has(key)) return;\n  warnings.add(key);\n  logger.warn(message);\n}\n"],"mappings":"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"}

package/dist/runtime/component-lifecycle.d.ts

@@ -0,0 +1,49 @@
+import { Props } from "../common/props.js";
+import { ReadableSource } from "./readable.js";
+import { ContextFrame } from "./context.js";
+import { ComponentInstance } from "./component-internal.js";
+
+//#region src/runtime/component-lifecycle.d.ts
+type LifecycleOperation = () => void | (() => void) | PromiseLike<void | (() => void)>;
+type LifecycleCommitBatchEntry = {
+  instance: ComponentInstance;
+  wasFirstMount: boolean;
+};
+type ReadSubscriptionCommit = {
+  instance: ComponentInstance;
+  token: number;
+  pendingReadSources: Set<ReadableSource<unknown>> | undefined;
+  pendingReadSourceVersions: Map<ReadableSource<unknown>, number> | undefined;
+};
+type InlineRenderSnapshot = {
+  instance: ComponentInstance;
+  props: Props;
+  ownerFrame: ContextFrame | null;
+  portalScope: object | null;
+  parentInstance: ComponentInstance | null;
+  isRoot: boolean | undefined;
+};
+type LifecycleCommitBatch = {
+  parent: LifecycleCommitBatch | null;
+  entries: LifecycleCommitBatchEntry[];
+  entriesByInstance: Map<ComponentInstance, LifecycleCommitBatchEntry>;
+  readCommits: ReadSubscriptionCommit[];
+  readCommitsByInstance: Map<ComponentInstance, ReadSubscriptionCommit>;
+  renderSnapshots: InlineRenderSnapshot[];
+  renderSnapshotsByInstance: Map<ComponentInstance, InlineRenderSnapshot>;
+  active: boolean;
+};
+declare function beginLifecycleCommitBatch(): LifecycleCommitBatch;
+declare function captureInlineRenderSnapshot(instance: ComponentInstance): void;
+declare function finalizeInlineReadSubscriptions(instance: ComponentInstance, token: number, pendingReadSources: Set<ReadableSource<unknown>> | undefined, pendingReadSourceVersions: Map<ReadableSource<unknown>, number> | undefined): void;
+declare function flushLifecycleCommitBatch(batch: LifecycleCommitBatch): void;
+declare function discardLifecycleCommitBatch(batch: LifecycleCommitBatch): void;
+declare function registerMountOperationForInstance(instance: ComponentInstance | null, operation: LifecycleOperation): void;
+declare function registerCommitOperationForInstance(instance: ComponentInstance | null, operation: LifecycleOperation): void;
+declare function discardCommitOperations(instance: ComponentInstance): void;
+declare function executeCommittedLifecycleOperations(instance: ComponentInstance, wasFirstMount: boolean): void;
+declare function commitLifecycleForInstance(instance: ComponentInstance, wasFirstMount: boolean): void;
+declare function commitRenderedComponent(instance: ComponentInstance): void;
+//#endregion
+export { LifecycleCommitBatch, LifecycleOperation };
+//# sourceMappingURL=component-lifecycle.d.ts.map

package/dist/runtime/component-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-lifecycle.d.ts","names":[],"sources":["../../src/runtime/component-lifecycle.ts"],"mappings":";;;;;;KAYY,kBAAA,+BAGR,WAAW;AAAA,KAEV,yBAAA;EACH,QAAA,EAAU,iBAAiB;EAC3B,aAAA;AAAA;AAAA,KAGG,sBAAA;EACH,QAAA,EAAU,iBAAA;EACV,KAAA;EACA,kBAAA,EAAoB,GAAA,CAAI,cAAA;EACxB,yBAAA,EAA2B,GAAA,CAAI,cAAA;AAAA;AAAA,KAG5B,oBAAA;EACH,QAAA,EAAU,iBAAA;EACV,KAAA,EAAO,KAAA;EACP,UAAA,EAAY,YAAA;EACZ,WAAA;EACA,cAAA,EAAgB,iBAAA;EAChB,MAAA;AAAA;AAAA,KAGU,oBAAA;EACV,MAAA,EAAQ,oBAAA;EACR,OAAA,EAAS,yBAAA;EACT,iBAAA,EAAmB,GAAA,CAAI,iBAAA,EAAmB,yBAAA;EAC1C,WAAA,EAAa,sBAAA;EACb,qBAAA,EAAuB,GAAA,CAAI,iBAAA,EAAmB,sBAAA;EAC9C,eAAA,EAAiB,oBAAA;EACjB,yBAAA,EAA2B,GAAA,CAAI,iBAAA,EAAmB,oBAAA;EAClD,MAAA;AAAA;AAAA,iBAKc,yBAAA,IAA6B,oBAAoB;AAAA,iBAkFjD,2BAAA,CAA4B,QAA2B,EAAjB,iBAAiB;AAAA,iBAevD,+BAAA,CACd,QAAA,EAAU,iBAAA,EACV,KAAA,UACA,kBAAA,EAAoB,GAAA,CAAI,cAAA,wBACxB,yBAAA,EAA2B,GAAA,CAAI,cAAA;AAAA,iBAqBjB,yBAAA,CAA0B,KAA2B,EAApB,oBAAoB;AAAA,iBAsCrD,2BAAA,CAA4B,KAA2B,EAApB,oBAAoB;AAAA,iBAsBvD,iCAAA,CACd,QAAA,EAAU,iBAAA,SACV,SAAA,EAAW,kBAAkB;AAAA,iBAkBf,kCAAA,CACd,QAAA,EAAU,iBAAA,SACV,SAAA,EAAW,kBAAkB;AAAA,iBA6Ef,uBAAA,CAAwB,QAA2B,EAAjB,iBAAiB;AAAA,iBAInD,mCAAA,CACd,QAAA,EAAU,iBAAiB,EAC3B,aAAA;AAAA,iBAUc,0BAAA,CACd,QAAA,EAAU,iBAAiB,EAC3B,aAAA;AAAA,iBAcc,uBAAA,CAAwB,QAA2B,EAAjB,iBAAiB"}

package/dist/runtime/component-lifecycle.js

@@ -0,0 +1,176 @@
+import { isDevelopmentEnvironment } from "../common/env.js";
+import { logger } from "../dev/logger.js";
+import { finalizeReadableSubscriptionsFromSnapshot } from "./readable.js";
+import { isPromiseLike } from "../common/promise.js";
+import { isBulkCommitActive } from "./fastlane.js";
+//#region src/runtime/component-lifecycle.ts
+let currentLifecycleCommitBatch = null;
+function beginLifecycleCommitBatch() {
+	const batch = {
+		parent: currentLifecycleCommitBatch,
+		entries: [],
+		entriesByInstance: /* @__PURE__ */ new Map(),
+		readCommits: [],
+		readCommitsByInstance: /* @__PURE__ */ new Map(),
+		renderSnapshots: [],
+		renderSnapshotsByInstance: /* @__PURE__ */ new Map(),
+		active: true
+	};
+	currentLifecycleCommitBatch = batch;
+	return batch;
+}
+function closeLifecycleCommitBatch(batch) {
+	if (!batch.active) return false;
+	batch.active = false;
+	currentLifecycleCommitBatch = batch.parent;
+	return true;
+}
+function enqueueLifecycleCommit(batch, instance, wasFirstMount) {
+	const existing = batch.entriesByInstance.get(instance);
+	if (existing) {
+		existing.wasFirstMount = existing.wasFirstMount || wasFirstMount;
+		return;
+	}
+	const entry = {
+		instance,
+		wasFirstMount
+	};
+	batch.entriesByInstance.set(instance, entry);
+	batch.entries.push(entry);
+}
+function enqueueReadSubscriptionCommit(batch, instance, token, pendingReadSources, pendingReadSourceVersions) {
+	const existing = batch.readCommitsByInstance.get(instance);
+	const commit = existing ?? {
+		instance,
+		token,
+		pendingReadSources,
+		pendingReadSourceVersions
+	};
+	commit.token = token;
+	commit.pendingReadSources = pendingReadSources ? new Set(pendingReadSources) : void 0;
+	commit.pendingReadSourceVersions = pendingReadSourceVersions ? new Map(pendingReadSourceVersions) : void 0;
+	if (!existing) {
+		batch.readCommitsByInstance.set(instance, commit);
+		batch.readCommits.push(commit);
+	}
+}
+function enqueueInlineRenderSnapshot(batch, snapshot) {
+	if (batch.renderSnapshotsByInstance.has(snapshot.instance)) return;
+	batch.renderSnapshotsByInstance.set(snapshot.instance, snapshot);
+	batch.renderSnapshots.push(snapshot);
+}
+function captureInlineRenderSnapshot(instance) {
+	if (!currentLifecycleCommitBatch?.active) return;
+	enqueueInlineRenderSnapshot(currentLifecycleCommitBatch, {
+		instance,
+		props: instance.props,
+		ownerFrame: instance.ownerFrame,
+		portalScope: instance.portalScope,
+		parentInstance: instance.parentInstance,
+		isRoot: instance.isRoot
+	});
+}
+function finalizeInlineReadSubscriptions(instance, token, pendingReadSources, pendingReadSourceVersions) {
+	if (currentLifecycleCommitBatch?.active) {
+		enqueueReadSubscriptionCommit(currentLifecycleCommitBatch, instance, token, pendingReadSources, pendingReadSourceVersions);
+		return;
+	}
+	finalizeReadableSubscriptionsFromSnapshot(instance, token, pendingReadSources, pendingReadSourceVersions);
+}
+function flushLifecycleCommitBatch(batch) {
+	if (!closeLifecycleCommitBatch(batch)) return;
+	if (batch.parent?.active) {
+		for (const snapshot of batch.renderSnapshots) enqueueInlineRenderSnapshot(batch.parent, snapshot);
+		for (const commit of batch.readCommits) enqueueReadSubscriptionCommit(batch.parent, commit.instance, commit.token, commit.pendingReadSources, commit.pendingReadSourceVersions);
+		for (const entry of batch.entries) enqueueLifecycleCommit(batch.parent, entry.instance, entry.wasFirstMount);
+		return;
+	}
+	for (const commit of batch.readCommits) finalizeReadableSubscriptionsFromSnapshot(commit.instance, commit.token, commit.pendingReadSources, commit.pendingReadSourceVersions);
+	for (const entry of batch.entries) executeCommittedLifecycleOperations(entry.instance, entry.wasFirstMount);
+}
+function discardLifecycleCommitBatch(batch) {
+	if (!closeLifecycleCommitBatch(batch)) return;
+	for (let index = batch.renderSnapshots.length - 1; index >= 0; index -= 1) {
+		const snapshot = batch.renderSnapshots[index];
+		snapshot.instance.props = snapshot.props;
+		snapshot.instance.ownerFrame = snapshot.ownerFrame;
+		snapshot.instance.portalScope = snapshot.portalScope;
+		snapshot.instance.parentInstance = snapshot.parentInstance;
+		snapshot.instance.isRoot = snapshot.isRoot;
+	}
+	for (const entry of batch.entries) {
+		if (entry.wasFirstMount) entry.instance.mountOperations = [];
+		discardCommitOperations(entry.instance);
+	}
+}
+function registerMountOperationForInstance(instance, operation) {
+	if (instance) {
+		if (isBulkCommitActive()) {
+			if (isDevelopmentEnvironment()) throw new Error("registerMountOperation called during bulk commit fast-lane");
+			return;
+		}
+		instance.mountOperations.push(operation);
+	}
+}
+function registerCommitOperationForInstance(instance, operation) {
+	if (instance) {
+		if (isBulkCommitActive()) {
+			if (isDevelopmentEnvironment()) throw new Error("registerCommitOperation called during bulk commit fast-lane");
+			return;
+		}
+		instance.commitOperations.push(operation);
+	}
+}
+function settleLifecycleOperationResult(instance, lifecycleGeneration, result) {
+	if (isPromiseLike(result)) Promise.resolve(result).then((cleanup) => {
+		if (typeof cleanup === "function") {
+			if (instance.lifecycleGeneration === lifecycleGeneration && instance.mounted) {
+				instance.cleanupFns.push(cleanup);
+				return;
+			}
+			try {
+				cleanup();
+			} catch (err) {
+				logger.error("[Askr] async mount cleanup failed:", err);
+			}
+		}
+	}, (err) => {
+		logger.error("[Askr] async mount operation failed:", err);
+	});
+	else if (typeof result === "function") instance.cleanupFns.push(result);
+}
+function executeMountOperations(instance) {
+	const mountOperations = instance.mountOperations;
+	if (mountOperations.length === 0) return;
+	const lifecycleGeneration = instance.lifecycleGeneration;
+	for (const operation of mountOperations) settleLifecycleOperationResult(instance, lifecycleGeneration, operation());
+	instance.mountOperations = [];
+}
+function executeCommitOperations(instance) {
+	const commitOperations = instance.commitOperations;
+	if (commitOperations.length === 0) return;
+	instance.commitOperations = [];
+	const lifecycleGeneration = instance.lifecycleGeneration;
+	for (const operation of commitOperations) settleLifecycleOperationResult(instance, lifecycleGeneration, operation());
+}
+function discardCommitOperations(instance) {
+	instance.commitOperations = [];
+}
+function executeCommittedLifecycleOperations(instance, wasFirstMount) {
+	if (wasFirstMount && instance.mountOperations.length > 0) executeMountOperations(instance);
+	if (instance.commitOperations.length > 0) executeCommitOperations(instance);
+}
+function commitLifecycleForInstance(instance, wasFirstMount) {
+	if (currentLifecycleCommitBatch) {
+		enqueueLifecycleCommit(currentLifecycleCommitBatch, instance, wasFirstMount);
+		return;
+	}
+	executeCommittedLifecycleOperations(instance, wasFirstMount);
+}
+function commitRenderedComponent(instance) {
+	if (instance.mounted && instance.commitOperations.length > 0) commitLifecycleForInstance(instance, false);
+}
+//#endregion
+export { beginLifecycleCommitBatch, captureInlineRenderSnapshot, commitLifecycleForInstance, commitRenderedComponent, discardCommitOperations, discardLifecycleCommitBatch, executeCommittedLifecycleOperations, finalizeInlineReadSubscriptions, flushLifecycleCommitBatch, registerCommitOperationForInstance, registerMountOperationForInstance };
+
+//# sourceMappingURL=component-lifecycle.js.map