@askrjs/askr 0.0.51 → 0.0.53

package/dist/runtime/component-commit.js

@@ -1,165 +0,0 @@
-import { isDevelopmentEnvironment } from "../common/env.js";
-import { logger } from "../common/logger.js";
-import { enqueueRuntimeTask, getRuntimeRenderer } from "./access.js";
-import { withContext } from "./context.js";
-import { incDevCounter, setDevValue } from "./dev-namespace.js";
-import { beginRenderTracking, enterDomCommitScope, restoreDomCommitScope } from "./component-scope.js";
-import { isPromiseLike } from "../common/promise.js";
-import { tryRuntimeFastLaneSync } from "./fastlane.js";
-import { beginLifecycleCommitBatch, discardCommitOperations, discardLifecycleCommitBatch, executeCommittedLifecycleOperations, flushLifecycleCommitBatch } from "./component-lifecycle.js";
-//#region src/runtime/component-commit.ts
-function runScheduledComponent(instance, host) {
-	instance.notifyUpdate = instance._enqueueRun;
-	beginRenderTracking(instance);
-	const domSnapshot = instance.target ? instance.target.innerHTML : "";
-	let result;
-	try {
-		result = host.execute(instance);
-	} catch (err) {
-		discardCommitOperations(instance);
-		throw err;
-	}
-	if (isPromiseLike(result)) throw new Error("Async components are not supported. Components must be synchronous.");
-	try {
-		if (tryRuntimeFastLaneSync(instance, result)) {
-			host.warnUnusedStateReads(instance);
-			return;
-		}
-	} catch (err) {
-		if (isDevelopmentEnvironment()) throw err;
-	}
-	enqueueRuntimeTask(() => {
-		if (!instance.target && instance._placeholder) {
-			commitPlaceholderReplacement(instance, result, host);
-			return;
-		}
-		if (instance.target) commitToTarget(instance, result, domSnapshot, host);
-	});
-}
-function commitPlaceholderReplacement(instance, result, host) {
-	if (result === null || result === void 0) {
-		host.finalizeReadSubscriptions(instance);
-		host.warnUnusedStateReads(instance);
-		host.commitRenderedComponent(instance);
-		return;
-	}
-	const placeholder = instance._placeholder;
-	const parent = placeholder.parentNode;
-	if (!parent) {
-		logger.warn("[Askr] placeholder no longer in DOM, cannot render component");
-		return;
-	}
-	const renderer = getRuntimeRenderer();
-	const hostElement = document.createElement("div");
-	const executionFrame = {
-		parent: instance.ownerFrame,
-		values: null
-	};
-	const oldInstance = enterDomCommitScope(instance);
-	const lifecycleBatch = beginLifecycleCommitBatch();
-	try {
-		try {
-			withContext(executionFrame, () => {
-				renderer.evaluate(result, hostElement);
-			});
-			parent.replaceChild(hostElement, placeholder);
-		} catch (err) {
-			discardLifecycleCommitBatch(lifecycleBatch);
-			throw err;
-		}
-		instance.target = hostElement;
-		instance._placeholder = void 0;
-		hostElement.__ASKR_INSTANCE = instance;
-		flushLifecycleCommitBatch(lifecycleBatch);
-		host.finalizeReadSubscriptions(instance);
-		host.warnUnusedStateReads(instance);
-		host.commitRenderedComponent(instance);
-	} finally {
-		restoreDomCommitScope(oldInstance);
-	}
-}
-function commitToTarget(instance, result, domSnapshot, host) {
-	const renderer = getRuntimeRenderer();
-	const target = instance.target;
-	let oldChildren = [];
-	let restoredOldChildren = false;
-	try {
-		const wasFirstMount = !instance.mounted;
-		const oldInstance = enterDomCommitScope(instance);
-		const executionFrame = {
-			parent: instance.ownerFrame,
-			values: null
-		};
-		oldChildren = Array.from(target.childNodes);
-		const lifecycleBatch = beginLifecycleCommitBatch();
-		try {
-			try {
-				withContext(executionFrame, () => {
-					renderer.evaluate(result, target, void 0, instance);
-				});
-			} catch (err) {
-				discardLifecycleCommitBatch(lifecycleBatch);
-				throw err;
-			}
-		} catch (err) {
-			cleanupFailedCommitChildren(renderer, target, oldChildren);
-			try {
-				incDevCounter("__DOM_REPLACE_COUNT");
-				setDevValue("__LAST_DOM_REPLACE_STACK_COMPONENT_RESTORE", (/* @__PURE__ */ new Error()).stack);
-			} catch (devErr) {}
-			target.replaceChildren(...oldChildren);
-			restoredOldChildren = true;
-			throw err;
-		} finally {
-			restoreDomCommitScope(oldInstance);
-		}
-		flushLifecycleCommitBatch(lifecycleBatch);
-		host.finalizeReadSubscriptions(instance);
-		host.warnUnusedStateReads(instance);
-		instance.mounted = true;
-		executeCommittedLifecycleOperations(instance, wasFirstMount);
-	} catch (renderError) {
-		discardCommitOperations(instance);
-		cleanupRollbackChildren(renderer, target, oldChildren, restoredOldChildren);
-		try {
-			incDevCounter("__DOM_REPLACE_COUNT");
-			setDevValue("__LAST_DOM_REPLACE_STACK_COMPONENT_ROLLBACK", (/* @__PURE__ */ new Error()).stack);
-			target.replaceChildren(...oldChildren);
-		} catch {
-			target.innerHTML = domSnapshot;
-		}
-		throw renderError;
-	}
-}
-function cleanupFailedCommitChildren(renderer, target, oldChildren) {
-	try {
-		const newChildren = Array.from(target.childNodes);
-		const preservedChildren = new Set(oldChildren);
-		for (const node of newChildren) {
-			if (preservedChildren.has(node)) continue;
-			try {
-				renderer.cleanupInstancesUnder(node);
-			} catch (err) {
-				logger.warn("[Askr] error cleaning up failed commit children:", err);
-			}
-		}
-	} catch (err) {}
-}
-function cleanupRollbackChildren(renderer, target, oldChildren, restoredOldChildren) {
-	try {
-		const currentChildren = Array.from(target.childNodes);
-		const preservedChildren = restoredOldChildren ? new Set(oldChildren) : null;
-		for (const node of currentChildren) {
-			if (preservedChildren?.has(node)) continue;
-			try {
-				renderer.cleanupInstancesUnder(node);
-			} catch (err) {
-				logger.warn("[Askr] error cleaning up partial children during rollback:", err);
-			}
-		}
-	} catch (err) {}
-}
-//#endregion
-export { runScheduledComponent };
-
-//# sourceMappingURL=component-commit.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"component-commit.js","names":[],"sources":["../../src/runtime/component-commit.ts"],"sourcesContent":["import { isDevelopmentEnvironment } from '../common/env';\nimport { isPromiseLike } from '../common/promise';\nimport { logger } from '../common/logger';\nimport { enqueueRuntimeTask, getRuntimeRenderer } from './access';\nimport {\n  beginLifecycleCommitBatch,\n  discardCommitOperations,\n  discardLifecycleCommitBatch,\n  executeCommittedLifecycleOperations,\n  flushLifecycleCommitBatch,\n} from './component-lifecycle';\nimport {\n  beginRenderTracking,\n  enterDomCommitScope,\n  restoreDomCommitScope,\n} from './component-scope';\nimport type { ContextFrame } from './context';\nimport { withContext } from './context';\nimport { incDevCounter, setDevValue } from './dev-namespace';\nimport { tryRuntimeFastLaneSync } from './fastlane';\nimport type { ComponentInstance } from './component-internal';\n\nexport interface ScheduledComponentCommitHost {\n  execute(instance: ComponentInstance): unknown | Promise<unknown>;\n  finalizeReadSubscriptions(instance: ComponentInstance): void;\n  warnUnusedStateReads(instance: ComponentInstance): void;\n  commitRenderedComponent(instance: ComponentInstance): void;\n}\n\nexport function runScheduledComponent(\n  instance: ComponentInstance,\n  host: ScheduledComponentCommitHost\n): void {\n  instance.notifyUpdate = instance._enqueueRun!;\n  beginRenderTracking(instance);\n  const domSnapshot = instance.target ? instance.target.innerHTML : '';\n\n  let result: unknown | Promise<unknown>;\n  try {\n    result = host.execute(instance);\n  } catch (err) {\n    discardCommitOperations(instance);\n    throw err;\n  }\n\n  if (isPromiseLike(result)) {\n    throw new Error(\n      'Async components are not supported. Components must be synchronous.'\n    );\n  }\n\n  try {\n    const used = tryRuntimeFastLaneSync(instance, result);\n    if (used) {\n      host.warnUnusedStateReads(instance);\n      return;\n    }\n  } catch (err) {\n    if (isDevelopmentEnvironment()) throw err;\n  }\n\n  enqueueRuntimeTask(() => {\n    if (!instance.target && instance._placeholder) {\n      commitPlaceholderReplacement(instance, result, host);\n      return;\n    }\n\n    if (instance.target) {\n      commitToTarget(instance, result, domSnapshot, host);\n    }\n  });\n}\n\nfunction commitPlaceholderReplacement(\n  instance: ComponentInstance,\n  result: unknown,\n  host: ScheduledComponentCommitHost\n): void {\n  if (result === null || result === undefined) {\n    host.finalizeReadSubscriptions(instance);\n    host.warnUnusedStateReads(instance);\n    host.commitRenderedComponent(instance);\n    return;\n  }\n\n  const placeholder = instance._placeholder!;\n  const parent = placeholder.parentNode;\n  if (!parent) {\n    logger.warn('[Askr] placeholder no longer in DOM, cannot render component');\n    return;\n  }\n\n  const renderer = getRuntimeRenderer();\n  const hostElement = document.createElement('div');\n  const executionFrame: ContextFrame = {\n    parent: instance.ownerFrame,\n    values: null,\n  };\n\n  const oldInstance = enterDomCommitScope(instance);\n  const lifecycleBatch = beginLifecycleCommitBatch();\n  try {\n    try {\n      withContext(executionFrame, () => {\n        renderer.evaluate(result, hostElement);\n      });\n      parent.replaceChild(hostElement, placeholder);\n    } catch (err) {\n      discardLifecycleCommitBatch(lifecycleBatch);\n      throw err;\n    }\n\n    instance.target = hostElement;\n    instance._placeholder = undefined;\n    (\n      hostElement as Element & {\n        __ASKR_INSTANCE?: ComponentInstance;\n      }\n    ).__ASKR_INSTANCE = instance;\n\n    flushLifecycleCommitBatch(lifecycleBatch);\n    host.finalizeReadSubscriptions(instance);\n    host.warnUnusedStateReads(instance);\n    host.commitRenderedComponent(instance);\n  } finally {\n    restoreDomCommitScope(oldInstance);\n  }\n}\n\nfunction commitToTarget(\n  instance: ComponentInstance,\n  result: unknown,\n  domSnapshot: string,\n  host: ScheduledComponentCommitHost\n): void {\n  const renderer = getRuntimeRenderer();\n  const target = instance.target!;\n  let oldChildren: Node[] = [];\n  let restoredOldChildren = false;\n\n  try {\n    const wasFirstMount = !instance.mounted;\n    const oldInstance = enterDomCommitScope(instance);\n    const executionFrame: ContextFrame = {\n      parent: instance.ownerFrame,\n      values: null,\n    };\n    oldChildren = Array.from(target.childNodes);\n\n    const lifecycleBatch = beginLifecycleCommitBatch();\n    try {\n      try {\n        withContext(executionFrame, () => {\n          renderer.evaluate(result, target, undefined, instance);\n        });\n      } catch (err) {\n        discardLifecycleCommitBatch(lifecycleBatch);\n        throw err;\n      }\n    } catch (err) {\n      cleanupFailedCommitChildren(renderer, target, oldChildren);\n      try {\n        incDevCounter('__DOM_REPLACE_COUNT');\n        setDevValue(\n          '__LAST_DOM_REPLACE_STACK_COMPONENT_RESTORE',\n          new Error().stack\n        );\n      } catch (devErr) {\n        void devErr;\n      }\n      target.replaceChildren(...oldChildren);\n      restoredOldChildren = true;\n      throw err;\n    } finally {\n      restoreDomCommitScope(oldInstance);\n    }\n\n    flushLifecycleCommitBatch(lifecycleBatch);\n    host.finalizeReadSubscriptions(instance);\n    host.warnUnusedStateReads(instance);\n    instance.mounted = true;\n    executeCommittedLifecycleOperations(instance, wasFirstMount);\n  } catch (renderError) {\n    discardCommitOperations(instance);\n    cleanupRollbackChildren(renderer, target, oldChildren, restoredOldChildren);\n\n    try {\n      incDevCounter('__DOM_REPLACE_COUNT');\n      setDevValue(\n        '__LAST_DOM_REPLACE_STACK_COMPONENT_ROLLBACK',\n        new Error().stack\n      );\n      target.replaceChildren(...oldChildren);\n    } catch {\n      target.innerHTML = domSnapshot;\n    }\n\n    throw renderError;\n  }\n}\n\nfunction cleanupFailedCommitChildren(\n  renderer: ReturnType<typeof getRuntimeRenderer>,\n  target: Element,\n  oldChildren: Node[]\n): void {\n  try {\n    const newChildren = Array.from(target.childNodes);\n    const preservedChildren = new Set(oldChildren);\n    for (const node of newChildren) {\n      if (preservedChildren.has(node)) {\n        continue;\n      }\n      try {\n        renderer.cleanupInstancesUnder(node);\n      } catch (err) {\n        logger.warn('[Askr] error cleaning up failed commit children:', err);\n      }\n    }\n  } catch (err) {\n    void err;\n  }\n}\n\nfunction cleanupRollbackChildren(\n  renderer: ReturnType<typeof getRuntimeRenderer>,\n  target: Element,\n  oldChildren: Node[],\n  restoredOldChildren: boolean\n): void {\n  try {\n    const currentChildren = Array.from(target.childNodes);\n    const preservedChildren = restoredOldChildren ? new Set(oldChildren) : null;\n    for (const node of currentChildren) {\n      if (preservedChildren?.has(node)) {\n        continue;\n      }\n      try {\n        renderer.cleanupInstancesUnder(node);\n      } catch (err) {\n        logger.warn(\n          '[Askr] error cleaning up partial children during rollback:',\n          err\n        );\n      }\n    }\n  } catch (err) {\n    void err;\n  }\n}\n"],"mappings":"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"}

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

@@ -1,5 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,100 +0,0 @@
-import { Props } from "../common/props.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 { ReadableSource } from "./readable.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

@@ -1 +0,0 @@
-{"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

@@ -1,219 +0,0 @@
-import { isDevelopmentEnvironment, isProductionEnvironment } from "../common/env.js";
-import { logger } from "../common/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

@@ -1 +0,0 @@
-{"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 '../common/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

@@ -1,49 +0,0 @@
-import { Props } from "../common/props.js";
-import { ContextFrame } from "./context.js";
-import { ComponentInstance } from "./component-internal.js";
-import { ReadableSource } from "./readable.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

@@ -1 +0,0 @@
-{"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"}