svelte-effect-runtime 1.6.2 → 2.0.0-beta.1

package/.dist/internal/remote-server.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Internal generated-code helpers used by the remote server runtime.
+ *
+ * @module
+ */
+export * from "../remote/server.js";

package/.dist/internal/remote-server.js

@@ -0,0 +1,2 @@
+import { encode_remote_failure, normalize_remote_helper_error, run_remote_effect, throw_form_error } from "../remote/server.js";
+export { encode_remote_failure, normalize_remote_helper_error, run_remote_effect, throw_form_error };

package/.dist/markup/promise.d.ts

@@ -0,0 +1,15 @@
+import type { Effect } from "effect";
+/**
+ * Runtime helper emitted by the markup preprocessor for
+ * `{#await yield* expr}` blocks. Delegates to the dispatcher's
+ * promise mechanism — returns a Promise that resolves when the effect
+ * completes.
+ *
+ * @since 2.0.0
+ * @param id - Stable identifier generated from the expression's source
+ *   position, used for cache lookups.
+ * @param deps - Array of reactive dependencies.
+ * @param factory - Generator function that yields the effect to run.
+ * @returns A Promise that resolves with the effect's result.
+ */
+export declare function promise<A, E, R>(id: string, deps: readonly unknown[], factory: () => Effect.gen.Return<A, E, R>): Promise<A>;

package/.dist/markup/promise.js

@@ -0,0 +1,26 @@
+import { n as get_dispatcher } from "../chunks/dispatcher-BSg2-ttN.js";
+//#region src/markup/promise.ts
+/**
+* Runtime helper emitted by the markup preprocessor for
+* `{#await yield* expr}` blocks. Delegates to the dispatcher's
+* promise mechanism — returns a Promise that resolves when the effect
+* completes.
+*
+* @since 2.0.0
+* @param id - Stable identifier generated from the expression's source
+*   position, used for cache lookups.
+* @param deps - Array of reactive dependencies.
+* @param factory - Generator function that yields the effect to run.
+* @returns A Promise that resolves with the effect's result.
+*/
+function promise(id, deps, factory) {
+	return get_dispatcher().promise({
+		id,
+		deps,
+		factory
+	});
+}
+//#endregion
+export { promise };
+
+//# sourceMappingURL=promise.js.map

package/.dist/markup/promise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.js","names":[],"sources":["../../../modules/svelte-effect-runtime/src/markup/promise.ts"],"sourcesContent":["import { get_dispatcher } from \"$/dispatcher.ts\";\nimport type { Effect } from \"effect\";\n\n/**\n * Runtime helper emitted by the markup preprocessor for\n * `{#await yield* expr}` blocks. Delegates to the dispatcher's\n * promise mechanism — returns a Promise that resolves when the effect\n * completes.\n *\n * @since 2.0.0\n * @param id - Stable identifier generated from the expression's source\n *   position, used for cache lookups.\n * @param deps - Array of reactive dependencies.\n * @param factory - Generator function that yields the effect to run.\n * @returns A Promise that resolves with the effect's result.\n */\nexport function promise<A, E, R>(\n  id: string,\n  deps: readonly unknown[],\n  factory: () => Effect.gen.Return<A, E, R>,\n): Promise<A> {\n  return get_dispatcher().promise({ id, deps, factory });\n}\n"],"mappings":";;;;;;;;;;;;;;;AAgBA,SAAgB,QACd,IACA,MACA,SACY;AACZ,QAAO,gBAAgB,CAAC,QAAQ;EAAE;EAAI;EAAM;EAAS,CAAC"}

package/.dist/markup/run.d.ts

@@ -0,0 +1,12 @@
+import { Effect } from "effect";
+/**
+ * Runtime helper emitted by the markup preprocessor for inline event
+ * handlers containing `yield*`. Wraps the user's generator in an
+ * `Effect.gen` and delegates to the dispatcher's fire-and-forget
+ * mechanism.
+ *
+ * @since 2.0.0
+ * @param factory - Generator function that yields the effect to run.
+ * @returns A Promise that resolves or rejects when the effect completes.
+ */
+export declare function run<A, E, R>(factory: () => Effect.gen.Return<A, E, R>): Promise<A>;

