@thomasfosterau/legation-svelte 0.0.0-stage → 0.1.0

package/dist/kit/index.js

@@ -0,0 +1,180 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import { Client, ClientStore, Hydration } from "@thomasfosterau/legation";
+import * as P from "effect/Predicate";
+// src/kit/clientGroup.ts
+/** The client-group cookie's default name. */
+const CLIENT_GROUP_COOKIE = "legation-client-group";
+const ONE_YEAR = 31536e3;
+/**
+* Read the browser's client group id from its cookie, minting one when
+* absent. Call it in a server `load` (or `handle`) and render the page's
+* snapshot under the returned id; the client boots its engine with the same
+* id (it can read the cookie itself, or take the value from the load data).
+*
+* The cookie is deliberately not `httpOnly` — the client engine needs the
+* same group id. It carries no authority: identity is resolved server-side
+* through the `IdentityResolver` seam, never from this value.
+*/
+const clientGroupId = (cookies, options) => {
+	const name = options?.name ?? "legation-client-group";
+	const existing = cookies.get(name);
+	if (existing !== void 0 && existing !== "") return existing;
+	const id = (options?.generate ?? (() => crypto.randomUUID()))();
+	cookies.set(name, id, {
+		path: options?.path ?? "/",
+		httpOnly: false,
+		sameSite: "lax",
+		maxAge: options?.maxAge ?? ONE_YEAR
+	});
+	return id;
+};
+// src/kit/load.ts
+function loadSnapshot(cookies, options) {
+	return Effect.suspend(() => {
+		const group = clientGroupId(cookies, options.cookie);
+		return Hydration.snapshot({
+			...options,
+			clientGroupId: group
+		}).pipe(Effect.map((snapshot) => ({
+			snapshot,
+			clientGroupId: group
+		})));
+	});
+}
+// src/kit/boot.ts
+/**
+* Client boot
+*
+* `clientRuntime` is the browser half of the SSR flow: hydrate the page's
+* snapshot into the durable store — but only when the store is empty
+* (`Hydration.hydrateIfEmpty`: a repeat visit's durable rows, cookie, and
+* journalled offline mutations are all fresher than the snapshot) — then build
+* the Client over that store.
+*
+* Both halves are core: `Hydration` does the moving of state, `Client.make`
+* does the wiring. This is only the Svelte-shaped assembly of them, producing
+* the `ManagedRuntime` {@link setClientRuntime} expects, so a root layout can
+* hand it straight to context.
+*/
+const hydrated = (store, snapshot) => snapshot === void 0 ? store : Layer.effect(ClientStore.ClientStore)(Effect.gen(function* () {
+	const built = yield* ClientStore.ClientStore;
+	yield* Hydration.hydrateIfEmpty(built, snapshot).pipe(Effect.orDie);
+	return built;
+})).pipe(Layer.provide(store));
+/**
+* Build the tab's Client runtime: store (snapshot-hydrated when empty) →
+* transport → `Client.make`, which starts the sync loop itself. Hand the
+* result to `setClientRuntime`, and dispose it when the app tears down.
+*/
+const clientRuntime = (options) => {
+	const { store, transport, snapshot, subscribe, ...client } = options;
+	return ManagedRuntime.make(Layer.effect(Client.Client)(Effect.gen(function* () {
+		const { client: built } = yield* Client.make(client);
+		if (subscribe !== void 0) yield* Effect.forEach(subscribe, (read) => built.subscribe(read), { discard: true }).pipe(Effect.orDie);
+		return built;
+	})).pipe(Layer.provide(transport), Layer.provide(hydrated(store, snapshot))));
+};
+// src/kit/formMutation.ts
+/** The hidden field carrying the rendered form's form client id. */
+const FORM_CLIENT_FIELD = "legation-form-client";
+/** The hidden field carrying the form client's mutation id. */
+const FORM_MUTATION_FIELD = "legation-form-mutation";
+/** The key of the action result's data under which the receipt travels. */
+const RECEIPT_KEY = "legationReceipt";
+/**
+* Mint a form client for one rendered form: a fresh id with mutation id `1`
+* (ADR-0030 #215 §2). The page's server `load` mints one per form and renders
+* it in the {@link FORM_CLIENT_FIELD} and {@link FORM_MUTATION_FIELD} hidden
+* fields, so a resubmission of the same rendered form is the same mutation.
+*/
+const mintFormClient = (generate = () => crypto.randomUUID()) => ({
+	clientId: `form-${generate()}`,
+	mutationId: 1
+});
+/** The form client a posted form names, or `undefined` when its fields are missing or malformed. */
+const formClientOf = (data) => {
+	const clientId = data.get(FORM_CLIENT_FIELD);
+	const mutationId = Number(data.get(FORM_MUTATION_FIELD));
+	return P.isString(clientId) && clientId !== "" && Number.isInteger(mutationId) && mutationId >= 1 ? {
+		clientId,
+		mutationId
+	} : void 0;
+};
+/**
+* Read where a form action's Mutation runs: the client group from its cookie
+* (never minted here) and the form client from the posted fields. `undefined`
+* means the action cannot name the group or the form: it stays an out-of-band
+* writer.
+*/
+const formMutationTarget = (cookies, data, options) => {
+	const group = cookies.get(options?.cookieName ?? "legation-client-group");
+	const form = formClientOf(data);
+	return group === void 0 || group === "" || form === void 0 ? void 0 : {
+		clientGroupId: group,
+		...form
+	};
+};
+/**
+* Run the form layer's decoded args as the target's Mutation on the server
+* (`Server.mutate`) and answer the receipt. Return it from the action as
+* `{ [RECEIPT_KEY]: receipt }`, so the enhanced submit settles on it; a
+* rejected receipt's `reason` is the form layer's to route to a message.
+* Args that do not fit the Mutation's schema are a defect, not a field error.
+*/
+const runFormMutation = (server, target, mutation, args) => server.mutate({
+	clientGroupId: target.clientGroupId,
+	clientId: target.clientId,
+	mutationId: target.mutationId,
+	mutation,
+	args
+});
+/** The receipt an action result carries under {@link RECEIPT_KEY}, or `undefined`. */
+const receiptOf = (result) => {
+	if (result.type !== "success" && result.type !== "failure") return void 0;
+	const receipt = result.data?.[RECEIPT_KEY];
+	if (!P.hasProperty(receipt, "clientId") || !P.hasProperty(receipt, "mutationId") || !P.hasProperty(receipt, "phase") || !P.isString(receipt.clientId) || !P.isNumber(receipt.mutationId) || receipt.phase !== "acknowledged" && receipt.phase !== "rejected") return;
+	if (receipt.phase === "acknowledged") return {
+		clientId: receipt.clientId,
+		mutationId: receipt.mutationId,
+		phase: "acknowledged"
+	};
+	const reason = P.hasProperty(receipt, "reason") && P.isString(receipt.reason) ? receipt.reason : "";
+	return {
+		clientId: receipt.clientId,
+		mutationId: receipt.mutationId,
+		phase: "rejected",
+		reason
+	};
+};
+/**
+* The enhanced submit for a form-action Mutation: pass it to SvelteKit's
+* `use:enhance`. Each submit mints a fresh form client and writes it into the
+* posted fields, overlays the Mutation's local effect under it without
+* journaling it (the action delivers it), and settles on the receipt the
+* action returns under {@link RECEIPT_KEY}: acknowledged moves the effect to
+* the unpulled tail, where the pull that covers the form client releases it;
+* rejected drops it. A result without a receipt (an error, a redirect, a
+* failed network) abandons the effect, and the next pull shows the server's
+* state. While offline the submit fails as the network fails (ADR-0030 open
+* point 6).
+*/
+const enhanceFormMutation = (runtime, options) => ({ formData }) => {
+	const form = mintFormClient(options.generate);
+	formData.set(FORM_CLIENT_FIELD, form.clientId);
+	formData.set(FORM_MUTATION_FIELD, String(form.mutationId));
+	const begun = runtime.runPromise(Effect.gen(function* () {
+		return yield* (yield* Client.Client).beginFormMutation(form, options.mutation.name, options.args(formData));
+	}));
+	return async ({ result, update }) => {
+		const submission = await begun;
+		const receipt = receiptOf(result);
+		await runtime.runPromise(receipt === void 0 ? submission.abandon : submission.settle(receipt).pipe(Effect.orDie));
+		if (receipt !== void 0) options.onReceipt?.(receipt);
+		await update({ refreshAll: options.refreshAll ?? false });
+	};
+};
+export { CLIENT_GROUP_COOKIE, FORM_CLIENT_FIELD, FORM_MUTATION_FIELD, RECEIPT_KEY, clientGroupId, clientRuntime, enhanceFormMutation, formClientOf, formMutationTarget, loadSnapshot, mintFormClient, receiptOf, runFormMutation };
+
+//# sourceMappingURL=index.js.map

