@askrjs/askr 0.0.28 → 0.0.29

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

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/runtime/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAMhD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAmBhC,MAAM,WAAW,OAAO,CAAC,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAC;IAEzB,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,UAAU,CAAC;CAC/E;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAE5B,MAAM,EAAE,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACzC;AAGD,eAAO,MAAM,oBAAoB,eAAkC,CAAC;AAWpE;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQzE;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,KAAK,EAAE,YAAY,GAAG,IAAI,EAC1B,EAAE,EAAE,MAAM,CAAC,GACV,CAAC,CAUH;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAmB5D;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAqBrD;AAsID;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,YAAY,CAU/C;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAItC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,YAAY,GAAG,IAAI,CAE5D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,YAAY,GAAG,IAAI,CAE3D"}
+{"version":3,"file":"context.d.ts","names":[],"sources":["../../src/runtime/context.ts"],"mappings":";;;KA4BY,UAAA;AAAA,UAmBK,OAAA;EAAA,SACN,GAAA,EAAK,UAAA;EAAA,SACL,YAAA,EAAc,CAAA;EAAA,SAEd,KAAA,GAAQ,KAAA;IAAS,KAAA;IAAgB,QAAA;EAAA,MAAyB,UAAA;AAAA;AAAA,UAGpD,YAAA;EACf,MAAA,EAAQ,YAAA;EAER,MAAA,EAAQ,GAAA,CAAI,UAAA;AAAA;AAAA,cAID,oBAAA;AAAA,iBAQG,oBAAA,CAAqB,IAAA,YAAgB,YAAA;AAAA,iBASrC,yBAAA,CACd,IAAA,WACA,KAAA,EAAO,YAAA,EACP,SAAA;AAAA,iBAsEc,6BAAA,CACd,IAAA,WACA,KAAA,EAAO,YAAA,SACP,SAAA;;;;;AA7FF;;;;;AAQA;;iBAoJgB,WAAA,GAAA,CAAe,KAAA,EAAO,YAAA,SAAqB,EAAA,QAAU,CAAA,GAAI,CAAA;;;AA3IzE;;;;;;;iBA8JgB,wBAAA,GAAA,CACd,KAAA,EAAO,YAAA,SACP,EAAA,QAAU,CAAA,GACT,CAAA;AAAA,iBAYa,aAAA,GAAA,CAAiB,YAAA,EAAc,CAAA,GAAI,OAAA,CAAQ,CAAA;AAAA,iBA0C3C,WAAA,GAAA,CAAe,OAAA,EAAS,OAAA,CAAQ,CAAA,IAAK,CAAA;AA9IrD;;;;AAAA,iBA6RgB,gBAAA,CAAA,GAAoB,YAAA;;;;;iBAgBpB,eAAA,CAAA;AA3OhB;;;AAAA,iBAoPgB,sBAAA,CAAA,GAA0B,YAAA;;;;;iBAQ1B,qBAAA,CAAA,GAAyB,YAAA"}

package/dist/runtime/context.js

@@ -1 +1,205 @@
-import{ELEMENT_TYPE as C}from"../common/jsx.js";import{getCurrentComponentInstance as s}from"./component.js";const h=Symbol("__tempoContextFrame__");let o=null,a=null;function F(n,r){const t=o;o=n;try{return r()}finally{o=t}}function v(n,r){const t=a;a=n;try{return r()}finally{a=t}}function w(n){const r=Symbol("AskrContext");return{key:r,defaultValue:n,Scope:t=>{const e=t.value;return{$$typeof:C,type:d,props:{key:r,value:e,children:t.children},key:null}}}}function A(n){const r=o||a;if(!r)throw new Error("readContext() can only be called during component render or async resource execution. Ensure you are calling this from inside your component or resource function.");let t=r;for(;t;){const e=t.values;if(e&&e.has(n.key))return e.get(n.key);t=t.parent}return n.defaultValue}function d(n){const r=n.key,t=n.value,e=n.children,u=s(),l={parent:o||(u&&u.ownerFrame?u.ownerFrame:null),values:new Map([[r,t]])};function m(c,y,p){return{type:x,props:{fn:c,__frame:y,__owner:p}}}return Array.isArray(e)?e.map(c=>typeof c=="function"?m(c,l,s()):i(c,l)):typeof e=="function"?m(e,l,s()):e?i(e,l):null}function i(n,r){if(typeof n=="object"&&n!==null){const t=n;t[h]=r;const e=t.children;if(Array.isArray(e))for(let u=0;u<e.length;u++){const f=e[u];f&&(e[u]=i(f,r))}else e&&(t.children=i(e,r))}return n}function x(n){const{fn:r,__frame:t}=n,e=F(t,()=>r());return e?i(e,t):null}function E(){const n={parent:o,values:null};return o=n,n}function g(){o&&(o=o.parent)}function S(){return o}function b(){return o}export{h as CONTEXT_FRAME_SYMBOL,w as defineContext,S as getCurrentContextFrame,b as getTopContextSnapshot,g as popContextFrame,E as pushContextFrame,A as readContext,v as withAsyncResourceContext,F as withContext};
+import { ELEMENT_TYPE, STATIC_CHILDREN } from "../common/jsx.js";
+import { getCurrentComponentInstance } from "./component.js";
+//#region src/runtime/context.ts
+const CONTEXT_FRAME_SYMBOL = Symbol("__tempoContextFrame__");
+const vnodeContextFrames = /* @__PURE__ */ new WeakMap();
+function getVNodeContextFrame(node) {
+	if (typeof node !== "object" || node === null) return;
+	const objectNode = node;
+	return vnodeContextFrames.get(node) ?? objectNode[CONTEXT_FRAME_SYMBOL];
+}
+function markVNodeWithContextFrame(node, frame, overwrite = false) {
+	if (typeof node !== "object" || node === null) return;
+	if (!overwrite && getVNodeContextFrame(node)) return;
+	const objectNode = node;
+	if (Object.prototype.hasOwnProperty.call(node, CONTEXT_FRAME_SYMBOL)) try {
+		objectNode[CONTEXT_FRAME_SYMBOL] = frame;
+		return;
+	} catch {}
+	if (Object.isExtensible(node)) try {
+		Object.defineProperty(node, CONTEXT_FRAME_SYMBOL, {
+			value: frame,
+			writable: true,
+			enumerable: true,
+			configurable: true
+		});
+		return;
+	} catch {}
+	vnodeContextFrames.set(node, frame);
+}
+function isVNodeLike(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const objectValue = value;
+	if (objectValue.$$typeof === ELEMENT_TYPE) return true;
+	return "type" in objectValue && ("props" in objectValue || "children" in objectValue);
+}
+function markContextPropValue(value, frame, overwrite) {
+	if (Array.isArray(value)) {
+		for (const item of value) markContextPropValue(item, frame, overwrite);
+		return;
+	}
+	if (isVNodeLike(value)) markVNodeTreeWithContextFrame(value, frame, overwrite);
+}
+function markVNodeTreeWithContextFrame(node, frame, overwrite = false) {
+	if (!frame) return node;
+	if (Array.isArray(node)) {
+		for (const child of node) markVNodeTreeWithContextFrame(child, frame, overwrite);
+		return node;
+	}
+	if (typeof node !== "object" || node === null) return node;
+	markVNodeWithContextFrame(node, frame, overwrite);
+	const objectNode = node;
+	const props = typeof objectNode.props === "object" && objectNode.props !== null ? objectNode.props : null;
+	const children = props?.children ?? objectNode.children;
+	if (Array.isArray(children)) for (const child of children) markVNodeTreeWithContextFrame(child, frame, overwrite);
+	else if (children) markVNodeTreeWithContextFrame(children, frame, overwrite);
+	if (props) {
+		for (const key in props) if (key !== "children") markContextPropValue(props[key], frame, overwrite);
+	}
+	return node;
+}
+let currentContextFrame = null;
+let currentAsyncResourceFrame = null;
+/**
+* Execute a function within a specific context frame.
+*
+* CORE PRIMITIVE for context restoration:
+* - Saves the current context
+* - Sets the provided frame as current
+* - Executes the function
+* - Restores the previous context in finally
+*
+* This ensures no context frame remains globally active across await.
+*/
+function withContext(frame, fn) {
+	const oldFrame = currentContextFrame;
+	currentContextFrame = frame;
+	try {
+		return fn();
+	} finally {
+		currentContextFrame = oldFrame;
+	}
+}
+/**
+* Execute an async resource step within its frozen context snapshot.
+*
+* CRITICAL: This wrapper is applied only to synchronous execution steps of
+* an async resource (the initial call). We intentionally DO NOT restore
+* the resource frame for post-await continuations — continuations must not
+* observe or rely on a live resource frame. This keeps semantics simple and
+* deterministic: async resources see only their creation-time snapshot.
+*/
+function withAsyncResourceContext(frame, fn) {
+	const oldFrame = currentAsyncResourceFrame;
+	currentAsyncResourceFrame = frame;
+	try {
+		return fn();
+	} finally {
+		currentAsyncResourceFrame = oldFrame;
+	}
+}
+function defineContext(defaultValue) {
+	const key = Symbol("AskrContext");
+	return {
+		key,
+		defaultValue,
+		Scope: (props) => {
+			return {
+				$$typeof: ELEMENT_TYPE,
+				type: ContextScopeComponent,
+				props: {
+					key,
+					value: props.value,
+					children: props.children
+				},
+				key: null
+			};
+		}
+	};
+}
+function preserveStaticChildrenMarker(source, target) {
+	if (source[STATIC_CHILDREN] === true) Object.defineProperty(target, STATIC_CHILDREN, {
+		value: true,
+		enumerable: false,
+		configurable: true
+	});
+	return target;
+}
+function readContext(context) {
+	const frame = currentContextFrame || currentAsyncResourceFrame;
+	if (!frame) throw new Error("readContext() can only be called during component render or async resource execution. Ensure you are calling this from inside your component or resource function.");
+	let current = frame;
+	while (current) {
+		const values = current.values;
+		if (values && values.has(context.key)) return values.get(context.key);
+		current = current.parent;
+	}
+	return context.defaultValue;
+}
+/**
+* Internal component that manages context frame
+* Used by Context.Scope to provide shadowed value to children
+*/
+function ContextScopeComponent(props) {
+	const key = props["key"];
+	const value = props["value"];
+	const children = props["children"];
+	const instance = getCurrentComponentInstance();
+	const newFrame = {
+		parent: (() => {
+			if (currentContextFrame) return currentContextFrame;
+			if (instance && instance.ownerFrame) return instance.ownerFrame;
+			return null;
+		})(),
+		values: new Map([[key, value]])
+	};
+	function createFunctionChildInvoker(fn, frame, owner) {
+		return {
+			type: ContextFunctionChildInvoker,
+			props: {
+				fn,
+				__frame: frame,
+				__owner: owner
+			}
+		};
+	}
+	if (Array.isArray(children)) return preserveStaticChildrenMarker(children, children.map((child) => {
+		if (typeof child === "function") return createFunctionChildInvoker(child, newFrame, getCurrentComponentInstance());
+		return markWithFrame(child, newFrame);
+	}));
+	else if (typeof children === "function") return createFunctionChildInvoker(children, newFrame, getCurrentComponentInstance());
+	else if (children) return markWithFrame(children, newFrame);
+	return null;
+}
+/**
+* Internal: Mark a vnode with a context frame
+* The renderer will restore this frame before executing component functions
+*/
+function markWithFrame(node, frame) {
+	return markVNodeTreeWithContextFrame(node, frame, true);
+}
+/**
+* Internal helper component: executes a function-child lazily inside the
+* provided frame and marks the returned subtree with that frame so later
+* component executions will restore the correct context frame.
+*
+* SNAPSHOT SEMANTIC: The frame passed here is the snapshot captured at render
+* time. Any resources created during this execution will observe this frozen
+* snapshot, ensuring deterministic behavior.
+*/
+function ContextFunctionChildInvoker(props) {
+	const { fn, __frame } = props;
+	const res = withContext(__frame, () => fn());
+	if (res) return markWithFrame(res, __frame);
+	return null;
+}
+/**
+* Get the current context frame for inspection (used by tests/diagnostics only)
+*/
+function getCurrentContextFrame() {
+	return currentContextFrame;
+}
+//#endregion
+export { defineContext, getCurrentContextFrame, getVNodeContextFrame, markVNodeTreeWithContextFrame, readContext, withAsyncResourceContext, withContext };
+
+//# sourceMappingURL=context.js.map