package/.dist/markup/run.js

@@ -0,0 +1,21 @@
+import { n as get_dispatcher } from "../chunks/dispatcher-BSg2-ttN.js";
+import { Effect } from "effect";
+//#region src/markup/run.ts
+/**
+* Runtime helper emitted by the markup preprocessor for inline event
+* handlers containing `yield*`. Wraps the user's generator in an
+* `Effect.gen` and delegates to the dispatcher's fire-and-forget
+* mechanism.
+*
+* @since 2.0.0
+* @param factory - Generator function that yields the effect to run.
+* @returns A Promise that resolves or rejects when the effect completes.
+*/
+function run(factory) {
+	const effect = Effect.gen(factory);
+	return get_dispatcher().run(effect);
+}
+//#endregion
+export { run };
+
+//# sourceMappingURL=run.js.map

package/.dist/markup/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","names":[],"sources":["../../../modules/svelte-effect-runtime/src/markup/run.ts"],"sourcesContent":["import { get_dispatcher } from \"$/dispatcher.ts\";\nimport { Effect } from \"effect\";\n\n/**\n * Runtime helper emitted by the markup preprocessor for inline event\n * handlers containing `yield*`. Wraps the user's generator in an\n * `Effect.gen` and delegates to the dispatcher's fire-and-forget\n * mechanism.\n *\n * @since 2.0.0\n * @param factory - Generator function that yields the effect to run.\n * @returns A Promise that resolves or rejects when the effect completes.\n */\nexport function run<A, E, R>(\n  factory: () => Effect.gen.Return<A, E, R>,\n): Promise<A> {\n  const effect = Effect.gen(factory);\n\n  return get_dispatcher().run(effect);\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,IACd,SACY;CACZ,MAAM,SAAS,OAAO,IAAI,QAAQ;AAElC,QAAO,gBAAgB,CAAC,IAAI,OAAO"}

package/.dist/markup/transform/apply.d.ts

@@ -0,0 +1,6 @@
+import type MagicString from "magic-string";
+import type { HelperDeclaration, Insertion, MarkupRelocation, Replacement } from "./types.js";
+export declare function create_source_map(magic: MagicString, filename: string): Record<string, unknown>;
+export declare function blank_script_blocks(content: string): string;
+export declare function inject_helpers(magic: MagicString, content: string, helpers?: HelperDeclaration[]): Insertion | undefined;
+export declare function create_relocations(replacements: Replacement[], helper_insertion: Insertion | undefined): MarkupRelocation[];

package/.dist/markup/transform/classify.d.ts

@@ -0,0 +1,15 @@
+import type { AST } from "svelte/compiler";
+import type { MarkupCandidate, TagKind } from "./types.js";
+/**
+ * Matches sanitized placeholders back to their Svelte AST context.
+ *
+ * @since 2.0.0
+ * @param ast - Parsed Svelte AST for the sanitized component markup.
+ * @param candidates - Placeholder candidates produced by the scanner.
+ * @returns Candidates paired with the markup context that determines how they
+ *   should be emitted.
+ */
+export declare function classify_candidates(ast: AST.Root, candidates: MarkupCandidate[]): Array<{
+    candidate: MarkupCandidate;
+    kind: TagKind;
+}>;

package/.dist/markup/transform/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const HELPERS: {
+    readonly value: "__ser_markup_value";
+    readonly promise: "__ser_markup_promise";
+    readonly run: "__ser_markup_run";
+};

package/.dist/markup/transform/emit.d.ts

@@ -0,0 +1,12 @@
+import type { MarkupCandidate, Replacement, TagKind } from "./types.js";
+/**
+ * Emits source edits for classified markup Effect expressions.
+ *
+ * @since 2.0.0
+ * @param classified - Candidates paired with their Svelte markup context.
+ * @returns Replacements ready to apply to the original component source.
+ */
+export declare function emit_replacements(classified: Array<{
+    candidate: MarkupCandidate;
+    kind: TagKind;
+}>): Replacement[];