package/dist/kit/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/kit/clientGroup.ts","../../src/kit/load.ts","../../src/kit/boot.ts","../../src/kit/formMutation.ts"],"sourcesContent":["/**\n * Client-group cookie\n *\n * The SSR flow renders under the *browser's* client group id so the snapshot\n * cookie continues that group's CVR conversation (see `Hydration.snapshot` in\n * `@thomasfosterau/legation`). The group id therefore has to be stable per browser and\n * visible to both the server (each `load`) and the client (the engine's\n * `clientGroupId` option) — an ordinary, non-`httpOnly` HTTP cookie.\n *\n * `clientGroupId(cookies)` reads it, minting and setting it on first contact.\n */\nimport type { Cookies } from \"@sveltejs/kit\";\n\n/** Options for {@link clientGroupId}. */\nexport interface ClientGroupOptions {\n  /** Cookie name. Default `\"legation-client-group\"`. */\n  readonly name?: string;\n  /** Generate a fresh id on first contact. Default `crypto.randomUUID`. */\n  readonly generate?: () => string;\n  /** Cookie path. Default `\"/\"`. */\n  readonly path?: string;\n  /** Cookie lifetime in seconds. Default one year. */\n  readonly maxAge?: number;\n}\n\n/** The client-group cookie's default name. */\nexport const CLIENT_GROUP_COOKIE = \"legation-client-group\";\nconst ONE_YEAR = 60 * 60 * 24 * 365;\n\n/**\n * Read the browser's client group id from its cookie, minting one when\n * absent. Call it in a server `load` (or `handle`) and render the page's\n * snapshot under the returned id; the client boots its engine with the same\n * id (it can read the cookie itself, or take the value from the load data).\n *\n * The cookie is deliberately not `httpOnly` — the client engine needs the\n * same group id. It carries no authority: identity is resolved server-side\n * through the `IdentityResolver` seam, never from this value.\n */\nexport const clientGroupId = (cookies: Cookies, options?: ClientGroupOptions): string => {\n  const name = options?.name ?? CLIENT_GROUP_COOKIE;\n  const existing = cookies.get(name);\n  if (existing !== undefined && existing !== \"\") return existing;\n  const id = (options?.generate ?? (() => crypto.randomUUID()))();\n  cookies.set(name, id, {\n    path: options?.path ?? \"/\",\n    httpOnly: false,\n    sameSite: \"lax\",\n    maxAge: options?.maxAge ?? ONE_YEAR,\n  });\n  return id;\n};\n","/**\n * Server `load` sugar\n *\n * `loadSnapshot` combines the client-group cookie with `Hydration.snapshot`:\n * resolve (or mint) the browser's group id, render the page's subsets over a\n * request-scoped engine, and return `{ snapshot, clientGroupId }` for the\n * page data. Run it inside any Effect-based server `load` (e.g.\n * `@thomasfosterau/effect-sveltekit`'s `serverLoad`). The snapshot itself is\n * core (`Hydration.snapshot`); this only folds the cookie into it.\n *\n * Where the backend lives decides what the `load` supplies. Same process:\n * provide the app's sync server as `ServerHandler` and pass no transport.\n * Separate Worker (the usual Cloudflare shape — a SvelteKit Worker in front\n * of a binding-only API Worker): pass a `transport` built from the request's\n * service binding (`BindingTransport` in `@thomasfosterau/legation-alchemy-cloudflare`), and nothing\n * is required from context.\n */\nimport type { Cookies } from \"@sveltejs/kit\";\nimport * as Effect from \"effect/Effect\";\nimport { Hydration, type Transport } from \"@thomasfosterau/legation\";\nimport type {\n  MutatorError,\n  StoreError,\n  TransportError,\n  VersionNotSupportedError,\n} from \"@thomasfosterau/legation\";\nimport { clientGroupId, type ClientGroupOptions } from \"./clientGroup.js\";\n\n/** Options for {@link loadSnapshot}. */\nexport interface LoadSnapshotOptions extends Omit<Hydration.SnapshotOptions, \"clientGroupId\"> {\n  /** Client-group cookie options (name, generation, lifetime). */\n  readonly cookie?: ClientGroupOptions;\n}\n\n/** {@link LoadSnapshotOptions} with the carrier supplied — no `ServerHandler` needed. */\nexport interface RemoteLoadSnapshotOptions extends LoadSnapshotOptions {\n  readonly transport: Transport.ClientTransport;\n}\n\n/** What {@link loadSnapshot} returns — put both in the page data. */\nexport interface LoadedSnapshot {\n  readonly snapshot: Hydration.Snapshot;\n  readonly clientGroupId: string;\n}\n\ntype LoadSnapshotError = StoreError | TransportError | MutatorError | VersionNotSupportedError;\n\n/**\n * Resolve the request's client group id from its cookie and produce the SSR\n * snapshot for the given subsets under it.\n *\n * The group id is the point of the cookie: the render happens under the\n * *browser's* group, so the snapshot's pull cookie continues that group's CVR\n * conversation. That holds over a remote `transport` too — the id travels on\n * the pull request and the server's fresh cookie travels back.\n */\nexport function loadSnapshot(\n  cookies: Cookies,\n  options: RemoteLoadSnapshotOptions\n): Effect.Effect<LoadedSnapshot, LoadSnapshotError>;\n/** The in-process form: renders against the app's sync server, the `ServerHandler` in context. */\nexport function loadSnapshot(\n  cookies: Cookies,\n  options: LoadSnapshotOptions\n): Effect.Effect<LoadedSnapshot, LoadSnapshotError, Transport.ServerHandler>;\nexport function loadSnapshot(\n  cookies: Cookies,\n  options: LoadSnapshotOptions\n): Effect.Effect<LoadedSnapshot, LoadSnapshotError, Transport.ServerHandler> {\n  return Effect.suspend(() => {\n    const group = clientGroupId(cookies, options.cookie);\n    return Hydration.snapshot({ ...options, clientGroupId: group }).pipe(\n      Effect.map((snapshot) => ({ snapshot, clientGroupId: group }))\n    );\n  });\n}\n","/**\n * Client boot\n *\n * `clientRuntime` is the browser half of the SSR flow: hydrate the page's\n * snapshot into the durable store — but only when the store is empty\n * (`Hydration.hydrateIfEmpty`: a repeat visit's durable rows, cookie, and\n * journalled offline mutations are all fresher than the snapshot) — then build\n * the Client over that store.\n *\n * Both halves are core: `Hydration` does the moving of state, `Client.make`\n * does the wiring. This is only the Svelte-shaped assembly of them, producing\n * the `ManagedRuntime` {@link setClientRuntime} expects, so a root layout can\n * hand it straight to context.\n */\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as ManagedRuntime from \"effect/ManagedRuntime\";\nimport { Client, ClientStore, Hydration, type Transport } from \"@thomasfosterau/legation\";\nimport type { ClientRuntime } from \"../Runtime.js\";\n\n/** Options for {@link clientRuntime}. */\nexport interface ClientRuntimeOptions extends Omit<Client.MakeOptions, \"store\" | \"transport\"> {\n  /** Fully-provided client store layer (e.g. `IndexedDbClientStore.layerWindow()`). */\n  readonly store: Layer.Layer<ClientStore.ClientStore>;\n  /** Fully-provided transport layer (RPC client, or an in-memory pair in tests). */\n  readonly transport: Layer.Layer<Transport.ClientTransport>;\n  /** The page's SSR snapshot, hydrated into an empty store before the Client boots. */\n  readonly snapshot?: Hydration.Snapshot;\n  /** Reads to pin for the runtime's lifetime (the app shell's working set). */\n  readonly subscribe?: ReadonlyArray<Parameters<Client.Client[\"subscribe\"]>[0]>;\n}\n\nconst hydrated = (\n  store: Layer.Layer<ClientStore.ClientStore>,\n  snapshot: Hydration.Snapshot | undefined\n): Layer.Layer<ClientStore.ClientStore> =>\n  snapshot === undefined\n    ? store\n    : Layer.effect(ClientStore.ClientStore)(\n        Effect.gen(function* () {\n          const built = yield* ClientStore.ClientStore;\n          // A hydration failure is a boot-integrity defect, not a recoverable\n          // runtime error — surface it as such.\n          yield* Hydration.hydrateIfEmpty(built, snapshot).pipe(Effect.orDie);\n          return built;\n        })\n      ).pipe(Layer.provide(store));\n\n/**\n * Build the tab's Client runtime: store (snapshot-hydrated when empty) →\n * transport → `Client.make`, which starts the sync loop itself. Hand the\n * result to `setClientRuntime`, and dispose it when the app tears down.\n */\nexport const clientRuntime = (options: ClientRuntimeOptions): ClientRuntime => {\n  const { store, transport, snapshot, subscribe, ...client } = options;\n  return ManagedRuntime.make(\n    Layer.effect(Client.Client)(\n      Effect.gen(function* () {\n        const { client: built } = yield* Client.make(client);\n        if (subscribe !== undefined) {\n          yield* Effect.forEach(subscribe, (read) => built.subscribe(read), {\n            discard: true,\n          }).pipe(Effect.orDie);\n        }\n        return built;\n      })\n    ).pipe(Layer.provide(transport), Layer.provide(hydrated(store, snapshot)))\n  );\n};\n","/**\n * Form-action Mutations (ADR-0030, amendment #215)\n *\n * A SvelteKit form action that can name the client group runs a named\n * Mutation as one of that group's mutations, under a **form client** id\n * minted for the rendered form with mutation id `1`. The mechanism is core\n * (`Server.mutate`); this module adds only what binds to SvelteKit:\n *\n * - Server: {@link mintFormClient} for the page that renders the form,\n *   {@link formMutationTarget} to read the group cookie and the posted\n *   form-client fields, and {@link runFormMutation} to hand the form layer's\n *   decoded args to `Server.mutate`. The action returns the receipt under\n *   {@link RECEIPT_KEY}.\n * - Client: {@link enhanceFormMutation}, the enhanced submit for `use:enhance`.\n *   It overlays the Mutation's effect under a fresh form client, then settles\n *   on the receipt: acknowledged moves it to the unpulled tail until the pull\n *   that covers it, rejected drops it.\n *\n * An action that cannot name the group (no cookie) is not routed here: it\n * stays an out-of-band writer (ADR-0020, amended), committing through the\n * app's API and announcing the change with `Server.broadcast`.\n *\n * One path per write: a page writes a submission either through its form\n * action (this module) or through a façade write (#169, ADR-0030 §1–§2),\n * never both for the same submission, or the write would be applied twice.\n */\nimport type { Cookies } from \"@sveltejs/kit\";\nimport * as Effect from \"effect/Effect\";\nimport * as P from \"effect/Predicate\";\nimport {\n  Client,\n  type Mutation,\n  type Server,\n  type TransportError,\n  type VersionNotSupportedError,\n} from \"@thomasfosterau/legation\";\nimport type { ClientRuntime } from \"../Runtime.js\";\nimport { CLIENT_GROUP_COOKIE } from \"./clientGroup.js\";\n\n/** The hidden field carrying the rendered form's form client id. */\nexport const FORM_CLIENT_FIELD = \"legation-form-client\";\n/** The hidden field carrying the form client's mutation id. */\nexport const FORM_MUTATION_FIELD = \"legation-form-mutation\";\n/** The key of the action result's data under which the receipt travels. */\nexport const RECEIPT_KEY = \"legationReceipt\";\n\n/** A form client: the id minted for one rendered form, and its mutation id (`1`). */\nexport interface FormClient {\n  readonly clientId: string;\n  readonly mutationId: number;\n}\n\n/**\n * Mint a form client for one rendered form: a fresh id with mutation id `1`\n * (ADR-0030 #215 §2). The page's server `load` mints one per form and renders\n * it in the {@link FORM_CLIENT_FIELD} and {@link FORM_MUTATION_FIELD} hidden\n * fields, so a resubmission of the same rendered form is the same mutation.\n */\nexport const mintFormClient = (generate: () => string = () => crypto.randomUUID()): FormClient => ({\n  clientId: `form-${generate()}`,\n  mutationId: 1,\n});\n\n/** The form client a posted form names, or `undefined` when its fields are missing or malformed. */\nexport const formClientOf = (data: FormData): FormClient | undefined => {\n  const clientId = data.get(FORM_CLIENT_FIELD);\n  const mutationId = Number(data.get(FORM_MUTATION_FIELD));\n  return P.isString(clientId) && clientId !== \"\" && Number.isInteger(mutationId) && mutationId >= 1\n    ? { clientId, mutationId }\n    : undefined;\n};\n\n/** Where a form action's Mutation runs: the client group and the form client. */\nexport interface FormMutationTarget extends FormClient {\n  readonly clientGroupId: string;\n}\n\n/** Options for {@link formMutationTarget}. */\nexport interface FormMutationTargetOptions {\n  /** The client-group cookie's name. Default `\"legation-client-group\"`, as `clientGroupId` uses. */\n  readonly cookieName?: string | undefined;\n}\n\n/**\n * Read where a form action's Mutation runs: the client group from its cookie\n * (never minted here) and the form client from the posted fields. `undefined`\n * means the action cannot name the group or the form: it stays an out-of-band\n * writer.\n */\nexport const formMutationTarget = (\n  cookies: Cookies,\n  data: FormData,\n  options?: FormMutationTargetOptions\n): FormMutationTarget | undefined => {\n  const group = cookies.get(options?.cookieName ?? CLIENT_GROUP_COOKIE);\n  const form = formClientOf(data);\n  return group === undefined || group === \"\" || form === undefined\n    ? undefined\n    : { clientGroupId: group, ...form };\n};\n\n/**\n * Run the form layer's decoded args as the target's Mutation on the server\n * (`Server.mutate`) and answer the receipt. Return it from the action as\n * `{ [RECEIPT_KEY]: receipt }`, so the enhanced submit settles on it; a\n * rejected receipt's `reason` is the form layer's to route to a message.\n * Args that do not fit the Mutation's schema are a defect, not a field error.\n */\nexport const runFormMutation = <Args, ArgsEncoded>(\n  server: Server.Server,\n  target: FormMutationTarget,\n  mutation: Mutation.Mutator<string, Args, ArgsEncoded>,\n  args: Args\n): Effect.Effect<Server.Receipt, TransportError | VersionNotSupportedError> =>\n  server.mutate({\n    clientGroupId: target.clientGroupId,\n    clientId: target.clientId,\n    mutationId: target.mutationId,\n    mutation,\n    args,\n  });\n\n/**\n * The part of SvelteKit's `ActionResult` (from `$app/forms`) read here: its\n * type, and the data a `success` or `failure` result carries.\n */\nexport interface FormActionResult {\n  readonly type: string;\n  readonly data?: Readonly<Record<string, unknown>> | undefined;\n}\n\n/**\n * The submit function {@link enhanceFormMutation} returns, typed by the parts\n * of SvelteKit's `SubmitFunction` it uses, so it can be passed to `enhance`.\n */\nexport type FormSubmitFunction = (input: {\n  readonly formData: FormData;\n}) => (opts: {\n  readonly result: FormActionResult;\n  readonly update: (options?: { refreshAll?: boolean }) => Promise<void>;\n}) => Promise<void>;\n\n/** The receipt an action result carries under {@link RECEIPT_KEY}, or `undefined`. */\nexport const receiptOf = (result: FormActionResult): Server.Receipt | undefined => {\n  if (result.type !== \"success\" && result.type !== \"failure\") return undefined;\n  const receipt: unknown = result.data?.[RECEIPT_KEY];\n  if (\n    !P.hasProperty(receipt, \"clientId\") ||\n    !P.hasProperty(receipt, \"mutationId\") ||\n    !P.hasProperty(receipt, \"phase\") ||\n    !P.isString(receipt.clientId) ||\n    !P.isNumber(receipt.mutationId) ||\n    (receipt.phase !== \"acknowledged\" && receipt.phase !== \"rejected\")\n  ) {\n    return undefined;\n  }\n  if (receipt.phase === \"acknowledged\") {\n    return { clientId: receipt.clientId, mutationId: receipt.mutationId, phase: \"acknowledged\" };\n  }\n  const reason =\n    P.hasProperty(receipt, \"reason\") && P.isString(receipt.reason) ? receipt.reason : \"\";\n  return { clientId: receipt.clientId, mutationId: receipt.mutationId, phase: \"rejected\", reason };\n};\n\n/** Options for {@link enhanceFormMutation}. */\nexport interface EnhanceFormMutationOptions<Args, ArgsEncoded> {\n  /** The Mutation the form's action runs. */\n  readonly mutation: Mutation.Mutator<string, Args, ArgsEncoded>;\n  /** The Mutation's args, read from the submitted form data (the form layer's decode). */\n  readonly args: (data: FormData) => Args;\n  /**\n   * Re-run the page's `load` functions after the action, SvelteKit's default.\n   * Default `false`: the overlay already shows the write, and the pull that\n   * covers it brings the confirmed rows (ADR-0030 #215 §4).\n   */\n  readonly refreshAll?: boolean | undefined;\n  /** Mint the per-submit form client id. Default `crypto.randomUUID`. */\n  readonly generate?: (() => string) | undefined;\n  /** Called with the receipt once the submission settles, e.g. to show a rejection's reason. */\n  readonly onReceipt?: ((receipt: Server.Receipt) => void) | undefined;\n}\n\n/**\n * The enhanced submit for a form-action Mutation: pass it to SvelteKit's\n * `use:enhance`. Each submit mints a fresh form client and writes it into the\n * posted fields, overlays the Mutation's local effect under it without\n * journaling it (the action delivers it), and settles on the receipt the\n * action returns under {@link RECEIPT_KEY}: acknowledged moves the effect to\n * the unpulled tail, where the pull that covers the form client releases it;\n * rejected drops it. A result without a receipt (an error, a redirect, a\n * failed network) abandons the effect, and the next pull shows the server's\n * state. While offline the submit fails as the network fails (ADR-0030 open\n * point 6).\n */\nexport const enhanceFormMutation =\n  <Args, ArgsEncoded>(\n    runtime: ClientRuntime,\n    options: EnhanceFormMutationOptions<Args, ArgsEncoded>\n  ): FormSubmitFunction =>\n  ({ formData }) => {\n    const form = mintFormClient(options.generate);\n    formData.set(FORM_CLIENT_FIELD, form.clientId);\n    formData.set(FORM_MUTATION_FIELD, String(form.mutationId));\n    const begun = runtime.runPromise(\n      Effect.gen(function* () {\n        const client = yield* Client.Client;\n        return yield* client.beginFormMutation(form, options.mutation.name, options.args(formData));\n      })\n    );\n    return async ({ result, update }) => {\n      const submission = await begun;\n      const receipt = receiptOf(result);\n      await runtime.runPromise(\n        receipt === undefined ? submission.abandon : submission.settle(receipt).pipe(Effect.orDie)\n      );\n      if (receipt !== undefined) options.onReceipt?.(receipt);\n      await update({ refreshAll: options.refreshAll ?? false });\n    };\n  };\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,71 @@
 {
   "name": "@thomasfosterau/legation-svelte",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Svelte bindings for the legation engine: rune hooks over the Client, plus the SvelteKit integration on /kit",
+  "keywords": [
+    "effect",
+    "runes",
+    "ssr",
+    "svelte",
+    "sveltekit",
+    "sync-engine",
+    "typescript"
+  ],
+  "homepage": "https://github.com/thomasfosterau/legation/tree/trunk/packages/svelte#readme",
+  "bugs": {
+    "url": "https://github.com/thomasfosterau/legation/issues"
+  },
+  "license": "MIT",
+  "author": "Thomas Foster",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thomasfosterau/legation.git",
+    "directory": "packages/svelte"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.svelte.js",
+  "types": "./dist/index.svelte.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.svelte.d.ts",
+      "svelte": "./dist/index.svelte.js",
+      "import": "./dist/index.svelte.js"
+    },
+    "./kit": {
+      "types": "./dist/kit/index.d.ts",
+      "import": "./dist/kit/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@thomasfosterau/effect-svelte": "^0.6.0",
+    "@thomasfosterau/legation": "^0.1.0"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.1.2",
+    "@sveltejs/kit": "^3.1.1",
+    "effect": "4.1.2",
+    "svelte": "^5.57.3",
+    "vitest": "5.0.5"
+  },
+  "peerDependencies": {
+    "@sveltejs/kit": "^2.0.0 || ^3.0.0",
+    "effect": "^4.0.2",
+    "svelte": ">=5.40"
+  },
+  "peerDependenciesMeta": {
+    "@sveltejs/kit": {
+      "optional": true
+    }
+  }
 }