package/dist/runtime/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","names":[],"sources":["../../src/runtime/context.ts"],"sourcesContent":["/**\n * Context system: lexical scope + render-time snapshots\n *\n * CORE SEMANTIC (Option A — Snapshot-Based):\n * ============================================\n * An async resource observes the context of the render that created it.\n * Context changes only take effect via re-render, not magically mid-await.\n *\n * This ensures:\n * - Deterministic behavior\n * - Concurrency safety\n * - Replayable execution\n * - Debuggability\n *\n * INVARIANTS:\n * - readContext() only works during component render (has currentContextFrame)\n * - Each render captures a context snapshot\n * - Async continuations see the snapshot from render start (frozen)\n * - Provider (Scope) creates a new frame that shadows parent\n * - Context updates require re-render to take effect\n */\n\nimport type { JSXElement } from '../common/jsx';\nimport { ELEMENT_TYPE, STATIC_CHILDREN } from '../common/jsx';\nimport type { Props } from '../common/props';\nimport { getCurrentComponentInstance } from './component';\nimport type { ComponentInstance } from './component';\n\nexport type ContextKey = symbol;\n\n// Lightweight VNode definition used for JSX typing in this module\ntype VNode = {\n  type: string;\n  props?: Record<string, unknown>;\n  children?: (string | VNode | null | undefined | false)[];\n};\n\n// Union of allowed render return values (text, vnode, JSX element, etc.)\ntype Renderable =\n  | JSXElement\n  | VNode\n  | string\n  | number\n  | null\n  | undefined\n  | false;\n\nexport interface Context<T> {\n  readonly key: ContextKey;\n  readonly defaultValue: T;\n  // A Scope is a JSX-style element factory returning a JSXElement (component invocation)\n  readonly Scope: (props: { value: unknown; children?: unknown }) => JSXElement;\n}\n\nexport interface ContextFrame {\n  parent: ContextFrame | null;\n  // Lazily allocate `values` Map only when a provider sets values or a read occurs.\n  values: Map<ContextKey, unknown> | null;\n}\n\n// Symbol to mark vnodes that need frame restoration\nexport const CONTEXT_FRAME_SYMBOL = Symbol('__tempoContextFrame__');\n\ntype ContextFrameCarrier = {\n  [CONTEXT_FRAME_SYMBOL]?: ContextFrame;\n};\n\nconst vnodeContextFrames = new WeakMap<object, ContextFrame>();\n\nexport function getVNodeContextFrame(node: unknown): ContextFrame | undefined {\n  if (typeof node !== 'object' || node === null) {\n    return undefined;\n  }\n\n  const objectNode = node as ContextFrameCarrier;\n  return vnodeContextFrames.get(node) ?? objectNode[CONTEXT_FRAME_SYMBOL];\n}\n\nexport function markVNodeWithContextFrame(\n  node: unknown,\n  frame: ContextFrame,\n  overwrite = false\n): void {\n  if (typeof node !== 'object' || node === null) {\n    return;\n  }\n\n  if (!overwrite && getVNodeContextFrame(node)) {\n    return;\n  }\n\n  const objectNode = node as ContextFrameCarrier;\n  if (Object.prototype.hasOwnProperty.call(node, CONTEXT_FRAME_SYMBOL)) {\n    try {\n      objectNode[CONTEXT_FRAME_SYMBOL] = frame;\n      return;\n    } catch {\n      // Fall through to WeakMap metadata when the symbol slot is readonly.\n    }\n  }\n\n  if (Object.isExtensible(node)) {\n    try {\n      Object.defineProperty(node, CONTEXT_FRAME_SYMBOL, {\n        value: frame,\n        writable: true,\n        enumerable: true,\n        configurable: true,\n      });\n      return;\n    } catch {\n      // Fall through to WeakMap metadata for exotic objects/proxies.\n    }\n  }\n\n  vnodeContextFrames.set(node, frame);\n}\n\nfunction isVNodeLike(value: unknown): boolean {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n    return false;\n  }\n\n  const objectValue = value as Record<string | symbol, unknown>;\n  if (objectValue.$$typeof === ELEMENT_TYPE) {\n    return true;\n  }\n\n  return (\n    'type' in objectValue &&\n    ('props' in objectValue || 'children' in objectValue)\n  );\n}\n\nfunction markContextPropValue(\n  value: unknown,\n  frame: ContextFrame,\n  overwrite: boolean\n): void {\n  if (Array.isArray(value)) {\n    for (const item of value) {\n      markContextPropValue(item, frame, overwrite);\n    }\n    return;\n  }\n\n  if (isVNodeLike(value)) {\n    markVNodeTreeWithContextFrame(value, frame, overwrite);\n  }\n}\n\nexport function markVNodeTreeWithContextFrame(\n  node: unknown,\n  frame: ContextFrame | null,\n  overwrite = false\n): unknown {\n  if (!frame) return node;\n\n  if (Array.isArray(node)) {\n    for (const child of node) {\n      markVNodeTreeWithContextFrame(child, frame, overwrite);\n    }\n    return node;\n  }\n\n  if (typeof node !== 'object' || node === null) {\n    return node;\n  }\n\n  markVNodeWithContextFrame(node, frame, overwrite);\n\n  const objectNode = node as Record<string | symbol, unknown>;\n  const props =\n    typeof objectNode.props === 'object' && objectNode.props !== null\n      ? (objectNode.props as Record<string, unknown>)\n      : null;\n  const children = (props?.children ?? objectNode.children) as unknown;\n\n  if (Array.isArray(children)) {\n    for (const child of children) {\n      markVNodeTreeWithContextFrame(child, frame, overwrite);\n    }\n  } else if (children) {\n    markVNodeTreeWithContextFrame(children, frame, overwrite);\n  }\n\n  if (props) {\n    for (const key in props) {\n      if (key !== 'children') {\n        markContextPropValue(props[key], frame, overwrite);\n      }\n    }\n  }\n\n  return node;\n}\n\n// Global context frame stack (maintained during render)\n// INVARIANT: Must NEVER be non-null across an await boundary\nlet currentContextFrame: ContextFrame | null = null;\n\n// Async resource frame (maintained during async resource execution)\n// INVARIANT: Set only for synchronous execution steps, cleared in finally\n// This allows async resources to access their frozen render-time snapshot\nlet currentAsyncResourceFrame: ContextFrame | null = null;\n\n/**\n * Execute a function within a specific context frame.\n *\n * CORE PRIMITIVE for context restoration:\n * - Saves the current context\n * - Sets the provided frame as current\n * - Executes the function\n * - Restores the previous context in finally\n *\n * This ensures no context frame remains globally active across await.\n */\nexport function withContext<T>(frame: ContextFrame | null, fn: () => T): T {\n  const oldFrame = currentContextFrame;\n  currentContextFrame = frame;\n  try {\n    return fn();\n  } finally {\n    currentContextFrame = oldFrame;\n  }\n}\n\n/**\n * Execute an async resource step within its frozen context snapshot.\n *\n * CRITICAL: This wrapper is applied only to synchronous execution steps of\n * an async resource (the initial call). We intentionally DO NOT restore\n * the resource frame for post-await continuations — continuations must not\n * observe or rely on a live resource frame. This keeps semantics simple and\n * deterministic: async resources see only their creation-time snapshot.\n */\nexport function withAsyncResourceContext<T>(\n  frame: ContextFrame | null,\n  fn: () => T\n): T {\n  const oldFrame = currentAsyncResourceFrame;\n  // Only set the frame for the synchronous execution step\n  currentAsyncResourceFrame = frame;\n  try {\n    return fn();\n  } finally {\n    // Clear the frame to avoid exposing it across await boundaries\n    currentAsyncResourceFrame = oldFrame;\n  }\n}\n\nexport function defineContext<T>(defaultValue: T): Context<T> {\n  const key = Symbol('AskrContext');\n\n  return {\n    key,\n    defaultValue,\n    Scope: (props: { value: unknown; children?: unknown }): JSXElement => {\n      // Scope component: accepts an unknown value (tests often pass loosely typed values)\n      // Cast to the expected T at the call site to preserve runtime behavior.\n      const value = props.value as T;\n      // Scope component: creates a new frame and renders children within it\n      return {\n        $$typeof: ELEMENT_TYPE,\n        type: ContextScopeComponent,\n        props: { key, value, children: props.children },\n        key: null,\n      } as JSXElement;\n    },\n  };\n}\n\nfunction preserveStaticChildrenMarker(\n  source: readonly unknown[],\n  target: unknown[]\n): unknown[] {\n  if (\n    (\n      source as {\n        [STATIC_CHILDREN]?: boolean;\n      }\n    )[STATIC_CHILDREN] === true\n  ) {\n    Object.defineProperty(target, STATIC_CHILDREN, {\n      value: true,\n      enumerable: false,\n      configurable: true,\n    });\n  }\n\n  return target;\n}\n\nexport function readContext<T>(context: Context<T>): T {\n  // Check render frame first (components), then async resource frame (resources)\n  const frame = currentContextFrame || currentAsyncResourceFrame;\n\n  if (!frame) {\n    throw new Error(\n      'readContext() can only be called during component render or async resource execution. ' +\n        'Ensure you are calling this from inside your component or resource function.'\n    );\n  }\n\n  let current: ContextFrame | null = frame;\n  while (current) {\n    // `values` may be null when no provider has created it yet — treat as empty\n    const values = current.values;\n    if (values && values.has(context.key)) {\n      return values.get(context.key) as T;\n    }\n    current = current.parent;\n  }\n  return context.defaultValue;\n}\n\n/**\n * Internal component that manages context frame\n * Used by Context.Scope to provide shadowed value to children\n */\nfunction ContextScopeComponent(props: Props): Renderable {\n  // Extract expected properties (we accept a loose shape so this can be used as a component type)\n  const key = props['key'] as ContextKey;\n  const value = props['value'];\n  const children = props['children'] as Renderable;\n\n  // Create a new frame with this value\n  const instance = getCurrentComponentInstance();\n  const parentFrame: ContextFrame | null = (() => {\n    // Prefer the live render frame.\n    // Note: the runtime executes component functions inside an empty \"render frame\"\n    // whose parent points at the nearest provider chain. Even if this frame has no\n    // values, it must still be used to preserve the parent linkage.\n    if (currentContextFrame) return currentContextFrame;\n\n    // If there is no live render frame (should be rare), fall back to the\n    // instance's owner frame.\n    if (instance && instance.ownerFrame) return instance.ownerFrame;\n\n    // Do NOT fall back to the async snapshot stack here: that stack represents\n    // unrelated async continuations and must not affect lexical provider chaining.\n    return null;\n  })();\n\n  const newFrame: ContextFrame = {\n    parent: parentFrame,\n    values: new Map([[key, value]]),\n  };\n\n  // Helper: create a function-child invoker node (centralized cast)\n  function createFunctionChildInvoker(\n    fn: () => Renderable,\n    frame: ContextFrame,\n    owner: ComponentInstance | null\n  ): Renderable {\n    return {\n      type: ContextFunctionChildInvoker,\n      props: { fn, __frame: frame, __owner: owner },\n    } as unknown as Renderable;\n  }\n\n  // The renderer will set ownerFrame on child component instances when they're created.\n  // We mark vnodes with the frame so the renderer knows which frame to assign.\n  if (Array.isArray(children)) {\n    // Mark array elements with the frame. If an element is a function-child,\n    // convert it into a lazy invoker so it's executed later inside the frame.\n    return preserveStaticChildrenMarker(\n      children,\n      children.map((child) => {\n        if (typeof child === 'function') {\n          return createFunctionChildInvoker(\n            child as () => Renderable,\n            newFrame,\n            getCurrentComponentInstance()\n          );\n        }\n        return markWithFrame(child, newFrame);\n      })\n    ) as unknown as Renderable;\n  } else if (typeof children === 'function') {\n    // If children is a function (render callback), do NOT execute it eagerly\n    // during the parent render. Instead, return a small internal component\n    // that will execute the function later (when it itself is rendered) and\n    // will execute it within the provider frame so any reads performed during\n    // that execution observe the provider's frame.\n    return createFunctionChildInvoker(\n      children as () => Renderable,\n      newFrame,\n      getCurrentComponentInstance()\n    );\n  } else if (children) {\n    return markWithFrame(children, newFrame);\n  }\n\n  return null;\n}\n\n/**\n * Internal: Mark a vnode with a context frame\n * The renderer will restore this frame before executing component functions\n */\nfunction markWithFrame(node: Renderable, frame: ContextFrame): Renderable {\n  return markVNodeTreeWithContextFrame(node, frame, true) as Renderable;\n}\n\n/**\n * Internal helper component: executes a function-child lazily inside the\n * provided frame and marks the returned subtree with that frame so later\n * component executions will restore the correct context frame.\n *\n * SNAPSHOT SEMANTIC: The frame passed here is the snapshot captured at render\n * time. Any resources created during this execution will observe this frozen\n * snapshot, ensuring deterministic behavior.\n */\nfunction ContextFunctionChildInvoker(props: {\n  fn: () => Renderable;\n  __frame: ContextFrame;\n  __owner?: ComponentInstance | null;\n}): Renderable {\n  const { fn, __frame } = props;\n\n  // Execute the function-child within the provider frame.\n  // The owner's ownerFrame is already set by the renderer when the component was created.\n  // Any resources started during this execution will capture this frame as their\n  // snapshot, ensuring they see the context values from this render, not future renders.\n  const res = withContext(__frame, () => fn());\n\n  // Mark the result so the renderer knows to set ownerFrame on child instances\n  if (res) return markWithFrame(res, __frame);\n  return null;\n}\n\n/**\n * Push a new context frame (for render entry)\n * Called by component runtime when render starts\n */\nexport function pushContextFrame(): ContextFrame {\n  // Lazily allocate the `values` map to avoid per-render allocations when\n  // components do not use context. The map will be created when a provider\n  // sets a value or when a read discovers no map and needs to behave as empty.\n  const frame: ContextFrame = {\n    parent: currentContextFrame,\n    values: null,\n  };\n  currentContextFrame = frame;\n  return frame;\n}\n\n/**\n * Pop context frame (for render exit)\n * Called by component runtime when render ends\n */\nexport function popContextFrame(): void {\n  if (currentContextFrame) {\n    currentContextFrame = currentContextFrame.parent;\n  }\n}\n\n/**\n * Get the current context frame for inspection (used by tests/diagnostics only)\n */\nexport function getCurrentContextFrame(): ContextFrame | null {\n  return currentContextFrame;\n}\n\n/**\n * Get the top of the context snapshot stack (used by runtime when deciding\n * how to link snapshots for async continuations). Returns null if stack empty.\n */\nexport function getTopContextSnapshot(): ContextFrame | null {\n  return currentContextFrame;\n}\n"],"mappings":"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"}