package/.dist/markup/transform/expressions.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Strips an event handler arrow function down to its executable body.
+ *
+ * @since 2.0.0
+ * @param expr - Event handler expression text from the original markup.
+ * @returns Handler parameters, body text, and body offsets inside `expr`.
+ */
+export declare function strip_arrow_function(expr: string): {
+    params: string;
+    body: string;
+    body_start: number;
+    body_end: number;
+};
+/**
+ * Classifies `yield*` placement inside an event handler body.
+ *
+ * @example
+ * ```ts
+ * analyze_event_body_yield_star("yield* save()");
+ * ```
+ *
+ * @since 2.0.0
+ * @param body - Event handler body text after the outer arrow has been
+ *   stripped.
+ * @returns Whether the body has top-level yield* expressions and whether any
+ *   yield* appears inside a nested non-generator callback.
+ */
+export declare function analyze_event_body_yield_star(body: string): {
+    has_top_level_yield_star: boolean;
+    has_nested_invalid_yield_star: boolean;
+};
+/**
+ * Collects free identifiers that must be captured as reactive dependencies.
+ *
+ * @since 2.0.0
+ * @param expr_text - Markup expression text to inspect.
+ * @returns Identifier names referenced by the expression.
+ */
+export declare function collect_free_identifiers(expr_text: string): string[];

package/.dist/markup/transform/index.d.ts

@@ -0,0 +1,19 @@
+import type { MarkupTransformResult } from "./types.js";
+export type { MarkupRelocation, MarkupTransformResult } from "./types.js";
+/**
+ * Transforms Svelte markup containing `{yield* expr}` brace expressions
+ * into calls to the markup runtime helpers (`value`, `promise`, `run`).
+ *
+ * Strategy: first find all brace expressions containing `yield*` via
+ * character scanning, replace them with placeholder identifiers, then
+ * parse the sanitized markup with Svelte's AST to determine the correct
+ * context for each placeholder (plain expression, #each, #await, event
+ * handler, etc.).
+ *
+ * @since 2.0.0
+ * @param content - The raw `.svelte` file content.
+ * @param filename - The source filename, used in error messages.
+ * @returns The transformed markup and a flag indicating whether yield* was
+ *   found.
+ */
+export declare function transform_markup_effect(content: string, filename: string): MarkupTransformResult;

package/.dist/markup/transform/scan.d.ts

@@ -0,0 +1,8 @@
+import type { MarkupCandidate } from "./types.js";
+interface SanitizeResult {
+    code: string;
+    candidates: MarkupCandidate[];
+}
+export declare function sanitize_markup(content: string, filename: string): SanitizeResult;
+export {};
+/** Free identifier collection helpers for generated closures. */

package/.dist/markup/transform/types.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Result of the markup preprocessor pass.
+ *
+ * @since 2.0.0
+ */
+export interface MarkupTransformResult {
+    /** The transformed source code. */
+    code: string;
+    /** Whether any yield* expressions were found and lowered. */
+    has_yield: boolean;
+    /** Source map from transformed markup back to the original component. */
+    map?: Record<string, unknown>;
+    /** Offset ranges that preserve hoverable source spans inside lowered code. */
+    relocations?: MarkupRelocation[];
+}
+/** Offset mapping between original markup and generated helper code. */
+export interface MarkupRelocation {
+    /** Start offset in the original source. */
+    originalStart: number;
+    /** End offset in the original source. */
+    originalEnd: number;
+    /** Start offset in the transformed source. */
+    generatedStart: number;
+    /** End offset in the transformed source. */
+    generatedEnd: number;
+}
+/** Describes a brace expression that contains yield* and needs lowering. */
+export interface MarkupCandidate {
+    /** The placeholder identifier injected into the sanitized markup. */
+    placeholder: string;
+    /** Start offset of the expression in the original source. */
+    start: number;
+    /** End offset of the expression in the original source. */
+    end: number;
+    /** The expression text (without surrounding braces). */
+    expr_text: string;
+    /** Source filename used to keep generated cache ids component-scoped. */
+    filename: string;
+    /** Whether this expression is a key context (each/promise/render key). */
+    key: TagKind;
+}
+export type TagKind = "plain" | "each" | "await" | "event" | "render";
+export interface Replacement {
+    start: number;
+    end: number;
+    text: string;
+    helpers?: HelperDeclaration[];
+    relocation?: PendingRelocation;
+}
+export interface HelperDeclaration {
+    text: string;
+    relocation?: PendingRelocation;
+}
+export interface PendingRelocation {
+    originalStart: number;
+    originalEnd: number;
+    generatedStartInReplacement: number;
+    generatedEndInReplacement: number;
+}
+export interface Insertion {
+    start: number;
+    text: string;
+    relocations?: PendingRelocation[];
+}

