svelte-effect-runtime 4.0.0 → 4.1.0

package/.dist/detect.js

@@ -1,52 +1,13 @@
 import ts from "typescript";
 //#region src/detect.ts
-/**
-* Returns `true` when the node tree contains a `yield*` expression that is
-* not inside any function boundary (arrow function, function declaration,
-* function expression, method).
-*
-* @example
-* ```ts
-* const sf = ts.createSourceFile("test.ts", "yield* foo()", ...);
-* contains_top_level_yield_star(sf.statements[0]); // true
-* ```
-*
-* @since 2.0.0
-* @param node - The root node to search from.
-* @returns Whether a top-level yield* expression was found.
-*/
 function contains_top_level_yield_star(node) {
 	if (is_function_boundary(node)) return false;
 	if (is_yield_star_expression(node)) return true;
 	return node.getChildren().some((child) => contains_top_level_yield_star(child));
 }
-/**
-* Returns `true` when the node is a function-like boundary that owns its
-* own yield/yield* semantics. A function boundary includes arrow functions,
-* function declarations, function expressions, methods, get accessors, and
-* set accessors.
-*
-* @example
-* ```ts
-* const stmt = parseStatement("function foo() {}");
-* is_function_boundary(stmt); // true
-* ```
-*
-* @since 2.0.0
-* @param node - The node to check.
-* @returns Whether the node is a function boundary.
-*/
 function is_function_boundary(node) {
 	return ts.isArrowFunction(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node);
 }
-/**
-* Returns `true` when the node is a binary expression shaped like
-* `yield * operand` — a yield* delegate expression in TypeScript's AST.
-*
-* @since 2.0.0
-* @param node - The node to check.
-* @returns Whether the node is a `yield*` expression.
-*/
 function is_yield_star_expression(node) {
 	return ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.AsteriskToken && ts.isIdentifier(node.left) && node.left.text === "yield";
 }

package/.dist/detect.js.map