package/dist/runtime/control.d.ts

@@ -0,0 +1,43 @@
+import { ComponentInstance } from "./component.js";
+import { ChildScope } from "./child-scope.js";
+import { ForState } from "./for.js";
+import { VNode } from "../common/vnode.js";
+
+//#region src/runtime/control.d.ts
+interface MatchBranch {
+  key: string | number;
+  render: () => VNode;
+  when: unknown;
+}
+interface BranchControlStateBase {
+  activeKey: string | number | null;
+  activeScope: ChildScope | null;
+  activeVNodes: VNode[];
+  lastRemovedNodes: Node[];
+  parentInstance: ComponentInstance | null;
+  _enqueueBoundaryCommit?: (() => void) | null;
+  _hasPendingBoundaryCommit?: boolean;
+}
+interface ShowState extends BranchControlStateBase {
+  kind: 'show';
+  fallbackScope: ChildScope | null;
+  renderFallback: (() => VNode) | null;
+  renderTruthy: ((value: unknown) => VNode) | (() => VNode);
+  selectedValue: unknown;
+  truthyScope: ChildScope | null;
+}
+interface CaseState extends BranchControlStateBase {
+  kind: 'case';
+  fallback: (() => VNode) | null;
+  matches: MatchBranch[];
+}
+type ControlBoundaryState = ForState<unknown> | ShowState | CaseState;
+declare function createShowState(value: unknown, renderTruthy: ShowState['renderTruthy'], renderFallback: ShowState['renderFallback']): ShowState;
+declare function evaluateShowState(state: ShowState): VNode[];
+declare function clearShowDomUpdateState(state: ShowState): void;
+declare function createCaseState(matches: MatchBranch[], fallback: (() => VNode) | null): CaseState;
+declare function evaluateCaseState(state: CaseState): VNode[];
+declare function clearCaseDomUpdateState(state: CaseState): void;
+//#endregion
+export { ControlBoundaryState };
+//# sourceMappingURL=control.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.ts","names":[],"sources":["../../src/runtime/control.ts"],"mappings":";;;;;;UASiB,WAAA;EACf,GAAA;EACA,MAAA,QAAc,KAAA;EACd,IAAA;AAAA;AAAA,UAGQ,sBAAA;EACR,SAAA;EACA,WAAA,EAAa,UAAA;EACb,YAAA,EAAc,KAAA;EACd,gBAAA,EAAkB,IAAA;EAClB,cAAA,EAAgB,iBAAA;EAChB,sBAAA;EACA,yBAAA;AAAA;AAAA,UAGe,SAAA,SAAkB,sBAAA;EACjC,IAAA;EACA,aAAA,EAAe,UAAA;EACf,cAAA,SAAuB,KAAA;EACvB,YAAA,IAAgB,KAAA,cAAmB,KAAA,WAAgB,KAAA;EACnD,aAAA;EACA,WAAA,EAAa,UAAA;AAAA;AAAA,UAGE,SAAA,SAAkB,sBAAA;EACjC,IAAA;EACA,QAAA,SAAiB,KAAA;EACjB,OAAA,EAAS,WAAA;AAAA;AAAA,KAGC,oBAAA,GAAuB,QAAA,YAAoB,SAAA,GAAY,SAAA;AAAA,iBAkCnD,eAAA,CACd,KAAA,WACA,YAAA,EAAc,SAAA,kBACd,cAAA,EAAgB,SAAA,qBACf,SAAA;AAAA,iBAkBa,iBAAA,CAAkB,KAAA,EAAO,SAAA,GAAY,KAAA;AAAA,iBAiDrC,uBAAA,CAAwB,KAAA,EAAO,SAAA;AAAA,iBAU/B,eAAA,CACd,OAAA,EAAS,WAAA,IACT,QAAA,SAAiB,KAAA,WAChB,SAAA;AAAA,iBAea,iBAAA,CAAkB,KAAA,EAAO,SAAA,GAAY,KAAA;AAAA,iBAiCrC,uBAAA,CAAwB,KAAA,EAAO,SAAA"}