package/.dist/markup/transform.d.ts

@@ -0,0 +1 @@
+export { type MarkupRelocation, type MarkupTransformResult, transform_markup_effect, } from "./transform/index.js";

package/.dist/markup/transform.js

@@ -0,0 +1,2 @@
+import { t as transform_markup_effect } from "../chunks/transform-BtlxgJrg.js";
+export { transform_markup_effect };

package/.dist/markup/value.d.ts

@@ -0,0 +1,20 @@
+import type { Effect } from "effect";
+/**
+ * Runtime helper emitted by the markup preprocessor for `{yield* expr}`
+ * expressions in Svelte templates. Delegates to the dispatcher's
+ * cached reactive value mechanism — returns the fallback synchronously,
+ * then the resolved value once the effect completes. The effect is still
+ * started during SSR so SvelteKit remote queries can register hydratable
+ * data before the HTML is sent.
+ *
+ * @since 2.0.0
+ * @param id - Stable identifier generated from the expression's source
+ *   position, used for cache lookups.
+ * @param deps - Array of reactive dependencies (free identifiers in the
+ *   expression). When any dep changes, the previous fiber is cancelled
+ *   and a new one starts.
+ * @param fallback - Value returned while the effect is running.
+ * @param factory - Generator function that yields the effect to run.
+ * @returns The cached value if resolved, or the fallback.
+ */
+export declare function value(id: string, deps: readonly unknown[], fallback: unknown, factory: () => Effect.gen.Return<unknown, unknown, unknown>): unknown;

package/.dist/markup/value.js

@@ -0,0 +1,32 @@
+import { n as get_dispatcher } from "../chunks/dispatcher-BSg2-ttN.js";
+//#region src/markup/value.ts
+/**
+* Runtime helper emitted by the markup preprocessor for `{yield* expr}`
+* expressions in Svelte templates. Delegates to the dispatcher's
+* cached reactive value mechanism — returns the fallback synchronously,
+* then the resolved value once the effect completes. The effect is still
+* started during SSR so SvelteKit remote queries can register hydratable
+* data before the HTML is sent.
+*
+* @since 2.0.0
+* @param id - Stable identifier generated from the expression's source
+*   position, used for cache lookups.
+* @param deps - Array of reactive dependencies (free identifiers in the
+*   expression). When any dep changes, the previous fiber is cancelled
+*   and a new one starts.
+* @param fallback - Value returned while the effect is running.
+* @param factory - Generator function that yields the effect to run.
+* @returns The cached value if resolved, or the fallback.
+*/
+function value(id, deps, fallback, factory) {
+	return get_dispatcher().value({
+		id,
+		deps,
+		fallback,
+		factory
+	});
+}
+//#endregion
+export { value };
+
+//# sourceMappingURL=value.js.map