@@ -1 +1 @@
-{"version":3,"file":"detect.js","names":[],"sources":["../../modules/svelte-effect-runtime/src/detect.ts"],"sourcesContent":["import ts from \"typescript\";\n\n/**\n * Returns `true` when the node tree contains a `yield*` expression that is\n * not inside any function boundary (arrow function, function declaration,\n * function expression, method).\n *\n * @example\n * ```ts\n * const sf = ts.createSourceFile(\"test.ts\", \"yield* foo()\", ...);\n * contains_top_level_yield_star(sf.statements[0]); // true\n * ```\n *\n * @since 2.0.0\n * @param node - The root node to search from.\n * @returns Whether a top-level yield* expression was found.\n */\nexport function contains_top_level_yield_star(node: ts.Node): boolean {\n\tif (is_function_boundary(node)) {\n\t\treturn false;\n\t}\n\n\tif (is_yield_star_expression(node)) {\n\t\treturn true;\n\t}\n\n\treturn node.getChildren().some((child) => contains_top_level_yield_star(child));\n}\n\n/**\n * Returns `true` when the node is a function-like boundary that owns its\n * own yield/yield* semantics. A function boundary includes arrow functions,\n * function declarations, function expressions, methods, get accessors, and\n * set accessors.\n *\n * @example\n * ```ts\n * const stmt = parseStatement(\"function foo() {}\");\n * is_function_boundary(stmt); // true\n * ```\n *\n * @since 2.0.0\n * @param node - The node to check.\n * @returns Whether the node is a function boundary.\n */\nexport function is_function_boundary(node: ts.Node): boolean {\n\treturn (\n\t\tts.isArrowFunction(node) ||\n\t\tts.isFunctionDeclaration(node) ||\n\t\tts.isFunctionExpression(node) ||\n\t\tts.isMethodDeclaration(node) ||\n\t\tts.isGetAccessorDeclaration(node) ||\n\t\tts.isSetAccessorDeclaration(node)\n\t);\n}\n\n/**\n * Returns `true` when the node is a binary expression shaped like\n * `yield * operand` — a yield* delegate expression in TypeScript's AST.\n *\n * @since 2.0.0\n * @param node - The node to check.\n * @returns Whether the node is a `yield*` expression.\n */\nfunction is_yield_star_expression(node: ts.Node): boolean {\n\treturn (\n\t\tts.isBinaryExpression(node) &&\n\t\tnode.operatorToken.kind === ts.SyntaxKind.AsteriskToken &&\n\t\tts.isIdentifier(node.left) &&\n\t\tnode.left.text === \"yield\"\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,SAAgB,8BAA8B,MAAwB;CACrE,IAAI,qBAAqB,IAAI,GAC5B,OAAO;CAGR,IAAI,yBAAyB,IAAI,GAChC,OAAO;CAGR,OAAO,KAAK,YAAY,CAAC,CAAC,MAAM,UAAU,8BAA8B,KAAK,CAAC;AAC/E;;;;;;;;;;;;;;;;;AAkBA,SAAgB,qBAAqB,MAAwB;CAC5D,OACC,GAAG,gBAAgB,IAAI,KACvB,GAAG,sBAAsB,IAAI,KAC7B,GAAG,qBAAqB,IAAI,KAC5B,GAAG,oBAAoB,IAAI,KAC3B,GAAG,yBAAyB,IAAI,KAChC,GAAG,yBAAyB,IAAI;AAElC;;;;;;;;;AAUA,SAAS,yBAAyB,MAAwB;CACzD,OACC,GAAG,mBAAmB,IAAI,KAC1B,KAAK,cAAc,SAAS,GAAG,WAAW,iBAC1C,GAAG,aAAa,KAAK,IAAI,KACzB,KAAK,KAAK,SAAS;AAErB"}
+{"version":3,"file":"detect.js","names":[],"sources":["../../modules/svelte-effect-runtime/src/detect.ts"],"sourcesContent":["import ts from \"typescript\";\n\nexport function contains_top_level_yield_star(node: ts.Node): boolean {\n\tif (is_function_boundary(node)) {\n\t\treturn false;\n\t}\n\n\tif (is_yield_star_expression(node)) {\n\t\treturn true;\n\t}\n\n\treturn node.getChildren().some((child) => contains_top_level_yield_star(child));\n}\n\nexport function is_function_boundary(node: ts.Node): boolean {\n\treturn (\n\t\tts.isArrowFunction(node) ||\n\t\tts.isFunctionDeclaration(node) ||\n\t\tts.isFunctionExpression(node) ||\n\t\tts.isMethodDeclaration(node) ||\n\t\tts.isGetAccessorDeclaration(node) ||\n\t\tts.isSetAccessorDeclaration(node)\n\t);\n}\n\nfunction is_yield_star_expression(node: ts.Node): boolean {\n\treturn (\n\t\tts.isBinaryExpression(node) &&\n\t\tnode.operatorToken.kind === ts.SyntaxKind.AsteriskToken &&\n\t\tts.isIdentifier(node.left) &&\n\t\tnode.left.text === \"yield\"\n\t);\n}\n"],"mappings":";;AAEA,SAAgB,8BAA8B,MAAwB;CACrE,IAAI,qBAAqB,IAAI,GAC5B,OAAO;CAGR,IAAI,yBAAyB,IAAI,GAChC,OAAO;CAGR,OAAO,KAAK,YAAY,CAAC,CAAC,MAAM,UAAU,8BAA8B,KAAK,CAAC;AAC/E;AAEA,SAAgB,qBAAqB,MAAwB;CAC5D,OACC,GAAG,gBAAgB,IAAI,KACvB,GAAG,sBAAsB,IAAI,KAC7B,GAAG,qBAAqB,IAAI,KAC5B,GAAG,oBAAoB,IAAI,KAC3B,GAAG,yBAAyB,IAAI,KAChC,GAAG,yBAAyB,IAAI;AAElC;AAEA,SAAS,yBAAyB,MAAwB;CACzD,OACC,GAAG,mBAAmB,IAAI,KAC1B,KAAK,cAAc,SAAS,GAAG,WAAW,iBAC1C,GAAG,aAAa,KAAK,IAAI,KACzB,KAAK,KAAK,SAAS;AAErB"}

package/.dist/diagnostics.d.ts

@@ -1,19 +1,3 @@
-/**
- * Finds best-effort SER usage diagnostics in Svelte component markup.
- *
- * @example
- * ```ts
- * const diagnostics = find_svelte_effect_diagnostics(
- *   `<button onclick={Effect.gen}>save</button>`,
- *   "Button.svelte",
- * );
- * ```
- *
- * @since 2.0.0
- * @param code - Svelte component source to scan for suspicious Effect usage.
- * @param filename - Filename used in diagnostic messages.
- * @returns Warning diagnostics with a message and source location.
- */
 export declare function find_svelte_effect_diagnostics(code: string, filename: string): Array<{
     message: string;
     line: number;

package/.dist/dispatcher/deps.d.ts

@@ -1,14 +1,3 @@
-/**
- * Builds a deterministic cache key from a dependency array.
- *
- * @example
- * ```ts
- * const key = hash_deps([user_id, filters]);
- * ```
- *
- * @since 2.0.0
- * @param deps - Dependency array to encode for cache lookup.
- * @returns A structured string key suitable for Map lookups.
- * @internal
- */
-export declare function hash_deps(deps: readonly unknown[]): string;
+/** Assigns stable identities to object dependencies while hashing value dependencies. */
+export type DependencyHasher = (deps: readonly unknown[]) => string;
+export declare function make_dependency_hasher(): DependencyHasher;

package/.dist/dispatcher/fibers.d.ts

@@ -1,54 +1,13 @@
 import type { Fiber as FiberType } from "effect/Fiber";
-import type { ManagedRuntime as ManagedRuntimeType } from "effect/ManagedRuntime";
-/**
- * Callbacks fired when a watched dispatcher fiber completes.
- *
- * @example
- * ```ts
- * const callbacks: FiberWatchCallbacks<number> = {
- *   on_success: (value) => cache.set(key, value),
- * };
- * ```
- *
- * @since 2.0.0
- * @internal
- */
+import { Effect } from "effect";
 export interface FiberWatchCallbacks<A> {
     on_complete?: () => void;
     on_success?: (value: A) => void;
     on_failure?: (error: unknown) => void;
     surface_failure?: boolean;
 }
-/**
- * Interrupts a dispatcher fiber through its managed runtime.
- *
- * @example
- * ```ts
- * interrupt_fiber(runtime, fiber);
- * ```
- *
- * @since 2.0.0
- * @param runtime - Managed runtime that owns the fiber.
- * @param fiber - Fiber to interrupt.
- * @returns Nothing.
- * @internal
- */
-export declare function interrupt_fiber(runtime: ManagedRuntimeType<unknown, unknown>, fiber: FiberType<unknown, unknown>): void;
-/**
- * Watches a dispatcher fiber, runs completion callbacks, and surfaces
- * non-interrupt failures on the microtask queue.
- *
- * @example
- * ```ts
- * watch_fiber_exit({ runtime, fiber, on_complete: cleanup });
- * ```
- *
- * @since 2.0.0
- * @param options - Runtime, fiber, and callbacks used for the watcher.
- * @returns Nothing.
- * @internal
- */
-export declare function watch_fiber_exit<A>(options: {
-    runtime: ManagedRuntimeType<unknown, unknown>;
+export declare const InterruptFiber: (fiber: FiberType<unknown, unknown>) => Effect.Effect<void, never, never>;
+/** Observes fiber completion and surfaces failures without taking ownership of the fiber. */
+export declare const WatchFiberExit: <A>(options: {
     fiber: FiberType<unknown, unknown>;
-} & FiberWatchCallbacks<A>): void;
+} & FiberWatchCallbacks<A>) => Effect.Effect<void, never, never>;

package/.dist/dispatcher/index.d.ts

@@ -1,163 +1,70 @@
+import type { DispatcherEvent, Dispose, MarkupPromiseEvent, MarkupRunEvent, MarkupValueEvent, PromiseOptions, ValueOptions } from "./types.js";
 import type { ManagedRuntime as ManagedRuntimeType } from "effect/ManagedRuntime";
 import { Effect, Layer } from "effect";
-import type { DispatcherEvent, Dispose, MarkupPromiseEvent, MarkupRunEvent, MarkupValueEvent, PromiseOptions, ValueOptions } from "./types.js";
+import { ComponentScope } from "./scope.js";
 export { Code } from "./types.js";
 export type { Dispose, PromiseOptions, ValueOptions } from "./types.js";
-/**
- * Unified effect block dispatcher. Manages the fiber lifecycle of every
- * effect block and wires results into reactive channels.
- *
- * @example
- * ```ts
- * const dispatcher = new Dispatcher();
- * const cancel = dispatcher.fork(Effect.log("running"));
- * cancel();
- * ```
- *
- * @since 2.0.0
- * @internal
- */
 export declare class Dispatcher {
     #private;
+    static make<R = never>(layer?: Layer.Layer<R>): Dispatcher;
+    constructor(runtime?: ManagedRuntimeType<unknown, unknown>);
     /**
-     * Creates a dispatcher with an optional layer and installs it as the global
-     * singleton returned by {@link get_dispatcher}.
-     *
-     * @example
-     * ```ts
-     * const dispatcher = Dispatcher.make(Db.Live);
-     * ```
-     *
-     * @since 2.0.0
-     * @param layer - Optional Effect layer to provide to the runtime.
-     * @returns The newly created dispatcher.
+     * Begin a component-owned Effect scope. Pass the returned scope to
+     * {@link run_scoped} so the work is interrupted and finalized when the
+     * component is destroyed. Disposal is idempotent.
      */
-    static make<R = never>(layer?: Layer.Layer<R>): Dispatcher;
+    begin_scope(): ComponentScope;
     /**
-     * Creates a dispatcher backed by the provided managed runtime.
-     *
-     * @example
-     * ```ts
-     * const dispatcher = new Dispatcher(runtime);
-     * ```
-     *
-     * @since 2.0.0
-     * @param runtime - Managed runtime to use, or an empty-layer runtime when
-     *   omitted.
+     * Runs `fn` with `scope` as the current component scope. While active,
+     * every effect path ({@link promise}, {@link run}, {@link value}) forks
+     * its work into `scope` so disposing the scope interrupts it and runs its
+     * finalizers. A disposed scope falls back to unscoped execution.
      */
-    constructor(runtime?: ManagedRuntimeType<unknown, unknown>);
+    with_scope<T>(scope: ComponentScope, fn: () => T): T;
     /**
-     * Handles a transform-generated dispatcher event.
-     *
-     * @example
-     * ```ts
-     * const value = dispatcher.emit({
-     *   type: Code.Markup.Value,
-     *   id: "Component.svelte:1:2",
-     *   deps: [],
-     *   fallback: undefined,
-     *   fn: function* () {
-     *     return yield* Effect.succeed(1);
-     *   },
-     * });
-     * ```
+     * Forks an effect into a component scope and starts it. The fiber becomes
+     * a child of the scope, so disposing the scope interrupts it and runs its
+     * finalizers. Returns an idempotent handle that interrupts the scoped
+     * fiber directly.
      *
-     * @since 3.3.0
-     * @param event - Generated event describing the dispatcher operation to run.
-     * @returns The operation result for the emitted dispatcher event.
+     * Throws {@link ScopeDisposedError} when the scope was already disposed
+     * and {@link DispatcherDisposedError} when the dispatcher was shut down.
      */
+    run_scoped<A, E, R>(scope: ComponentScope, effect: Effect.Effect<A, E, R>): Dispose;
+    /**
+     * Disposes a component scope owned by this dispatcher, interrupting its
+     * bound work and running its finalizers. Idempotent. Rejects scopes owned
+     * by another dispatcher with {@link ScopeDisposedError}.
+     */
+    dispose_scope(scope: ComponentScope): void;
     emit<A, F>(event: MarkupValueEvent<A, F>): A | F;
     emit<A>(event: MarkupPromiseEvent<A>): Promise<A>;
     emit<A>(event: MarkupRunEvent<A>): Promise<A>;
     emit<A, F>(event: DispatcherEvent<A, F>): A | F | Promise<A>;
-    /**
-     * Forks an effect as a managed fiber and returns a cleanup function.
-     *
-     * @example
-     * ```ts
-     * const dispose = dispatcher.fork(Effect.log("clicked"));
-     * ```
-     *
-     * @since 2.0.0
-     * @param effect - Effect to fork.
-     * @returns A function that interrupts the fiber.
-     */
     fork<A, E, R>(effect: Effect.Effect<A, E, R>): Dispose;
-    /**
-     * Forks an effect and exposes its result as a cached reactive value.
-     *
-     * @example
-     * ```ts
-     * const user = dispatcher.value({ id, deps, fallback, factory });
-     * ```
-     *
-     * @since 2.0.0
-     * @param options - Value id, dependency array, fallback, and effect factory.
-     * @returns The cached value if resolved, otherwise the fallback.
-     */
     value<A>(options: ValueOptions<A>): A;
-    /**
-     * Forks an effect and exposes its completion as a cached promise.
-     *
-     * @example
-     * ```ts
-     * const promise = dispatcher.promise({ id, deps, factory });
-     * ```
-     *
-     * @since 2.0.0
-     * @param options - Promise id, dependency array, and effect factory.
-     * @returns A promise that resolves with the effect result.
-     */
     promise<A>(options: PromiseOptions<A>): Promise<A>;
-    /**
-     * Runs an event-handler effect and surfaces failures to Svelte.
-     *
-     * @example
-     * ```ts
-     * await dispatcher.run(Effect.log("submit"));
-     * ```
-     *
-     * @since 2.0.0
-     * @param effect - Effect to execute.
-     * @returns A promise that resolves or rejects when the effect completes.
-     */
     run<A, E, R>(effect: Effect.Effect<A, E, R>): Promise<A>;
-    /**
-     * Cancels all running fibers and releases cached values.
-     *
-     * @example
-     * ```ts
-     * dispatcher.dispose();
-     * ```
-     *
-     * @since 2.0.0
-     * @returns Nothing.
-     */
     dispose(): void;
 }
-/**
- * Resolves the active dispatcher, creating a default one if necessary.
- *
- * @example
- * ```ts
- * const dispatcher = get_dispatcher();
- * ```
- *
- * @since 2.0.0
- * @returns The active dispatcher singleton.
- * @internal
- */
 export declare function get_dispatcher(): Dispatcher;
+export declare function reset_dispatcher(): void;
 /**
- * Resets the internal singleton dispatcher used by source-level tests.
+ * Lazily-created component scope used by generated component code.
  *
- * @example
- * ```ts
- * reset_dispatcher();
- * ```
+ * The holder is created synchronously during component init (before any
+ * top-level `await`, where `onDestroy` is not yet available), and the scope
+ * itself is materialized on first use. Disposal is registered separately
+ * through `onDestroy` during component initialisation, so the scope is
+ * reliably closed on unmount.
  *
- * @since 2.0.0
- * @returns Nothing.
- * @internal
+ * @since 4.1.0
  */
-export declare function reset_dispatcher(): void;
+export declare class ComponentScopeRef {
+    #private;
+    constructor(get_dispatcher_fn: () => Dispatcher);
+    /** The component scope, creating it on first access. */
+    get scope(): ComponentScope;
+    /** Disposes the scope if it was created. Idempotent. */
+    dispose(): void;
+}

package/.dist/dispatcher/scope.d.ts

@@ -0,0 +1,36 @@
+import { Effect, Scope } from "effect";
+import type { Fiber } from "effect";
+/**
+ * A component-owned Effect scope.
+ *
+ * A `ComponentScope` wraps a `Scope.Closeable` forked from the dispatcher's
+ * root scope. Work is forked into the scope with `Effect.forkIn`, so closing
+ * the scope interrupts that work and runs its finalizers. The generated
+ * component teardown disposes the scope on destroy. Disposal is idempotent.
+ *
+ * @since 4.1.0
+ */
+export declare class ComponentScope {
+    #private;
+    private constructor();
+    /** Forks a child scope from the given root and returns it wrapped. */
+    static fork(root: Scope.Closeable, on_dispose: (scope: ComponentScope) => void): ComponentScope;
+    /** The underlying closeable scope used to bind Effect work. */
+    get underlying(): Scope.Closeable;
+    /** Whether this scope has already been disposed. */
+    get disposed(): boolean;
+    /**
+     * Forks an effect into this scope. The fiber becomes a child of the scope,
+     * so disposing the scope interrupts it and runs its finalizers. The scope
+     * is provided ambiently so `Effect.forkIn` registers the fiber as a child.
+     */
+    fork_in<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<Fiber.Fiber<A, E>, never, R>;
+    /** Effect that closes the scope. Must be run by the owning dispatcher. */
+    get close_effect(): Effect.Effect<void>;
+    /**
+     * Marks the scope disposed and detaches it from the dispatcher. The caller
+     * is responsible for running {@link close_effect} to run finalizers.
+     * Idempotent.
+     */
+    dispose(): void;
+}

package/.dist/dispatcher/types.d.ts

@@ -1,15 +1,4 @@
 import type { Effect } from "effect";
-/**
- * Stable operation codes used by transform-generated dispatcher events.
- *
- * @example
- * ```ts
- * const type = Code.Markup.Promise;
- * ```
- *
- * @since 3.3.0
- * @internal
- */
 export declare const Code: {
     readonly Markup: {
         readonly Promise: "MarkupPromise";
@@ -17,187 +6,47 @@ export declare const Code: {
         readonly Value: "MarkupValue";
     };
 };
-/**
- * Options for markup promise behavior during server rendering.
- *
- * @example
- * ```ts
- * const options: MarkupPromiseOptions = { ssr: "pending" };
- * ```
- *
- * @since 3.3.0
- * @internal
- */
 export interface MarkupPromiseOptions {
     /** Keep the SSR promise pending so Svelte renders an await block fallback. */
     ssr?: "pending";
 }
-/**
- * Minimal cleanup handle returned by dispatcher lifecycle hooks.
- *
- * @example
- * ```ts
- * const dispose: Dispose = dispatcher.fork(program);
- * dispose();
- * ```
- *
- * @since 2.0.0
- * @internal
- */
 export type Dispose = () => void;
-/**
- * Options for a cached dispatcher value block.
- *
- * @example
- * ```ts
- * const options: ValueOptions<number> = {
- *   id: "count",
- *   deps: [],
- *   fallback: 0,
- *   factory: () => Effect.succeed(1),
- * };
- * ```
- *
- * @since 2.0.0
- * @internal
- */
 export interface ValueOptions<A> {
     /** Stable cache key for this value block. */
     id: string;
-    /** Reactive dependency array. */
     deps: readonly unknown[];
     /** Value returned synchronously while the effect is running or during SSR. */
     fallback: A;
-    /** Generator function that yields the effect to run. */
     factory: () => Effect.gen.Return<A, unknown, unknown>;
 }
-/**
- * Options for a cached dispatcher promise block.
- *
- * @example
- * ```ts
- * const options: PromiseOptions<number> = {
- *   id: "count",
- *   deps: [],
- *   factory: () => Effect.succeed(1),
- * };
- * ```
- *
- * @since 2.0.0
- * @internal
- */
 export interface PromiseOptions<A> {
     /** Stable cache key for this promise block. */
     id: string;
-    /** Reactive dependency array. */
     deps: readonly unknown[];
-    /** Generator function that yields the effect to run. */
     factory: () => Effect.gen.Return<A, unknown, unknown>;
 }
-/**
- * Generated event that reads a markup expression through the cached value
- * channel.
- *
- * @example
- * ```ts
- * const event: MarkupValueEvent<number, undefined> = {
- *   type: Code.Markup.Value,
- *   id: "Component.svelte:1:2",
- *   deps: [],
- *   fallback: undefined,
- *   fn: function* () {
- *     return yield* Effect.succeed(1);
- *   },
- * };
- * ```
- *
- * @since 3.3.0
- * @internal
- */
 export interface MarkupValueEvent<A, F> {
-    /** Dispatcher code identifying a markup value read. */
     type: typeof Code.Markup.Value;
     /** Stable identifier generated from the expression's source position. */
     id: string;
-    /** Reactive dependency array captured from free identifiers. */
     deps: readonly unknown[];
     /** Value returned synchronously while the effect is pending. */
     fallback: F;
-    /** Generator function that yields the effect to run. */
     fn: () => Effect.gen.Return<A, unknown, unknown>;
 }
-/**
- * Generated event that reads a markup expression through the cached promise
- * channel.
- *
- * @example
- * ```ts
- * const event: MarkupPromiseEvent<number> = {
- *   type: Code.Markup.Promise,
- *   id: "Component.svelte:1:2",
- *   deps: [],
- *   fn: function* () {
- *     return yield* Effect.succeed(1);
- *   },
- * };
- * ```
- *
- * @since 3.3.0
- * @internal
- */
 export interface MarkupPromiseEvent<A> {
-    /** Dispatcher code identifying a markup promise read. */
     type: typeof Code.Markup.Promise;
     /** Stable identifier generated from the expression's source position. */
     id: string;
-    /** Reactive dependency array captured from free identifiers. */
     deps: readonly unknown[];
-    /** Generator function that yields the effect to run. */
     fn: () => Effect.gen.Return<A, unknown, unknown>;
     /** Value resolved during SSR when a fallback is required. */
     ssr_fallback?: A;
     /** Optional SSR behavior for await blocks and similar contexts. */
     options?: MarkupPromiseOptions;
 }
-/**
- * Generated event that runs an event-handler Effect.
- *
- * @example
- * ```ts
- * const event: MarkupRunEvent<void> = {
- *   type: Code.Markup.Run,
- *   fn: function* () {
- *     yield* Effect.void;
- *   },
- * };
- * ```
- *
- * @since 3.3.0
- * @internal
- */
 export interface MarkupRunEvent<A> {
-    /** Dispatcher code identifying a markup event-handler run. */
     type: typeof Code.Markup.Run;
-    /** Generator function that yields the effect to run. */
     fn: () => Effect.gen.Return<A, unknown, unknown>;
 }
-/**
- * Union of generated dispatcher events.
- *
- * @example
- * ```ts
- * const event: DispatcherEvent<number, undefined> = {
- *   type: Code.Markup.Value,
- *   id: "Component.svelte:1:2",
- *   deps: [],
- *   fallback: undefined,
- *   fn: function* () {
- *     return yield* Effect.succeed(1);
- *   },
- * };
- * ```
- *
- * @since 3.3.0
- * @internal
- */
 export type DispatcherEvent<A, F = A> = MarkupPromiseEvent<A> | MarkupRunEvent<A> | MarkupValueEvent<A, F>;

package/.dist/dispatcher.d.ts

@@ -1,2 +1,3 @@
-export { Code, Dispatcher, get_dispatcher, reset_dispatcher } from "./dispatcher/index.js";
+export { Code, ComponentScopeRef, Dispatcher, get_dispatcher, reset_dispatcher, } from "./dispatcher/index.js";
+export { ComponentScope } from "./dispatcher/scope.js";
 export type { DispatcherEvent, Dispose, MarkupPromiseEvent, MarkupPromiseOptions, MarkupRunEvent, MarkupValueEvent, PromiseOptions, ValueOptions, } from "./dispatcher/types.js";

package/.dist/dispatcher.js

@@ -1,2 +1,2 @@
-import { i as Code, n as get_dispatcher, r as reset_dispatcher, t as Dispatcher } from "./chunks/dispatcher-DOx8iC6r.js";
-export { Code, Dispatcher, get_dispatcher, reset_dispatcher };
+import { a as Code, i as reset_dispatcher, n as Dispatcher, o as ComponentScope, r as get_dispatcher, t as ComponentScopeRef } from "./chunks/dispatcher-CTWINW5I.js";
+export { Code, ComponentScope, ComponentScopeRef, Dispatcher, get_dispatcher, reset_dispatcher };