package/dist/runtime/control.js

@@ -0,0 +1,125 @@
+import { getCurrentInstance } from "./component.js";
+import { createChildScope, disposeChildScope } from "./child-scope.js";
+//#region src/runtime/control.ts
+const SHOW_TRUTHY_KEY = "__show-truthy__";
+const SHOW_FALLBACK_KEY = "__show-fallback__";
+const CASE_FALLBACK_KEY = "__case-fallback__";
+function disposeBranchScope(state, scope) {
+	if (!scope) return;
+	const removedDom = scope.dom;
+	disposeChildScope(scope);
+	if (removedDom) state.lastRemovedNodes.push(removedDom);
+}
+function createBranchScope(state, key) {
+	return createChildScope(state.parentInstance, key, () => {
+		if (state._enqueueBoundaryCommit) {
+			state._enqueueBoundaryCommit();
+			return;
+		}
+		state.parentInstance?._enqueueRun?.();
+	});
+}
+function createShowState(value, renderTruthy, renderFallback) {
+	return {
+		kind: "show",
+		activeKey: null,
+		activeScope: null,
+		activeVNodes: [],
+		fallbackScope: null,
+		lastRemovedNodes: [],
+		parentInstance: getCurrentInstance(),
+		_enqueueBoundaryCommit: null,
+		_hasPendingBoundaryCommit: false,
+		renderFallback,
+		renderTruthy,
+		selectedValue: value,
+		truthyScope: null
+	};
+}
+function evaluateShowState(state) {
+	state.lastRemovedNodes = [];
+	if (state.selectedValue) {
+		if (state.fallbackScope) {
+			disposeBranchScope(state, state.fallbackScope);
+			state.fallbackScope = null;
+		}
+		const truthyScope = state.truthyScope ?? createBranchScope(state, SHOW_TRUTHY_KEY);
+		state.truthyScope = truthyScope;
+		state.activeScope = truthyScope;
+		state.activeKey = SHOW_TRUTHY_KEY;
+		const vnode = truthyScope.render(() => state.renderTruthy(state.selectedValue));
+		state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];
+		return state.activeVNodes;
+	}
+	if (state.truthyScope) {
+		disposeBranchScope(state, state.truthyScope);
+		state.truthyScope = null;
+	}
+	if (!state.renderFallback) {
+		if (state.fallbackScope) {
+			disposeBranchScope(state, state.fallbackScope);
+			state.fallbackScope = null;
+		}
+		state.activeKey = null;
+		state.activeScope = null;
+		state.activeVNodes = [];
+		return state.activeVNodes;
+	}
+	const fallbackScope = state.fallbackScope ?? createBranchScope(state, SHOW_FALLBACK_KEY);
+	state.fallbackScope = fallbackScope;
+	state.activeScope = fallbackScope;
+	state.activeKey = SHOW_FALLBACK_KEY;
+	const vnode = fallbackScope.render(state.renderFallback);
+	state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];
+	return state.activeVNodes;
+}
+function clearShowDomUpdateState(state) {
+	if (state.truthyScope) state.truthyScope.needsDomUpdate = false;
+	if (state.fallbackScope) state.fallbackScope.needsDomUpdate = false;
+	state.lastRemovedNodes = [];
+}
+function createCaseState(matches, fallback) {
+	return {
+		kind: "case",
+		activeKey: null,
+		activeScope: null,
+		activeVNodes: [],
+		fallback,
+		lastRemovedNodes: [],
+		matches,
+		parentInstance: getCurrentInstance(),
+		_enqueueBoundaryCommit: null,
+		_hasPendingBoundaryCommit: false
+	};
+}
+function evaluateCaseState(state) {
+	state.lastRemovedNodes = [];
+	const selectedMatch = state.matches.find((candidate) => Boolean(candidate.when)) ?? null;
+	const nextKey = selectedMatch?.key ?? (state.fallback ? CASE_FALLBACK_KEY : null);
+	if (nextKey === null) {
+		if (state.activeScope) disposeBranchScope(state, state.activeScope);
+		state.activeKey = null;
+		state.activeScope = null;
+		state.activeVNodes = [];
+		return state.activeVNodes;
+	}
+	if (state.activeScope && state.activeKey !== nextKey) {
+		disposeBranchScope(state, state.activeScope);
+		state.activeScope = null;
+	}
+	const activeScope = state.activeScope ?? createBranchScope(state, nextKey);
+	state.activeKey = nextKey;
+	state.activeScope = activeScope;
+	const renderBranch = selectedMatch?.render ?? state.fallback;
+	const vnode = renderBranch ? activeScope.render(renderBranch) : null;
+	state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];
+	return state.activeVNodes;
+}
+function clearCaseDomUpdateState(state) {
+	if (state.activeScope) state.activeScope.needsDomUpdate = false;
+	state.lastRemovedNodes = [];
+}
+//#endregion
+export { clearCaseDomUpdateState, clearShowDomUpdateState, createCaseState, createShowState, evaluateCaseState, evaluateShowState };
+
+//# sourceMappingURL=control.js.map