package/.dist/markup/value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"value.js","names":[],"sources":["../../../modules/svelte-effect-runtime/src/markup/value.ts"],"sourcesContent":["import { get_dispatcher } from \"$/dispatcher.ts\";\nimport type { Effect } from \"effect\";\n\n/**\n * Runtime helper emitted by the markup preprocessor for `{yield* expr}`\n * expressions in Svelte templates. Delegates to the dispatcher's\n * cached reactive value mechanism — returns the fallback synchronously,\n * then the resolved value once the effect completes. The effect is still\n * started during SSR so SvelteKit remote queries can register hydratable\n * data before the HTML is sent.\n *\n * @since 2.0.0\n * @param id - Stable identifier generated from the expression's source\n *   position, used for cache lookups.\n * @param deps - Array of reactive dependencies (free identifiers in the\n *   expression). When any dep changes, the previous fiber is cancelled\n *   and a new one starts.\n * @param fallback - Value returned while the effect is running.\n * @param factory - Generator function that yields the effect to run.\n * @returns The cached value if resolved, or the fallback.\n */\nexport function value(\n  id: string,\n  deps: readonly unknown[],\n  fallback: unknown,\n  factory: () => Effect.gen.Return<unknown, unknown, unknown>,\n): unknown {\n  return get_dispatcher().value({ id, deps, fallback, factory });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,MACd,IACA,MACA,UACA,SACS;AACT,QAAO,gBAAgB,CAAC,MAAM;EAAE;EAAI;EAAM;EAAU;EAAS,CAAC"}

package/.dist/mod.d.ts

@@ -0,0 +1,186 @@
+import type { RequestEvent as RequestEventShape } from "./server/runtime.js";
+import type { CommandFactory, FormFactory, PrerenderFactory, QueryFactory, ServerRuntimeFactory } from "./server/types.js";
+import type { Context, Layer, ManagedRuntime } from "effect";
+/**
+ * Result returned by the root Svelte markup preprocessor hook.
+ *
+ * @since 2.0.0
+ */
+interface MarkupResult {
+    code: string;
+}
+/**
+ * Root preprocessor group shape. The root export keeps transform code lazy so
+ * client imports do not pull parser-only dependencies into the browser.
+ *
+ * @since 2.0.0
+ */
+interface PreprocessGroup {
+    name: string;
+    markup(options: {
+        content: string;
+        filename: string;
+    }): MarkupResult | Promise<MarkupResult>;
+}
+/**
+ * Public API surface for `svelte-effect-runtime`.
+ *
+ * Call {@link ClientRuntime.make} in `hooks.client.ts`, call
+ * {@link ServerRuntime.make} in `hooks.server.ts`, and let the Vite plugin
+ * route server-only helpers to the server entrypoint automatically.
+ *
+ * @module
+ */
+/**
+ * Client-side runtime singleton. Call `ClientRuntime.make(layer?)` once
+ * in `hooks.client.ts` to provide services to every component's effect
+ * blocks.
+ *
+ * If never called, a default empty-layer runtime is created lazily on
+ * the first `yield*` expression.
+ *
+ * @example
+ * ```ts
+ * import { ClientRuntime } from "svelte-effect-runtime";
+ * import { Db } from "./db.js";
+ *
+ * ClientRuntime.make(Db.Live);
+ * ```
+ *
+ * @since 2.0.0
+ */
+export declare class ClientRuntime {
+    /**
+     * Build and cache the client-side dispatcher runtime.
+     *
+     * @since 2.0.0
+     * @param layer - Optional Effect layer to provide to the runtime.
+     */
+    static make<R = never>(layer?: Layer.Layer<R>): void;
+}
+/**
+ * Server-side runtime singleton export. In SvelteKit server files the Vite
+ * plugin rewrites root imports to `svelte-effect-runtime/server`, so this
+ * name resolves to the real server implementation before it is evaluated.
+ *
+ * @example
+ * ```ts
+ * import { ServerRuntime } from "svelte-effect-runtime";
+ *
+ * ServerRuntime.make();
+ * ```
+ *
+ * @since 2.0.0
+ */
+export declare const ServerRuntime: ServerRuntimeFactory;
+/**
+ * Remote query factory export for `.remote.ts` files imported from the root
+ * entrypoint. The Vite plugin rewrites it to the real server implementation.
+ *
+ * @example
+ * ```ts
+ * import { Query } from "svelte-effect-runtime";
+ *
+ * export const GetPosts = Query(Effect.succeed([]));
+ * ```
+ *
+ * @since 2.0.0
+ */
+export declare const Query: QueryFactory;
+/**
+ * Remote command factory export for `.remote.ts` files imported from the root
+ * entrypoint. The Vite plugin rewrites it to the real server implementation.
+ *
+ * @example
+ * ```ts
+ * import { Command } from "svelte-effect-runtime";
+ *
+ * export const SavePost = Command(Schema.String, (id) => Effect.succeed(id));
+ * ```
+ *
+ * @since 2.0.0
+ */
+export declare const Command: CommandFactory;
+/**
+ * Remote form factory export for `.remote.ts` files imported from the root
+ * entrypoint. The Vite plugin rewrites it to the real server implementation.
+ *
+ * @example
+ * ```ts
+ * import { Form } from "svelte-effect-runtime";
+ *
+ * export const CreatePost = Form(PostInput, ({ data }) => Effect.succeed(data));
+ * ```
+ *
+ * @since 2.0.0
+ */
+export declare const Form: FormFactory;
+/**
+ * Remote prerender factory export for `.remote.ts` files imported from the
+ * root entrypoint. The Vite plugin rewrites it to the real server
+ * implementation.
+ *
+ * @example
+ * ```ts
+ * import { Prerender } from "svelte-effect-runtime";
+ *
+ * export const GetBuildInfo = Prerender(() => Effect.succeed("ready"));
+ * ```
+ *
+ * @since 2.0.0
+ */
+export declare const Prerender: PrerenderFactory;
+/**
+ * Current SvelteKit request event service export for `.remote.ts` files
+ * imported from the root entrypoint. The Vite plugin rewrites it to the real
+ * server implementation.
+ *
+ * @example
+ * ```ts
+ * import { RequestEvent } from "svelte-effect-runtime";
+ *
+ * const event = yield* RequestEvent;
+ * ```
+ *
+ * @since 2.0.0
+ */
+export declare const RequestEvent: Context.Reference<RequestEventShape>;
+/**
+ * Returns the active server runtime when imported from a server file. The Vite
+ * plugin rewrites root imports to the real server implementation.
+ *
+ * @example
+ * ```ts
+ * import { get_server_runtime_or_throw } from "svelte-effect-runtime";
+ *
+ * const runtime = get_server_runtime_or_throw();
+ * ```
+ *
+ * @since 2.0.0
+ */
+export declare const get_server_runtime_or_throw: () => ManagedRuntime.ManagedRuntime<unknown, never>;
+/** Re-export error types users need for typed catch handlers. */
+export type { FormError, FormIssue, RemoteFailure, RemoteHttpError, RemoteTransportError, RemoteValidationError, } from "./remote/shared.js";
+export { is_form_error, is_remote_http_error, is_remote_transport_error, is_remote_validation_error, } from "./remote/shared.js";
+/** Re-export app setup helpers so users can import them from root. */
+export { effect, type EffectOptions } from "./vite.js";
+/** Re-export server helper types from the root entrypoint. */
+export type { EffectLike, EffectRemoteBatchHandler, EffectRemoteCommand, EffectRemoteForm, EffectRemoteFunction, EffectRemoteLiveQuery, EffectRemoteLiveQueryFunction, EffectRemoteLiveSource, EffectRemoteQuery, EffectRemoteQueryFunction, FormInvalid, PrerenderOptions, QueryBatchFactory, QueryFactory, QueryLiveFactory, RemoteLiveHandler, RemoteFormHandler, RemoteHandler, SchemaInput, CommandFactory, FormFactory, PrerenderFactory, ServerRuntimeFactory, StandardSchema, } from "./server/types.js";
+/**
+ * Creates the Svelte preprocessor that lowers script and markup `yield*`
+ * expressions. The heavy transform module is loaded lazily so browser imports
+ * from the package root stay client-safe.
+ *
+ * @example
+ * ```js
+ * import { preprocess } from "svelte-effect-runtime";
+ *
+ * export default {
+ *   preprocess: [preprocess()],
+ * };
+ * ```
+ *
+ * @since 2.0.0
+ * @returns A Svelte preprocessor group with an async markup hook.
+ */
+export declare function preprocess(): PreprocessGroup;