package/dist/runtime/control.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.js","names":[],"sources":["../../src/runtime/control.ts"],"sourcesContent":["import type { VNode } from '../common/vnode';\nimport {\n  createChildScope,\n  disposeChildScope,\n  type ChildScope,\n} from './child-scope';\nimport { getCurrentInstance, type ComponentInstance } from './component';\nimport type { ForState } from './for';\n\nexport interface MatchBranch {\n  key: string | number;\n  render: () => VNode;\n  when: unknown;\n}\n\ninterface BranchControlStateBase {\n  activeKey: string | number | null;\n  activeScope: ChildScope | null;\n  activeVNodes: VNode[];\n  lastRemovedNodes: Node[];\n  parentInstance: ComponentInstance | null;\n  _enqueueBoundaryCommit?: (() => void) | null;\n  _hasPendingBoundaryCommit?: boolean;\n}\n\nexport interface ShowState extends BranchControlStateBase {\n  kind: 'show';\n  fallbackScope: ChildScope | null;\n  renderFallback: (() => VNode) | null;\n  renderTruthy: ((value: unknown) => VNode) | (() => VNode);\n  selectedValue: unknown;\n  truthyScope: ChildScope | null;\n}\n\nexport interface CaseState extends BranchControlStateBase {\n  kind: 'case';\n  fallback: (() => VNode) | null;\n  matches: MatchBranch[];\n}\n\nexport type ControlBoundaryState = ForState<unknown> | ShowState | CaseState;\n\nconst SHOW_TRUTHY_KEY = '__show-truthy__';\nconst SHOW_FALLBACK_KEY = '__show-fallback__';\nconst CASE_FALLBACK_KEY = '__case-fallback__';\n\nfunction disposeBranchScope(\n  state: BranchControlStateBase,\n  scope: ChildScope | null\n): void {\n  if (!scope) {\n    return;\n  }\n  const removedDom = scope.dom;\n  disposeChildScope(scope);\n  if (removedDom) {\n    state.lastRemovedNodes.push(removedDom);\n  }\n}\n\nfunction createBranchScope(\n  state: BranchControlStateBase,\n  key: string | number\n): ChildScope {\n  return createChildScope(state.parentInstance, key, () => {\n    if (state._enqueueBoundaryCommit) {\n      state._enqueueBoundaryCommit();\n      return;\n    }\n\n    state.parentInstance?._enqueueRun?.();\n  });\n}\n\nexport function createShowState(\n  value: unknown,\n  renderTruthy: ShowState['renderTruthy'],\n  renderFallback: ShowState['renderFallback']\n): ShowState {\n  return {\n    kind: 'show',\n    activeKey: null,\n    activeScope: null,\n    activeVNodes: [],\n    fallbackScope: null,\n    lastRemovedNodes: [],\n    parentInstance: getCurrentInstance(),\n    _enqueueBoundaryCommit: null,\n    _hasPendingBoundaryCommit: false,\n    renderFallback,\n    renderTruthy,\n    selectedValue: value,\n    truthyScope: null,\n  };\n}\n\nexport function evaluateShowState(state: ShowState): VNode[] {\n  state.lastRemovedNodes = [];\n\n  if (state.selectedValue) {\n    if (state.fallbackScope) {\n      disposeBranchScope(state, state.fallbackScope);\n      state.fallbackScope = null;\n    }\n\n    const truthyScope =\n      state.truthyScope ?? createBranchScope(state, SHOW_TRUTHY_KEY);\n    state.truthyScope = truthyScope;\n    state.activeScope = truthyScope;\n    state.activeKey = SHOW_TRUTHY_KEY;\n\n    const vnode = truthyScope.render(() =>\n      state.renderTruthy(state.selectedValue)\n    );\n    state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];\n    return state.activeVNodes;\n  }\n\n  if (state.truthyScope) {\n    disposeBranchScope(state, state.truthyScope);\n    state.truthyScope = null;\n  }\n\n  if (!state.renderFallback) {\n    if (state.fallbackScope) {\n      disposeBranchScope(state, state.fallbackScope);\n      state.fallbackScope = null;\n    }\n    state.activeKey = null;\n    state.activeScope = null;\n    state.activeVNodes = [];\n    return state.activeVNodes;\n  }\n\n  const fallbackScope =\n    state.fallbackScope ?? createBranchScope(state, SHOW_FALLBACK_KEY);\n  state.fallbackScope = fallbackScope;\n  state.activeScope = fallbackScope;\n  state.activeKey = SHOW_FALLBACK_KEY;\n\n  const vnode = fallbackScope.render(state.renderFallback);\n  state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];\n  return state.activeVNodes;\n}\n\nexport function clearShowDomUpdateState(state: ShowState): void {\n  if (state.truthyScope) {\n    state.truthyScope.needsDomUpdate = false;\n  }\n  if (state.fallbackScope) {\n    state.fallbackScope.needsDomUpdate = false;\n  }\n  state.lastRemovedNodes = [];\n}\n\nexport function createCaseState(\n  matches: MatchBranch[],\n  fallback: (() => VNode) | null\n): CaseState {\n  return {\n    kind: 'case',\n    activeKey: null,\n    activeScope: null,\n    activeVNodes: [],\n    fallback,\n    lastRemovedNodes: [],\n    matches,\n    parentInstance: getCurrentInstance(),\n    _enqueueBoundaryCommit: null,\n    _hasPendingBoundaryCommit: false,\n  };\n}\n\nexport function evaluateCaseState(state: CaseState): VNode[] {\n  state.lastRemovedNodes = [];\n\n  const selectedMatch =\n    state.matches.find((candidate) => Boolean(candidate.when)) ?? null;\n  const nextKey =\n    selectedMatch?.key ?? (state.fallback ? CASE_FALLBACK_KEY : null);\n\n  if (nextKey === null) {\n    if (state.activeScope) {\n      disposeBranchScope(state, state.activeScope);\n    }\n    state.activeKey = null;\n    state.activeScope = null;\n    state.activeVNodes = [];\n    return state.activeVNodes;\n  }\n\n  if (state.activeScope && state.activeKey !== nextKey) {\n    disposeBranchScope(state, state.activeScope);\n    state.activeScope = null;\n  }\n\n  const activeScope = state.activeScope ?? createBranchScope(state, nextKey);\n  state.activeKey = nextKey;\n  state.activeScope = activeScope;\n\n  const renderBranch = selectedMatch?.render ?? state.fallback;\n  const vnode = renderBranch ? activeScope.render(renderBranch) : null;\n  state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];\n  return state.activeVNodes;\n}\n\nexport function clearCaseDomUpdateState(state: CaseState): void {\n  if (state.activeScope) {\n    state.activeScope.needsDomUpdate = false;\n  }\n  state.lastRemovedNodes = [];\n}\n"],"mappings":";;;AA0CA,MAAM,kBAAkB;AACxB,MAAM,oBAAoB;AAC1B,MAAM,oBAAoB;AAE1B,SAAS,mBACP,OACA,OACM;AACN,KAAI,CAAC,MACH;CAEF,MAAM,aAAa,MAAM;AACzB,mBAAkB,MAAM;AACxB,KAAI,WACF,OAAM,iBAAiB,KAAK,WAAW;;AAI3C,SAAS,kBACP,OACA,KACY;AACZ,QAAO,iBAAiB,MAAM,gBAAgB,WAAW;AACvD,MAAI,MAAM,wBAAwB;AAChC,SAAM,wBAAwB;AAC9B;;AAGF,QAAM,gBAAgB,eAAe;GACrC;;AAGJ,SAAgB,gBACd,OACA,cACA,gBACW;AACX,QAAO;EACL,MAAM;EACN,WAAW;EACX,aAAa;EACb,cAAc,EAAE;EAChB,eAAe;EACf,kBAAkB,EAAE;EACpB,gBAAgB,oBAAoB;EACpC,wBAAwB;EACxB,2BAA2B;EAC3B;EACA;EACA,eAAe;EACf,aAAa;EACd;;AAGH,SAAgB,kBAAkB,OAA2B;AAC3D,OAAM,mBAAmB,EAAE;AAE3B,KAAI,MAAM,eAAe;AACvB,MAAI,MAAM,eAAe;AACvB,sBAAmB,OAAO,MAAM,cAAc;AAC9C,SAAM,gBAAgB;;EAGxB,MAAM,cACJ,MAAM,eAAe,kBAAkB,OAAO,gBAAgB;AAChE,QAAM,cAAc;AACpB,QAAM,cAAc;AACpB,QAAM,YAAY;EAElB,MAAM,QAAQ,YAAY,aACxB,MAAM,aAAa,MAAM,cAAc,CACxC;AACD,QAAM,eAAe,SAAS,QAAQ,UAAU,QAAQ,EAAE,GAAG,CAAC,MAAM;AACpE,SAAO,MAAM;;AAGf,KAAI,MAAM,aAAa;AACrB,qBAAmB,OAAO,MAAM,YAAY;AAC5C,QAAM,cAAc;;AAGtB,KAAI,CAAC,MAAM,gBAAgB;AACzB,MAAI,MAAM,eAAe;AACvB,sBAAmB,OAAO,MAAM,cAAc;AAC9C,SAAM,gBAAgB;;AAExB,QAAM,YAAY;AAClB,QAAM,cAAc;AACpB,QAAM,eAAe,EAAE;AACvB,SAAO,MAAM;;CAGf,MAAM,gBACJ,MAAM,iBAAiB,kBAAkB,OAAO,kBAAkB;AACpE,OAAM,gBAAgB;AACtB,OAAM,cAAc;AACpB,OAAM,YAAY;CAElB,MAAM,QAAQ,cAAc,OAAO,MAAM,eAAe;AACxD,OAAM,eAAe,SAAS,QAAQ,UAAU,QAAQ,EAAE,GAAG,CAAC,MAAM;AACpE,QAAO,MAAM;;AAGf,SAAgB,wBAAwB,OAAwB;AAC9D,KAAI,MAAM,YACR,OAAM,YAAY,iBAAiB;AAErC,KAAI,MAAM,cACR,OAAM,cAAc,iBAAiB;AAEvC,OAAM,mBAAmB,EAAE;;AAG7B,SAAgB,gBACd,SACA,UACW;AACX,QAAO;EACL,MAAM;EACN,WAAW;EACX,aAAa;EACb,cAAc,EAAE;EAChB;EACA,kBAAkB,EAAE;EACpB;EACA,gBAAgB,oBAAoB;EACpC,wBAAwB;EACxB,2BAA2B;EAC5B;;AAGH,SAAgB,kBAAkB,OAA2B;AAC3D,OAAM,mBAAmB,EAAE;CAE3B,MAAM,gBACJ,MAAM,QAAQ,MAAM,cAAc,QAAQ,UAAU,KAAK,CAAC,IAAI;CAChE,MAAM,UACJ,eAAe,QAAQ,MAAM,WAAW,oBAAoB;AAE9D,KAAI,YAAY,MAAM;AACpB,MAAI,MAAM,YACR,oBAAmB,OAAO,MAAM,YAAY;AAE9C,QAAM,YAAY;AAClB,QAAM,cAAc;AACpB,QAAM,eAAe,EAAE;AACvB,SAAO,MAAM;;AAGf,KAAI,MAAM,eAAe,MAAM,cAAc,SAAS;AACpD,qBAAmB,OAAO,MAAM,YAAY;AAC5C,QAAM,cAAc;;CAGtB,MAAM,cAAc,MAAM,eAAe,kBAAkB,OAAO,QAAQ;AAC1E,OAAM,YAAY;AAClB,OAAM,cAAc;CAEpB,MAAM,eAAe,eAAe,UAAU,MAAM;CACpD,MAAM,QAAQ,eAAe,YAAY,OAAO,aAAa,GAAG;AAChE,OAAM,eAAe,SAAS,QAAQ,UAAU,QAAQ,EAAE,GAAG,CAAC,MAAM;AACpE,QAAO,MAAM;;AAGf,SAAgB,wBAAwB,OAAwB;AAC9D,KAAI,MAAM,YACR,OAAM,YAAY,iBAAiB;AAErC,OAAM,mBAAmB,EAAE"}

package/dist/runtime/derive.d.ts

@@ -1,13 +1,16 @@
-import { type ReadableSource } from './readable';
-export interface Derived<T> extends ReadableSource<T> {
-    (): T;
+import { ReadableSource } from "./readable.js";
+
+//#region src/runtime/derive.d.ts
+interface Derived<T> extends ReadableSource<T> {
+  (): T;
 }
 type SnapshotSource<T> = {
-    value: T | null;
-    pending?: boolean;
-    error?: Error | null;
+  value: T | null;
+  pending?: boolean;
+  error?: Error | null;
 };
-export declare function derive<TOut>(fn: () => TOut): Derived<TOut>;
-export declare function derive<TIn, TOut>(source: SnapshotSource<TIn> | TIn | (() => TIn), map: (value: TIn) => TOut): Derived<TOut | null>;
-export {};
+declare function derive<TOut>(fn: () => TOut): Derived<TOut>;
+declare function derive<TIn, TOut>(source: SnapshotSource<TIn> | TIn | (() => TIn), map: (value: TIn) => TOut): Derived<TOut | null>;
+//#endregion
+export { Derived, derive };
 //# sourceMappingURL=derive.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"derive.d.ts","sourceRoot":"","sources":["../../src/runtime/derive.ts"],"names":[],"mappings":"AAMA,OAAO,EAQL,KAAK,cAAc,EAEpB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,OAAO,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACnD,IAAI,CAAC,CAAC;CACP;AAgBD,KAAK,cAAc,CAAC,CAAC,IAAI;IACvB,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;CACtB,CAAC;AA0LF,wBAAgB,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE5D,wBAAgB,MAAM,CAAC,GAAG,EAAE,IAAI,EAC9B,MAAM,EAAE,cAAc,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,EAC/C,GAAG,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,GACxB,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC"}
+{"version":3,"file":"derive.d.ts","names":[],"sources":["../../src/runtime/derive.ts"],"mappings":";;;UAkBiB,OAAA,YAAmB,cAAA,CAAe,CAAA;EAAA,IAC7C,CAAA;AAAA;AAAA,KAiBD,cAAA;EACH,KAAA,EAAO,CAAA;EACP,OAAA;EACA,KAAA,GAAQ,KAAA;AAAA;AAAA,iBA2LM,MAAA,MAAA,CAAa,EAAA,QAAU,IAAA,GAAO,OAAA,CAAQ,IAAA;AAAA,iBAEtC,MAAA,WAAA,CACd,MAAA,EAAQ,cAAA,CAAe,GAAA,IAAO,GAAA,UAAa,GAAA,GAC3C,GAAA,GAAM,KAAA,EAAO,GAAA,KAAQ,IAAA,GACpB,OAAA,CAAQ,IAAA"}

package/dist/runtime/derive.js

@@ -1 +1,134 @@
-import{getCurrentInstance as f,claimHookIndex as _}from"./component.js";import{globalScheduler as l}from"./scheduler.js";import{withDerivedReadTracking as v,syncDerivedDependencySubscriptions as p,markReadableDerivedSubscribersDirty as y,markReactivePropsDirtySource as D,notifyReadableReaders as h,recordReadableRead as g,clearDerivedDependencySubscriptions as S}from"./readable.js";const o=new WeakMap,a=new Set;let d=!1;function m(e){let t=o.get(e);return t||(t=new Map,o.set(e,t)),t}function w(e){e._dirty=!0,!e._scheduled&&(e._scheduled=!0,a.add(e),d||(d=!0,l.enqueueInLane("derived",b)))}function b(){if(d=!1,a.size===0)return;const e=Array.from(a);a.clear();for(const t of e)t._scheduled=!1,t._dirty&&s(t,!0)}function s(e,t){if(!e._dirty&&e._hasValue)return e._value;if(e._evaluating)throw new Error("derive() cannot read itself recursively");e._evaluating=!0,e._dirty=!1,e._pendingDependencySources=new Set;const n=e._sources;let r;try{r=v(e,e._compute)}catch(c){throw e._dirty=!0,e._pendingDependencySources=void 0,c}finally{e._evaluating=!1}const i=e._pendingDependencySources??new Set;e._pendingDependencySources=void 0,p(e,n,i),e._sources=i;const u=!e._hasValue||!Object.is(e._value,r);return e._hasValue=!0,e._value=r,u&&t&&(y(e),D(e),h(e)),e._value}function C(e,t,n){const r=function(){return g(r),s(r,r._scheduled)};return r._owner=e,r._hookIndex=t,r._compute=n,r._value=void 0,r._hasValue=!1,r._dirty=!0,r._scheduled=!1,r._evaluating=!1,r._sources=new Set,r._markDirty=()=>{w(r)},r._cleanup=()=>{r._scheduled=!1,r._dirty=!1,r._hasValue=!1,a.delete(r),S(r,r._sources),r._derivedSubscribers?.clear(),r._readers?.clear()},e.cleanupFns.push(()=>{r._cleanup(),o.get(e)?.delete(t)}),r}function R(e,t,n){const r=m(e),i=r.get(t);if(i)return i._compute=n,i._dirty=!0,i;const u=C(e,t,n);return r.set(t,u),u}function k(e,t){return()=>{let n;return typeof e=="function"&&!("value"in e)?n=e():n=e?.value??e,n==null?null:t(n)}}function E(e,t){const n=f();if(!n)throw new Error("derive() can only be called during component render execution. Move derive() calls to the top level of your component function.");const r=_(n,"derive"),i=t===void 0?e:k(e,t),u=R(n,r,i);return s(u,!1),u}export{E as derive};
+import { globalScheduler } from "./scheduler.js";
+import { clearDerivedDependencySubscriptions, markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead, syncDerivedDependencySubscriptions, withDerivedReadTracking } from "./readable.js";
+import { claimHookIndex, getCurrentInstance } from "./component.js";
+//#region src/runtime/derive.ts
+const deriveCells = /* @__PURE__ */ new WeakMap();
+const dirtyDerivedCells = /* @__PURE__ */ new Set();
+let hasPendingDerivedFlush = false;
+function getDeriveStore(instance) {
+	let store = deriveCells.get(instance);
+	if (!store) {
+		store = /* @__PURE__ */ new Map();
+		deriveCells.set(instance, store);
+	}
+	return store;
+}
+function markDerivedCellDirty(cell) {
+	cell._dirty = true;
+	if (cell._scheduled) return;
+	cell._scheduled = true;
+	dirtyDerivedCells.add(cell);
+	if (!hasPendingDerivedFlush) {
+		hasPendingDerivedFlush = true;
+		globalScheduler.enqueueInLane("derived", flushDirtyDerivedCells);
+	}
+}
+function flushDirtyDerivedCells() {
+	hasPendingDerivedFlush = false;
+	if (dirtyDerivedCells.size === 0) return;
+	const pending = Array.from(dirtyDerivedCells);
+	dirtyDerivedCells.clear();
+	for (const cell of pending) {
+		cell._scheduled = false;
+		if (!cell._dirty) continue;
+		recomputeDerivedCell(cell, true);
+	}
+}
+function recomputeDerivedCell(cell, notifyDownstream) {
+	if (!cell._dirty && cell._hasValue) return cell._value;
+	if (cell._evaluating) throw new Error("derive() cannot read itself recursively");
+	cell._evaluating = true;
+	cell._dirty = false;
+	cell._pendingDependencySources = /* @__PURE__ */ new Set();
+	const prevSources = cell._sources;
+	let nextValue;
+	try {
+		nextValue = withDerivedReadTracking(cell, cell._compute);
+	} catch (error) {
+		cell._dirty = true;
+		cell._pendingDependencySources = void 0;
+		throw error;
+	} finally {
+		cell._evaluating = false;
+	}
+	const nextSources = cell._pendingDependencySources ?? /* @__PURE__ */ new Set();
+	cell._pendingDependencySources = void 0;
+	syncDerivedDependencySubscriptions(cell, prevSources, nextSources);
+	cell._sources = nextSources;
+	const valueChanged = !cell._hasValue || !Object.is(cell._value, nextValue);
+	cell._hasValue = true;
+	cell._value = nextValue;
+	if (valueChanged && notifyDownstream) {
+		markReadableDerivedSubscribersDirty(cell);
+		markReactivePropsDirtySource(cell);
+		notifyReadableReaders(cell);
+	}
+	return cell._value;
+}
+function createDerivedCell(instance, hookIndex, compute) {
+	const cell = function derivedGetter() {
+		recordReadableRead(cell);
+		return recomputeDerivedCell(cell, cell._scheduled);
+	};
+	cell._owner = instance;
+	cell._hookIndex = hookIndex;
+	cell._compute = compute;
+	cell._value = void 0;
+	cell._hasValue = false;
+	cell._dirty = true;
+	cell._scheduled = false;
+	cell._evaluating = false;
+	cell._sources = /* @__PURE__ */ new Set();
+	cell._markDirty = () => {
+		markDerivedCellDirty(cell);
+	};
+	cell._cleanup = () => {
+		cell._scheduled = false;
+		cell._dirty = false;
+		cell._hasValue = false;
+		dirtyDerivedCells.delete(cell);
+		clearDerivedDependencySubscriptions(cell, cell._sources);
+		cell._derivedSubscribers?.clear();
+		cell._readers?.clear();
+	};
+	(instance.cleanupFns ??= []).push(() => {
+		cell._cleanup();
+		deriveCells.get(instance)?.delete(hookIndex);
+	});
+	return cell;
+}
+function getOrCreateDerivedCell(instance, hookIndex, compute) {
+	const store = getDeriveStore(instance);
+	const existing = store.get(hookIndex);
+	if (existing) {
+		existing._compute = compute;
+		existing._dirty = true;
+		return existing;
+	}
+	const created = createDerivedCell(instance, hookIndex, compute);
+	store.set(hookIndex, created);
+	return created;
+}
+function createSelector(selector) {
+	return selector;
+}
+function createMappedSelector(source, map) {
+	return () => {
+		let value;
+		if (typeof source === "function" && !("value" in source)) value = source();
+		else value = source?.value ?? source;
+		if (value == null) return null;
+		return map(value);
+	};
+}
+function derive(source, map) {
+	const instance = getCurrentInstance();
+	if (!instance) throw new Error("derive() can only be called during component render execution. Move derive() calls to the top level of your component function.");
+	const cell = getOrCreateDerivedCell(instance, claimHookIndex(instance, "derive"), map === void 0 ? createSelector(source) : createMappedSelector(source, map));
+	recomputeDerivedCell(cell, false);
+	return cell;
+}
+//#endregion
+export { derive };
+
+//# sourceMappingURL=derive.js.map

package/dist/runtime/derive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.js","names":[],"sources":["../../src/runtime/derive.ts"],"sourcesContent":["import {\n  claimHookIndex,\n  getCurrentInstance,\n  type ComponentInstance,\n} from './component';\nimport { globalScheduler } from './scheduler';\nimport {\n  clearDerivedDependencySubscriptions,\n  markReadableDerivedSubscribersDirty,\n  markReactivePropsDirtySource,\n  notifyReadableReaders,\n  recordReadableRead,\n  syncDerivedDependencySubscriptions,\n  type DerivedSubscriber,\n  type ReadableSource,\n  withDerivedReadTracking,\n} from './readable';\n\nexport interface Derived<T> extends ReadableSource<T> {\n  (): T;\n}\n\ninterface DerivedCell<T> extends Derived<T>, DerivedSubscriber {\n  _owner: ComponentInstance;\n  _hookIndex: number;\n  _compute: () => T;\n  _value: T;\n  _hasValue: boolean;\n  _dirty: boolean;\n  _scheduled: boolean;\n  _evaluating: boolean;\n  _sources: Set<ReadableSource<unknown>>;\n  _pendingDependencySources?: Set<ReadableSource<unknown>>;\n  _cleanup(): void;\n}\n\ntype SnapshotSource<T> = {\n  value: T | null;\n  pending?: boolean;\n  error?: Error | null;\n};\n\nconst deriveCells = new WeakMap<\n  ComponentInstance,\n  Map<number, DerivedCell<unknown>>\n>();\nconst dirtyDerivedCells = new Set<DerivedCell<unknown>>();\nlet hasPendingDerivedFlush = false;\n\nfunction getDeriveStore(\n  instance: ComponentInstance\n): Map<number, DerivedCell<unknown>> {\n  let store = deriveCells.get(instance);\n  if (!store) {\n    store = new Map();\n    deriveCells.set(instance, store);\n  }\n  return store;\n}\n\nfunction markDerivedCellDirty(cell: DerivedCell<unknown>): void {\n  cell._dirty = true;\n  if (cell._scheduled) {\n    return;\n  }\n\n  cell._scheduled = true;\n  dirtyDerivedCells.add(cell);\n\n  if (!hasPendingDerivedFlush) {\n    hasPendingDerivedFlush = true;\n    globalScheduler.enqueueInLane('derived', flushDirtyDerivedCells);\n  }\n}\n\nfunction flushDirtyDerivedCells(): void {\n  hasPendingDerivedFlush = false;\n\n  if (dirtyDerivedCells.size === 0) {\n    return;\n  }\n\n  const pending = Array.from(dirtyDerivedCells);\n  dirtyDerivedCells.clear();\n\n  for (const cell of pending) {\n    cell._scheduled = false;\n    if (!cell._dirty) {\n      continue;\n    }\n    recomputeDerivedCell(cell, true);\n  }\n}\n\nfunction recomputeDerivedCell<T>(\n  cell: DerivedCell<T>,\n  notifyDownstream: boolean\n): T {\n  if (!cell._dirty && cell._hasValue) {\n    return cell._value;\n  }\n\n  if (cell._evaluating) {\n    throw new Error('derive() cannot read itself recursively');\n  }\n\n  cell._evaluating = true;\n  cell._dirty = false;\n  cell._pendingDependencySources = new Set();\n\n  const prevSources = cell._sources;\n  let nextValue: T;\n\n  try {\n    nextValue = withDerivedReadTracking(cell, cell._compute);\n  } catch (error) {\n    cell._dirty = true;\n    cell._pendingDependencySources = undefined;\n    throw error;\n  } finally {\n    cell._evaluating = false;\n  }\n\n  const nextSources = cell._pendingDependencySources ?? new Set();\n  cell._pendingDependencySources = undefined;\n  syncDerivedDependencySubscriptions(cell, prevSources, nextSources);\n  cell._sources = nextSources;\n\n  const valueChanged = !cell._hasValue || !Object.is(cell._value, nextValue);\n  cell._hasValue = true;\n  cell._value = nextValue;\n\n  if (valueChanged && notifyDownstream) {\n    markReadableDerivedSubscribersDirty(cell);\n    markReactivePropsDirtySource(cell);\n    notifyReadableReaders(cell);\n  }\n\n  return cell._value;\n}\n\nfunction createDerivedCell<T>(\n  instance: ComponentInstance,\n  hookIndex: number,\n  compute: () => T\n): DerivedCell<T> {\n  const cell = function derivedGetter(): T {\n    recordReadableRead(cell as DerivedCell<T>);\n    return recomputeDerivedCell(\n      cell as DerivedCell<T>,\n      (cell as DerivedCell<T>)._scheduled\n    );\n  } as DerivedCell<T>;\n\n  cell._owner = instance;\n  cell._hookIndex = hookIndex;\n  cell._compute = compute;\n  cell._value = undefined as T;\n  cell._hasValue = false;\n  cell._dirty = true;\n  cell._scheduled = false;\n  cell._evaluating = false;\n  cell._sources = new Set();\n  cell._markDirty = () => {\n    markDerivedCellDirty(cell);\n  };\n  cell._cleanup = () => {\n    cell._scheduled = false;\n    cell._dirty = false;\n    cell._hasValue = false;\n    dirtyDerivedCells.delete(cell);\n    clearDerivedDependencySubscriptions(cell, cell._sources);\n    cell._derivedSubscribers?.clear();\n    cell._readers?.clear();\n  };\n\n  (instance.cleanupFns ??= []).push(() => {\n    cell._cleanup();\n    deriveCells.get(instance)?.delete(hookIndex);\n  });\n\n  return cell;\n}\n\nfunction getOrCreateDerivedCell<T>(\n  instance: ComponentInstance,\n  hookIndex: number,\n  compute: () => T\n): DerivedCell<T> {\n  const store = getDeriveStore(instance);\n  const existing = store.get(hookIndex) as DerivedCell<T> | undefined;\n  if (existing) {\n    existing._compute = compute;\n    existing._dirty = true;\n    return existing;\n  }\n\n  const created = createDerivedCell(instance, hookIndex, compute);\n  store.set(hookIndex, created as DerivedCell<unknown>);\n  return created;\n}\n\nfunction createSelector<TOut>(selector: () => TOut): () => TOut {\n  return selector;\n}\n\nfunction createMappedSelector<TIn, TOut>(\n  source: SnapshotSource<TIn> | TIn | (() => TIn),\n  map: (value: TIn) => TOut\n): () => TOut | null {\n  return () => {\n    let value: TIn;\n    if (typeof source === 'function' && !('value' in source)) {\n      value = (source as () => TIn)();\n    } else {\n      value = (source as SnapshotSource<TIn>)?.value ?? (source as TIn);\n    }\n\n    if (value == null) {\n      return null;\n    }\n\n    return map(value);\n  };\n}\n\nexport function derive<TOut>(fn: () => TOut): Derived<TOut>;\n\nexport function derive<TIn, TOut>(\n  source: SnapshotSource<TIn> | TIn | (() => TIn),\n  map: (value: TIn) => TOut\n): Derived<TOut | null>;\n\nexport function derive<TIn, TOut>(\n  source: SnapshotSource<TIn> | TIn | (() => TIn),\n  map?: (value: TIn) => TOut\n): Derived<TOut | null> | Derived<TIn> {\n  const instance = getCurrentInstance();\n  if (!instance) {\n    throw new Error(\n      'derive() can only be called during component render execution. ' +\n        'Move derive() calls to the top level of your component function.'\n    );\n  }\n\n  const hookIndex = claimHookIndex(instance, 'derive');\n  const compute =\n    map === undefined\n      ? createSelector(source as () => TIn)\n      : createMappedSelector(source, map);\n\n  const cell = getOrCreateDerivedCell(\n    instance,\n    hookIndex,\n    compute as () => TOut | null | TIn\n  );\n  recomputeDerivedCell(cell, false);\n  return cell as Derived<TOut | null> | Derived<TIn>;\n}\n"],"mappings":"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"}