@thomasfosterau/effect-forms-svelte 0.1.0 → 0.2.0

package/dist/SvelteKit.js

@@ -4,7 +4,9 @@ const isFormActionData = (data) => typeof data === "object" && data !== null &&
 * Apply a derived form action's result to `form`. On a validation `failure`
 * carrying `{ form }`, repopulate the store's errors + posted values and return
 * `true` (consumed). Otherwise return `false` — the caller should defer to the
-* framework (`applyAction`) for success / redirect / error.
+* framework for success / redirect / error: inside SvelteKit's `enhance`
+* callback that is `update`, which applies the result itself, so don't also
+* call `applyAction`.
 */
 function applyActionResult(form, result) {
 	if (result.type !== "failure" || !isFormActionData(result.data)) return false;

package/dist/SvelteKit.js.map

@@ -1 +1 @@
-{"version":3,"file":"SvelteKit.js","names":[],"sources":["../src/SvelteKit.ts"],"sourcesContent":["/**\n * @copyright Thomas Foster\n *\n * SvelteKit interop for the form store. The framework's `$app/forms` `enhance`\n * / `applyAction` are app-build virtuals (not resolvable from a library), so\n * the SvelteKit-specific glue stays in the consuming app; this module owns the\n * reusable half — applying a derived form action's result back to the store.\n *\n * @module effect-forms-svelte/SvelteKit\n */\n\nimport type { Errors, Result, State } from \"@thomasfosterau/effect-forms\";\nimport type { FormStore } from \"./FormStore.svelte.ts\";\n\ntype FormActionData<A = unknown, Message = unknown> = Result.FormActionData<A, Message>;\ntype FormState<A, Message = unknown> = State.FormState<A, Message>;\ntype FormErrors = Errors.FormErrors;\n\n/**\n * The minimal view of SvelteKit's `ActionResult` that {@link applyActionResult}\n * inspects — a failure carries the derived action's {@link FormActionData}.\n */\nexport interface ServerActionResult {\n  readonly type: \"success\" | \"failure\" | \"redirect\" | \"error\";\n  readonly data?: FormActionData | Record<string, unknown> | undefined;\n}\n\nconst isFormActionData = (data: unknown): data is FormActionData & { form: FormState<unknown> } =>\n  typeof data === \"object\" &&\n  data !== null &&\n  \"form\" in data &&\n  Boolean((data as { form?: unknown }).form);\n\n/**\n * Apply a derived form action's result to `form`. On a validation `failure`\n * carrying `{ form }`, repopulate the store's errors + posted values and return\n * `true` (consumed). Otherwise return `false` — the caller should defer to the\n * framework (`applyAction`) for success / redirect / error.\n */\nexport function applyActionResult(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any concrete store\n  form: FormStore<any, any, any>,\n  result: ServerActionResult,\n): boolean {\n  if (result.type !== \"failure\" || !isFormActionData(result.data)) return false;\n  const state = result.data.form;\n  form.setServerState(state.data, state.errors as FormErrors);\n  return true;\n}\n"],"mappings":";AA2BA,MAAM,oBAAoB,SACxB,OAAO,SAAS,YAChB,SAAS,QACT,UAAU,QACV,QAAS,KAA4B,IAAI;;;;;;;AAQ3C,SAAgB,kBAEd,MACA,QACS;CACT,IAAI,OAAO,SAAS,aAAa,CAAC,iBAAiB,OAAO,IAAI,GAAG,OAAO;CACxE,MAAM,QAAQ,OAAO,KAAK;CAC1B,KAAK,eAAe,MAAM,MAAM,MAAM,MAAoB;CAC1D,OAAO;AACT"}
+{"version":3,"file":"SvelteKit.js","names":[],"sources":["../src/SvelteKit.ts"],"sourcesContent":["/**\n * SvelteKit interop for the form store that needs no SvelteKit import:\n * applying a derived form action's result back to the store. The glue that\n * imports `@sveltejs/kit` or the `$app/forms` virtual lives in the `/kit`\n * entry.\n *\n * @copyright Thomas Foster\n * @module effect-forms-svelte/SvelteKit\n */\n\nimport type { Errors, Result, State } from \"@thomasfosterau/effect-forms\";\nimport type { FormStore } from \"./FormStore.svelte.ts\";\n\ntype FormActionData<A = unknown, Message = unknown> = Result.FormActionData<A, Message>;\ntype FormState<A, Message = unknown> = State.FormState<A, Message>;\ntype FormErrors = Errors.FormErrors;\n\n/**\n * The minimal view of SvelteKit's `ActionResult` that {@link applyActionResult}\n * inspects — a failure carries the derived action's {@link FormActionData}.\n */\nexport interface ServerActionResult {\n  readonly type: \"success\" | \"failure\" | \"redirect\" | \"error\";\n  readonly data?: FormActionData | Record<string, unknown> | undefined;\n}\n\nconst isFormActionData = (data: unknown): data is FormActionData & { form: FormState<unknown> } =>\n  typeof data === \"object\" &&\n  data !== null &&\n  \"form\" in data &&\n  Boolean((data as { form?: unknown }).form);\n\n/**\n * Apply a derived form action's result to `form`. On a validation `failure`\n * carrying `{ form }`, repopulate the store's errors + posted values and return\n * `true` (consumed). Otherwise return `false` — the caller should defer to the\n * framework for success / redirect / error: inside SvelteKit's `enhance`\n * callback that is `update`, which applies the result itself, so don't also\n * call `applyAction`.\n */\nexport function applyActionResult(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any concrete store\n  form: FormStore<any, any, any>,\n  result: ServerActionResult,\n): boolean {\n  if (result.type !== \"failure\" || !isFormActionData(result.data)) return false;\n  const state = result.data.form;\n  form.setServerState(state.data, state.errors as FormErrors);\n  return true;\n}\n"],"mappings":";AA0BA,MAAM,oBAAoB,SACxB,OAAO,SAAS,YAChB,SAAS,QACT,UAAU,QACV,QAAS,KAA4B,IAAI;;;;;;;;;AAU3C,SAAgB,kBAEd,MACA,QACS;CACT,IAAI,OAAO,SAAS,aAAa,CAAC,iBAAiB,OAAO,IAAI,GAAG,OAAO;CACxE,MAAM,QAAQ,OAAO,KAAK;CAC1B,KAAK,eAAe,MAAM,MAAM,MAAM,MAAoB;CAC1D,OAAO;AACT"}

package/dist/Tainted.d.ts

@@ -2,11 +2,11 @@ import { Issues } from "@thomasfosterau/effect-forms";
 //#region src/Tainted.d.ts
 type FormPath = Issues.FormPath;
 /** A nested tree mirroring the form data, `true` where a leaf has changed. */
-interface TaintedFields {
+export interface TaintedFields {
   readonly [key: string]: boolean | TaintedFields | undefined;
 }
 /** Structural deep equality for plain JSON-ish values. */
-declare function deepEqual(a: unknown, b: unknown): boolean;
+export declare function deepEqual(a: unknown, b: unknown): boolean;
 /**
  * Compare `current` against `original`, returning the nested tainted tree.
  * A changed scalar leaf is `true`; an unchanged leaf is omitted; nested objects
@@ -14,11 +14,11 @@ declare function deepEqual(a: unknown, b: unknown): boolean;
  * row taints only that index — `taintedAt(["items", 2, "name"])` stays precise.
  * Keys present in either side are considered.
  */
-declare function computeTainted(original: unknown, current: unknown): TaintedFields;
+export declare function computeTainted(original: unknown, current: unknown): TaintedFields;
 /** Whether anything in the tree is tainted. */
-declare function isAnyTainted(tainted: TaintedFields): boolean;
+export declare function isAnyTainted(tainted: TaintedFields): boolean;
 /** Whether the field at `path` (or anything beneath it) is tainted. */
-declare function isTaintedAt(tainted: TaintedFields, path: FormPath): boolean;
+export declare function isTaintedAt(tainted: TaintedFields, path: FormPath): boolean;
 /**
  * Flatten a {@link TaintedFields} tree into the list of leaf {@link FormPath}s
  * that actually changed, in depth-first order — the per-field-changed events
@@ -26,7 +26,6 @@ declare function isTaintedAt(tainted: TaintedFields, path: FormPath): boolean;
  * server error at exactly the field that moved (as opposed to `isAnyTainted`,
  * which only says *something* changed).
  */
-declare function taintedLeafPaths(tainted: TaintedFields): FormPath[];
+export declare function taintedLeafPaths(tainted: TaintedFields): FormPath[];
 //#endregion
-export { TaintedFields, computeTainted, deepEqual, isAnyTainted, isTaintedAt, taintedLeafPaths };
 //# sourceMappingURL=Tainted.d.ts.map

package/dist/Tainted.js.map

@@ -1 +1 @@
-{"version":3,"file":"Tainted.js","names":[],"sources":["../src/Tainted.ts"],"sourcesContent":["/**\n * @copyright Thomas Foster\n *\n * Tainted-field tracking — which fields the user has changed since the form\n * was seeded.\n *\n * A `tainted` store lets a UI show \"unsaved changes\",\n * guard navigation, or submit only what changed. This is the pure half: a deep\n * diff of the current data against the original snapshot producing a nested\n * boolean tree mirroring the data's shape. The reactive store\n * (`superForm.svelte.ts`) re-derives it as the data changes.\n *\n * @module effect-forms-svelte/Tainted\n */\n\nimport type { Issues } from \"@thomasfosterau/effect-forms\";\n\ntype FormPath = Issues.FormPath;\n\n/** A nested tree mirroring the form data, `true` where a leaf has changed. */\nexport interface TaintedFields {\n  readonly [key: string]: boolean | TaintedFields | undefined;\n}\n\nconst isObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null;\n\n/** Structural deep equality for plain JSON-ish values. */\nexport function deepEqual(a: unknown, b: unknown): boolean {\n  if (a === b) return true;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every((item, i) => deepEqual(item, b[i]));\n  }\n  if (isObject(a) && isObject(b)) {\n    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);\n    for (const key of keys) {\n      if (!deepEqual(a[key], b[key])) return false;\n    }\n    return true;\n  }\n  return false;\n}\n\n/** Whether two containers are the same kind (both arrays, or both plain objects). */\nconst sameKind = (a: unknown, b: unknown): boolean => Array.isArray(a) === Array.isArray(b);\n\n/**\n * Compare `current` against `original`, returning the nested tainted tree.\n * A changed scalar leaf is `true`; an unchanged leaf is omitted; nested objects\n * **and arrays** recurse (array elements keyed by index), so a single changed\n * row taints only that index — `taintedAt([\"items\", 2, \"name\"])` stays precise.\n * Keys present in either side are considered.\n */\nexport function computeTainted(original: unknown, current: unknown): TaintedFields {\n  if (!isObject(original) || !isObject(current) || !sameKind(original, current)) return {};\n\n  const out: Record<string, boolean | TaintedFields> = {};\n  const keys = new Set([...Object.keys(original), ...Object.keys(current)]);\n  for (const key of keys) {\n    const before = original[key];\n    const after = current[key];\n    if (isObject(before) && isObject(after) && sameKind(before, after)) {\n      const nested = computeTainted(before, after);\n      if (Object.keys(nested).length > 0) out[key] = nested;\n    } else if (!deepEqual(before, after)) {\n      out[key] = true;\n    }\n  }\n  return out;\n}\n\n/** Whether anything in the tree is tainted. */\nexport function isAnyTainted(tainted: TaintedFields): boolean {\n  for (const key of Object.keys(tainted)) {\n    const value = tainted[key];\n    if (value === true) return true;\n    if (isObject(value) && isAnyTainted(value)) return true;\n  }\n  return false;\n}\n\n/** Whether the field at `path` (or anything beneath it) is tainted. */\nexport function isTaintedAt(tainted: TaintedFields, path: FormPath): boolean {\n  let node: boolean | TaintedFields | undefined = tainted;\n  for (const segment of path) {\n    if (node === undefined || typeof node === \"boolean\") return node === true;\n    node = node[String(segment)];\n  }\n  if (node === undefined) return false;\n  if (typeof node === \"boolean\") return node;\n  return isAnyTainted(node);\n}\n\n/**\n * Flatten a {@link TaintedFields} tree into the list of leaf {@link FormPath}s\n * that actually changed, in depth-first order — the per-field-changed events\n * a reactive store needs to run per-field validators / clear a superseded\n * server error at exactly the field that moved (as opposed to `isAnyTainted`,\n * which only says *something* changed).\n */\nexport function taintedLeafPaths(tainted: TaintedFields): FormPath[] {\n  const out: FormPath[] = [];\n\n  const walk = (node: TaintedFields, path: Array<string | number>): void => {\n    for (const key of Object.keys(node)) {\n      const value = node[key];\n      if (value === undefined) continue;\n      const segment: string | number = /^\\d+$/.test(key) ? Number(key) : key;\n      if (value === true) out.push([...path, segment]);\n      else if (typeof value === \"object\") walk(value, [...path, segment]);\n    }\n  };\n\n  walk(tainted, []);\n  return out;\n}\n"],"mappings":";AAwBA,MAAM,YAAY,UAChB,OAAO,UAAU,YAAY,UAAU;;AAGzC,SAAgB,UAAU,GAAY,GAAqB;CACzD,IAAI,MAAM,GAAG,OAAO;CACpB,IAAI,MAAM,QAAQ,CAAC,KAAK,MAAM,QAAQ,CAAC,GACrC,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,MAAM,MAAM,UAAU,MAAM,EAAE,EAAE,CAAC;CAE5E,IAAI,SAAS,CAAC,KAAK,SAAS,CAAC,GAAG;EAC9B,MAAM,uBAAO,IAAI,IAAI,CAAC,GAAG,OAAO,KAAK,CAAC,GAAG,GAAG,OAAO,KAAK,CAAC,CAAC,CAAC;EAC3D,KAAK,MAAM,OAAO,MAChB,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,GAAG,OAAO;EAEzC,OAAO;CACT;CACA,OAAO;AACT;;AAGA,MAAM,YAAY,GAAY,MAAwB,MAAM,QAAQ,CAAC,MAAM,MAAM,QAAQ,CAAC;;;;;;;;AAS1F,SAAgB,eAAe,UAAmB,SAAiC;CACjF,IAAI,CAAC,SAAS,QAAQ,KAAK,CAAC,SAAS,OAAO,KAAK,CAAC,SAAS,UAAU,OAAO,GAAG,OAAO,CAAC;CAEvF,MAAM,MAA+C,CAAC;CACtD,MAAM,uBAAO,IAAI,IAAI,CAAC,GAAG,OAAO,KAAK,QAAQ,GAAG,GAAG,OAAO,KAAK,OAAO,CAAC,CAAC;CACxE,KAAK,MAAM,OAAO,MAAM;EACtB,MAAM,SAAS,SAAS;EACxB,MAAM,QAAQ,QAAQ;EACtB,IAAI,SAAS,MAAM,KAAK,SAAS,KAAK,KAAK,SAAS,QAAQ,KAAK,GAAG;GAClE,MAAM,SAAS,eAAe,QAAQ,KAAK;GAC3C,IAAI,OAAO,KAAK,MAAM,CAAC,CAAC,SAAS,GAAG,IAAI,OAAO;EACjD,OAAO,IAAI,CAAC,UAAU,QAAQ,KAAK,GACjC,IAAI,OAAO;CAEf;CACA,OAAO;AACT;;AAGA,SAAgB,aAAa,SAAiC;CAC5D,KAAK,MAAM,OAAO,OAAO,KAAK,OAAO,GAAG;EACtC,MAAM,QAAQ,QAAQ;EACtB,IAAI,UAAU,MAAM,OAAO;EAC3B,IAAI,SAAS,KAAK,KAAK,aAAa,KAAK,GAAG,OAAO;CACrD;CACA,OAAO;AACT;;AAGA,SAAgB,YAAY,SAAwB,MAAyB;CAC3E,IAAI,OAA4C;CAChD,KAAK,MAAM,WAAW,MAAM;EAC1B,IAAI,SAAS,KAAA,KAAa,OAAO,SAAS,WAAW,OAAO,SAAS;EACrE,OAAO,KAAK,OAAO,OAAO;CAC5B;CACA,IAAI,SAAS,KAAA,GAAW,OAAO;CAC/B,IAAI,OAAO,SAAS,WAAW,OAAO;CACtC,OAAO,aAAa,IAAI;AAC1B;;;;;;;;AASA,SAAgB,iBAAiB,SAAoC;CACnE,MAAM,MAAkB,CAAC;CAEzB,MAAM,QAAQ,MAAqB,SAAuC;EACxE,KAAK,MAAM,OAAO,OAAO,KAAK,IAAI,GAAG;GACnC,MAAM,QAAQ,KAAK;GACnB,IAAI,UAAU,KAAA,GAAW;GACzB,MAAM,UAA2B,QAAQ,KAAK,GAAG,IAAI,OAAO,GAAG,IAAI;GACnE,IAAI,UAAU,MAAM,IAAI,KAAK,CAAC,GAAG,MAAM,OAAO,CAAC;QAC1C,IAAI,OAAO,UAAU,UAAU,KAAK,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC;EACpE;CACF;CAEA,KAAK,SAAS,CAAC,CAAC;CAChB,OAAO;AACT"}
+{"version":3,"file":"Tainted.js","names":[],"sources":["../src/Tainted.ts"],"sourcesContent":["/**\n * Tainted-field tracking — which fields the user has changed since the form\n * was seeded.\n *\n * A `tainted` store lets a UI show \"unsaved changes\",\n * guard navigation, or submit only what changed. This is the pure half: a deep\n * diff of the current data against the original snapshot producing a nested\n * boolean tree mirroring the data's shape. The reactive store\n * (`superForm.svelte.ts`) re-derives it as the data changes.\n *\n * @copyright Thomas Foster\n * @module effect-forms-svelte/Tainted\n */\n\nimport type { Issues } from \"@thomasfosterau/effect-forms\";\n\ntype FormPath = Issues.FormPath;\n\n/** A nested tree mirroring the form data, `true` where a leaf has changed. */\nexport interface TaintedFields {\n  readonly [key: string]: boolean | TaintedFields | undefined;\n}\n\nconst isObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null;\n\n/** Structural deep equality for plain JSON-ish values. */\nexport function deepEqual(a: unknown, b: unknown): boolean {\n  if (a === b) return true;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every((item, i) => deepEqual(item, b[i]));\n  }\n  if (isObject(a) && isObject(b)) {\n    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);\n    for (const key of keys) {\n      if (!deepEqual(a[key], b[key])) return false;\n    }\n    return true;\n  }\n  return false;\n}\n\n/** Whether two containers are the same kind (both arrays, or both plain objects). */\nconst sameKind = (a: unknown, b: unknown): boolean => Array.isArray(a) === Array.isArray(b);\n\n/**\n * Compare `current` against `original`, returning the nested tainted tree.\n * A changed scalar leaf is `true`; an unchanged leaf is omitted; nested objects\n * **and arrays** recurse (array elements keyed by index), so a single changed\n * row taints only that index — `taintedAt([\"items\", 2, \"name\"])` stays precise.\n * Keys present in either side are considered.\n */\nexport function computeTainted(original: unknown, current: unknown): TaintedFields {\n  if (!isObject(original) || !isObject(current) || !sameKind(original, current)) return {};\n\n  const out: Record<string, boolean | TaintedFields> = {};\n  const keys = new Set([...Object.keys(original), ...Object.keys(current)]);\n  for (const key of keys) {\n    const before = original[key];\n    const after = current[key];\n    if (isObject(before) && isObject(after) && sameKind(before, after)) {\n      const nested = computeTainted(before, after);\n      if (Object.keys(nested).length > 0) out[key] = nested;\n    } else if (!deepEqual(before, after)) {\n      out[key] = true;\n    }\n  }\n  return out;\n}\n\n/** Whether anything in the tree is tainted. */\nexport function isAnyTainted(tainted: TaintedFields): boolean {\n  for (const key of Object.keys(tainted)) {\n    const value = tainted[key];\n    if (value === true) return true;\n    if (isObject(value) && isAnyTainted(value)) return true;\n  }\n  return false;\n}\n\n/** Whether the field at `path` (or anything beneath it) is tainted. */\nexport function isTaintedAt(tainted: TaintedFields, path: FormPath): boolean {\n  let node: boolean | TaintedFields | undefined = tainted;\n  for (const segment of path) {\n    if (node === undefined || typeof node === \"boolean\") return node === true;\n    node = node[String(segment)];\n  }\n  if (node === undefined) return false;\n  if (typeof node === \"boolean\") return node;\n  return isAnyTainted(node);\n}\n\n/**\n * Flatten a {@link TaintedFields} tree into the list of leaf {@link FormPath}s\n * that actually changed, in depth-first order — the per-field-changed events\n * a reactive store needs to run per-field validators / clear a superseded\n * server error at exactly the field that moved (as opposed to `isAnyTainted`,\n * which only says *something* changed).\n */\nexport function taintedLeafPaths(tainted: TaintedFields): FormPath[] {\n  const out: FormPath[] = [];\n\n  const walk = (node: TaintedFields, path: Array<string | number>): void => {\n    for (const key of Object.keys(node)) {\n      const value = node[key];\n      if (value === undefined) continue;\n      const segment: string | number = /^\\d+$/.test(key) ? Number(key) : key;\n      if (value === true) out.push([...path, segment]);\n      else if (typeof value === \"object\") walk(value, [...path, segment]);\n    }\n  };\n\n  walk(tainted, []);\n  return out;\n}\n"],"mappings":";AAuBA,MAAM,YAAY,UAChB,OAAO,UAAU,YAAY,UAAU;;AAGzC,SAAgB,UAAU,GAAY,GAAqB;CACzD,IAAI,MAAM,GAAG,OAAO;CACpB,IAAI,MAAM,QAAQ,CAAC,KAAK,MAAM,QAAQ,CAAC,GACrC,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,MAAM,MAAM,UAAU,MAAM,EAAE,EAAE,CAAC;CAE5E,IAAI,SAAS,CAAC,KAAK,SAAS,CAAC,GAAG;EAC9B,MAAM,uBAAO,IAAI,IAAI,CAAC,GAAG,OAAO,KAAK,CAAC,GAAG,GAAG,OAAO,KAAK,CAAC,CAAC,CAAC;EAC3D,KAAK,MAAM,OAAO,MAChB,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,GAAG,OAAO;EAEzC,OAAO;CACT;CACA,OAAO;AACT;;AAGA,MAAM,YAAY,GAAY,MAAwB,MAAM,QAAQ,CAAC,MAAM,MAAM,QAAQ,CAAC;;;;;;;;AAS1F,SAAgB,eAAe,UAAmB,SAAiC;CACjF,IAAI,CAAC,SAAS,QAAQ,KAAK,CAAC,SAAS,OAAO,KAAK,CAAC,SAAS,UAAU,OAAO,GAAG,OAAO,CAAC;CAEvF,MAAM,MAA+C,CAAC;CACtD,MAAM,uBAAO,IAAI,IAAI,CAAC,GAAG,OAAO,KAAK,QAAQ,GAAG,GAAG,OAAO,KAAK,OAAO,CAAC,CAAC;CACxE,KAAK,MAAM,OAAO,MAAM;EACtB,MAAM,SAAS,SAAS;EACxB,MAAM,QAAQ,QAAQ;EACtB,IAAI,SAAS,MAAM,KAAK,SAAS,KAAK,KAAK,SAAS,QAAQ,KAAK,GAAG;GAClE,MAAM,SAAS,eAAe,QAAQ,KAAK;GAC3C,IAAI,OAAO,KAAK,MAAM,CAAC,CAAC,SAAS,GAAG,IAAI,OAAO;EACjD,OAAO,IAAI,CAAC,UAAU,QAAQ,KAAK,GACjC,IAAI,OAAO;CAEf;CACA,OAAO;AACT;;AAGA,SAAgB,aAAa,SAAiC;CAC5D,KAAK,MAAM,OAAO,OAAO,KAAK,OAAO,GAAG;EACtC,MAAM,QAAQ,QAAQ;EACtB,IAAI,UAAU,MAAM,OAAO;EAC3B,IAAI,SAAS,KAAK,KAAK,aAAa,KAAK,GAAG,OAAO;CACrD;CACA,OAAO;AACT;;AAGA,SAAgB,YAAY,SAAwB,MAAyB;CAC3E,IAAI,OAA4C;CAChD,KAAK,MAAM,WAAW,MAAM;EAC1B,IAAI,SAAS,KAAA,KAAa,OAAO,SAAS,WAAW,OAAO,SAAS;EACrE,OAAO,KAAK,OAAO,OAAO;CAC5B;CACA,IAAI,SAAS,KAAA,GAAW,OAAO;CAC/B,IAAI,OAAO,SAAS,WAAW,OAAO;CACtC,OAAO,aAAa,IAAI;AAC1B;;;;;;;;AASA,SAAgB,iBAAiB,SAAoC;CACnE,MAAM,MAAkB,CAAC;CAEzB,MAAM,QAAQ,MAAqB,SAAuC;EACxE,KAAK,MAAM,OAAO,OAAO,KAAK,IAAI,GAAG;GACnC,MAAM,QAAQ,KAAK;GACnB,IAAI,UAAU,KAAA,GAAW;GACzB,MAAM,UAA2B,QAAQ,KAAK,GAAG,IAAI,OAAO,GAAG,IAAI;GACnE,IAAI,UAAU,MAAM,IAAI,KAAK,CAAC,GAAG,MAAM,OAAO,CAAC;QAC1C,IAAI,OAAO,UAAU,UAAU,KAAK,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC;EACpE;CACF;CAEA,KAAK,SAAS,CAAC,CAAC;CAChB,OAAO;AACT"}

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/kit/ActionRedirect.d.ts

@@ -0,0 +1,22 @@
+import * as Option from "effect/Option";
+//#region src/kit/ActionRedirect.d.ts
+/**
+ * A user-fixable failure's message; `None` takes the hard-error path.
+ *
+ * - a `JsonapiError` / `ErrorResponse`-tagged cause at 400 / 409 / 422 → its
+ *   first error object's `detail`, else `title`, else `fallback` (an
+ *   `ErrorResponse` with no document → its own message);
+ * - an `HttpError`-tagged 400 → its message (or `fallback`);
+ * - anything else → `None`.
+ *
+ * `Some("")` is a deliberate *present* answer: an error object carrying a
+ * blank `detail` redirects with an empty parameter rather than escalating.
+ */
+export declare const userFixableMessage: (cause: unknown, fallback: string) => Option.Option<string>;
+/**
+ * Append the failure's query parameters to a same-origin return target,
+ * answering the path and query only (never an origin).
+ */
+export declare const withFailureParams: (target: string, params: Readonly<Record<string, string>>) => string;
+//#endregion
+//# sourceMappingURL=ActionRedirect.d.ts.map

package/dist/kit/ActionRedirect.js

@@ -0,0 +1,56 @@
+import { detailOf, jsonapiFailure } from "./CommandFailure.js";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+//#region src/kit/ActionRedirect.ts
+/**
+* Failure routing for **action-only** routes: a route with no page of its
+* own (a restore, a confirm) always answers a submission with a redirect, so
+* a *user-fixable* command failure rides back to the submitting page as
+* query parameters instead of a `fail()` (which would try to render the
+* action route's nonexistent page for a no-JS submitter). Everything else —
+* auth denials, infrastructure faults — stays a hard error at the caller.
+*
+* @copyright Thomas Foster
+* @module effect-forms-svelte/kit/ActionRedirect
+*/
+/** The statuses whose failure the submitter can act on (the form layer's set). */
+const USER_FIXABLE_STATUSES = /* @__PURE__ */ new Set([
+	400,
+	409,
+	422
+]);
+/**
+* A user-fixable failure's message; `None` takes the hard-error path.
+*
+* - a `JsonapiError` / `ErrorResponse`-tagged cause at 400 / 409 / 422 → its
+*   first error object's `detail`, else `title`, else `fallback` (an
+*   `ErrorResponse` with no document → its own message);
+* - an `HttpError`-tagged 400 → its message (or `fallback`);
+* - anything else → `None`.
+*
+* `Some("")` is a deliberate *present* answer: an error object carrying a
+* blank `detail` redirects with an empty parameter rather than escalating.
+*/
+const userFixableMessage = (cause, fallback) => {
+	if (!Predicate.isObjectOrArray(cause)) return Option.none();
+	const tagged = cause;
+	if (tagged._tag === "HttpError") {
+		if (tagged.status !== 400) return Option.none();
+		return Option.some(Predicate.isString(tagged.message) ? tagged.message : fallback);
+	}
+	if (tagged._tag !== "JsonapiError" && tagged._tag !== "ErrorResponse") return Option.none();
+	return jsonapiFailure(cause).pipe(Option.filter((failure) => USER_FIXABLE_STATUSES.has(failure.status)), Option.map((failure) => failure._tag === "Routed" ? detailOf(failure.errors[0], fallback) : failure.message));
+};
+/**
+* Append the failure's query parameters to a same-origin return target,
+* answering the path and query only (never an origin).
+*/
+const withFailureParams = (target, params) => {
+	const url = new URL(target, "http://localhost");
+	for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);
+	return url.pathname + url.search;
+};
+//#endregion
+export { userFixableMessage, withFailureParams };
+
+//# sourceMappingURL=ActionRedirect.js.map

package/dist/kit/ActionRedirect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActionRedirect.js","names":[],"sources":["../../src/kit/ActionRedirect.ts"],"sourcesContent":["/**\n * Failure routing for **action-only** routes: a route with no page of its\n * own (a restore, a confirm) always answers a submission with a redirect, so\n * a *user-fixable* command failure rides back to the submitting page as\n * query parameters instead of a `fail()` (which would try to render the\n * action route's nonexistent page for a no-JS submitter). Everything else —\n * auth denials, infrastructure faults — stays a hard error at the caller.\n *\n * @copyright Thomas Foster\n * @module effect-forms-svelte/kit/ActionRedirect\n */\n\nimport * as Option from \"effect/Option\";\nimport * as Predicate from \"effect/Predicate\";\nimport { detailOf, jsonapiFailure } from \"./CommandFailure.ts\";\n\n/** The statuses whose failure the submitter can act on (the form layer's set). */\nconst USER_FIXABLE_STATUSES: ReadonlySet<number> = new Set([400, 409, 422]);\n\ninterface TaggedLike {\n  readonly _tag?: unknown;\n  readonly status?: unknown;\n  readonly message?: unknown;\n}\n\n/**\n * A user-fixable failure's message; `None` takes the hard-error path.\n *\n * - a `JsonapiError` / `ErrorResponse`-tagged cause at 400 / 409 / 422 → its\n *   first error object's `detail`, else `title`, else `fallback` (an\n *   `ErrorResponse` with no document → its own message);\n * - an `HttpError`-tagged 400 → its message (or `fallback`);\n * - anything else → `None`.\n *\n * `Some(\"\")` is a deliberate *present* answer: an error object carrying a\n * blank `detail` redirects with an empty parameter rather than escalating.\n */\nexport const userFixableMessage = (cause: unknown, fallback: string): Option.Option<string> => {\n  if (!Predicate.isObjectOrArray(cause)) return Option.none();\n  const tagged = cause as TaggedLike;\n  if (tagged._tag === \"HttpError\") {\n    if (tagged.status !== 400) return Option.none();\n    return Option.some(Predicate.isString(tagged.message) ? tagged.message : fallback);\n  }\n  if (tagged._tag !== \"JsonapiError\" && tagged._tag !== \"ErrorResponse\") return Option.none();\n  return jsonapiFailure(cause).pipe(\n    Option.filter((failure) => USER_FIXABLE_STATUSES.has(failure.status)),\n    Option.map((failure) =>\n      failure._tag === \"Routed\" ? detailOf(failure.errors[0], fallback) : failure.message,\n    ),\n  );\n};\n\n/**\n * Append the failure's query parameters to a same-origin return target,\n * answering the path and query only (never an origin).\n */\nexport const withFailureParams = (\n  target: string,\n  params: Readonly<Record<string, string>>,\n): string => {\n  const url = new URL(target, \"http://localhost\");\n  for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);\n  return url.pathname + url.search;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,MAAM,wCAA6C,IAAI,IAAI;CAAC;CAAK;CAAK;AAAG,CAAC;;;;;;;;;;;;;AAoB1E,MAAa,sBAAsB,OAAgB,aAA4C;CAC7F,IAAI,CAAC,UAAU,gBAAgB,KAAK,GAAG,OAAO,OAAO,KAAK;CAC1D,MAAM,SAAS;CACf,IAAI,OAAO,SAAS,aAAa;EAC/B,IAAI,OAAO,WAAW,KAAK,OAAO,OAAO,KAAK;EAC9C,OAAO,OAAO,KAAK,UAAU,SAAS,OAAO,OAAO,IAAI,OAAO,UAAU,QAAQ;CACnF;CACA,IAAI,OAAO,SAAS,kBAAkB,OAAO,SAAS,iBAAiB,OAAO,OAAO,KAAK;CAC1F,OAAO,eAAe,KAAK,CAAC,CAAC,KAC3B,OAAO,QAAQ,YAAY,sBAAsB,IAAI,QAAQ,MAAM,CAAC,GACpE,OAAO,KAAK,YACV,QAAQ,SAAS,WAAW,SAAS,QAAQ,OAAO,IAAI,QAAQ,IAAI,QAAQ,OAC9E,CACF;AACF;;;;;AAMA,MAAa,qBACX,QACA,WACW;CACX,MAAM,MAAM,IAAI,IAAI,QAAQ,kBAAkB;CAC9C,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,GAAG,IAAI,aAAa,IAAI,KAAK,KAAK;CAClF,OAAO,IAAI,WAAW,IAAI;AAC5B"}

package/dist/kit/CommandFailure.d.ts

@@ -0,0 +1,52 @@
+import * as Option from "effect/Option";
+import { Document } from "@thomasfosterau/effect-jsonapi";
+declare namespace CommandFailure_d_exports {
+  export { Classify, CommandFailure, DEFAULT_MESSAGE, ErrorObject, MessageFailure, RoutedFailure, detailOf, jsonapiFailure, message, routed };
+}
+/** One JSON:API error object: `@thomasfosterau/effect-jsonapi`'s `Document.ErrorObject`. */
+export type ErrorObject = typeof Document.ErrorObject.Type;
+/** A failure carrying JSON:API error objects, each routed to a field (or the root) by its pointer. */
+export interface RoutedFailure {
+  readonly _tag: "Routed";
+  readonly status: number;
+  readonly errors: ReadonlyArray<ErrorObject>;
+}
+/** A failure with no error objects to route: one whole-form message. */
+export interface MessageFailure {
+  readonly _tag: "Message";
+  readonly status: number;
+  readonly message: string;
+}
+/**
+ * What a form action needs to know about a recognised command failure. An
+ * unrecognised failure is not a `CommandFailure` at all: the classifier
+ * answers `None` and the action treats it as unexpected.
+ */
+export type CommandFailure = RoutedFailure | MessageFailure;
+/** Construct a {@link RoutedFailure}. */
+export declare const routed: (status: number, errors: ReadonlyArray<ErrorObject>) => CommandFailure;
+/** Construct a {@link MessageFailure}. */
+export declare const message: (status: number, message: string) => CommandFailure;
+/** A classifier: `Some` for a failure the form can show, `None` for an unexpected one. */
+export type Classify = (cause: unknown) => Option.Option<CommandFailure>;
+/** The fallback message for an error object with neither `detail` nor `title`. */
+export declare const DEFAULT_MESSAGE = "Request could not be completed";
+/** An error object's human message: its `detail`, else its `title`, else `fallback`. */
+export declare const detailOf: (error: ErrorObject | undefined, fallback?: string) => string;
+/**
+ * The default classifier:
+ *
+ * - a `JsonapiError`-tagged cause (`{ status, errors }`) → its error objects,
+ *   at its own status;
+ * - an `ErrorResponse`-tagged cause (effect-jsonapi's client-side decoded
+ *   error) → its document's error objects, or its message when the response
+ *   carried no document;
+ * - an `Error` carrying a numeric `status` (a transport's status error, e.g.
+ *   a 413 oversize upload the transport did not map to a document) → its
+ *   message, at its own status;
+ * - anything else → `None` (unexpected).
+ */
+export declare const jsonapiFailure: Classify;
+//#endregion
+export { CommandFailure_d_exports };
+//# sourceMappingURL=CommandFailure.d.ts.map

package/dist/kit/CommandFailure.js

@@ -0,0 +1,82 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+//#region src/kit/CommandFailure.ts
+/**
+* Classifying what a form action's command failed with.
+*
+* A command (an API client call, an Effect program) fails with whatever its
+* transport raises. The form layer only needs to know two things about it:
+* which JSON:API error objects it carried (so each can be routed onto a
+* field by its `source.pointer`), or, failing that, a status and a single
+* message for the whole form. {@link CommandFailure} is that view, and
+* {@link jsonapiFailure} is the default classifier.
+*
+* The error-object shape is `@thomasfosterau/effect-jsonapi`'s
+* `Document.ErrorObject` — an optional peer imported for its type only, so
+* nothing here depends on it at runtime and no application type leaks in.
+* Causes are recognised structurally by their `_tag`, so an application's
+* own `JsonapiError` with the same shape is recognised too.
+*
+* @copyright Thomas Foster
+* @module effect-forms-svelte/kit/CommandFailure
+*/
+var CommandFailure_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_MESSAGE: () => DEFAULT_MESSAGE,
+	detailOf: () => detailOf,
+	jsonapiFailure: () => jsonapiFailure,
+	message: () => message,
+	routed: () => routed
+});
+/** Construct a {@link RoutedFailure}. */
+const routed = (status, errors) => ({
+	_tag: "Routed",
+	status,
+	errors
+});
+/** Construct a {@link MessageFailure}. */
+const message = (status, message) => ({
+	_tag: "Message",
+	status,
+	message
+});
+/** The fallback message for an error object with neither `detail` nor `title`. */
+const DEFAULT_MESSAGE = "Request could not be completed";
+/** An error object's human message: its `detail`, else its `title`, else `fallback`. */
+const detailOf = (error, fallback = DEFAULT_MESSAGE) => error?.detail ?? error?.title ?? fallback;
+const isStatus = (u) => Predicate.isNumber(u) && Number.isInteger(u);
+const fromJsonapiError = (cause) => isStatus(cause.status) && Array.isArray(cause.errors) ? Option.some(routed(cause.status, cause.errors)) : Option.none();
+const fromErrorResponse = (cause) => {
+	if (!isStatus(cause.status)) return Option.none();
+	const errors = Option.isOption(cause.document) ? Option.flatMap(cause.document, (document) => Predicate.hasProperty(document, "errors") && Array.isArray(document.errors) && document.errors.length > 0 ? Option.some(document.errors) : Option.none()) : Option.none();
+	const status = cause.status;
+	return Option.some(Option.match(errors, {
+		onSome: (errors) => routed(status, errors),
+		onNone: () => message(status, Predicate.isString(cause.message) ? cause.message : DEFAULT_MESSAGE)
+	}));
+};
+/**
+* The default classifier:
+*
+* - a `JsonapiError`-tagged cause (`{ status, errors }`) → its error objects,
+*   at its own status;
+* - an `ErrorResponse`-tagged cause (effect-jsonapi's client-side decoded
+*   error) → its document's error objects, or its message when the response
+*   carried no document;
+* - an `Error` carrying a numeric `status` (a transport's status error, e.g.
+*   a 413 oversize upload the transport did not map to a document) → its
+*   message, at its own status;
+* - anything else → `None` (unexpected).
+*/
+const jsonapiFailure = (cause) => {
+	if (!Predicate.isObjectOrArray(cause)) return Option.none();
+	const tagged = cause;
+	if (tagged._tag === "JsonapiError") return fromJsonapiError(tagged);
+	if (tagged._tag === "ErrorResponse") return fromErrorResponse(tagged);
+	if (Predicate.isError(cause) && isStatus(tagged.status)) return Option.some(message(tagged.status, cause.message));
+	return Option.none();
+};
+//#endregion
+export { CommandFailure_exports, DEFAULT_MESSAGE, detailOf, jsonapiFailure, message, routed };
+
+//# sourceMappingURL=CommandFailure.js.map

package/dist/kit/CommandFailure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommandFailure.js","names":[],"sources":["../../src/kit/CommandFailure.ts"],"sourcesContent":["/**\n * Classifying what a form action's command failed with.\n *\n * A command (an API client call, an Effect program) fails with whatever its\n * transport raises. The form layer only needs to know two things about it:\n * which JSON:API error objects it carried (so each can be routed onto a\n * field by its `source.pointer`), or, failing that, a status and a single\n * message for the whole form. {@link CommandFailure} is that view, and\n * {@link jsonapiFailure} is the default classifier.\n *\n * The error-object shape is `@thomasfosterau/effect-jsonapi`'s\n * `Document.ErrorObject` — an optional peer imported for its type only, so\n * nothing here depends on it at runtime and no application type leaks in.\n * Causes are recognised structurally by their `_tag`, so an application's\n * own `JsonapiError` with the same shape is recognised too.\n *\n * @copyright Thomas Foster\n * @module effect-forms-svelte/kit/CommandFailure\n */\n\nimport * as Option from \"effect/Option\";\nimport * as Predicate from \"effect/Predicate\";\nimport type { Document } from \"@thomasfosterau/effect-jsonapi\";\n\n/** One JSON:API error object: `@thomasfosterau/effect-jsonapi`'s `Document.ErrorObject`. */\nexport type ErrorObject = typeof Document.ErrorObject.Type;\n\n/** A failure carrying JSON:API error objects, each routed to a field (or the root) by its pointer. */\nexport interface RoutedFailure {\n  readonly _tag: \"Routed\";\n  readonly status: number;\n  readonly errors: ReadonlyArray<ErrorObject>;\n}\n\n/** A failure with no error objects to route: one whole-form message. */\nexport interface MessageFailure {\n  readonly _tag: \"Message\";\n  readonly status: number;\n  readonly message: string;\n}\n\n/**\n * What a form action needs to know about a recognised command failure. An\n * unrecognised failure is not a `CommandFailure` at all: the classifier\n * answers `None` and the action treats it as unexpected.\n */\nexport type CommandFailure = RoutedFailure | MessageFailure;\n\n/** Construct a {@link RoutedFailure}. */\nexport const routed = (status: number, errors: ReadonlyArray<ErrorObject>): CommandFailure => ({\n  _tag: \"Routed\",\n  status,\n  errors,\n});\n\n/** Construct a {@link MessageFailure}. */\nexport const message = (status: number, message: string): CommandFailure => ({\n  _tag: \"Message\",\n  status,\n  message,\n});\n\n/** A classifier: `Some` for a failure the form can show, `None` for an unexpected one. */\nexport type Classify = (cause: unknown) => Option.Option<CommandFailure>;\n\n/** The fallback message for an error object with neither `detail` nor `title`. */\nexport const DEFAULT_MESSAGE = \"Request could not be completed\";\n\n/** An error object's human message: its `detail`, else its `title`, else `fallback`. */\nexport const detailOf = (error: ErrorObject | undefined, fallback = DEFAULT_MESSAGE): string =>\n  error?.detail ?? error?.title ?? fallback;\n\ninterface TaggedLike {\n  readonly _tag?: unknown;\n  readonly status?: unknown;\n  readonly message?: unknown;\n  readonly errors?: unknown;\n  readonly document?: unknown;\n}\n\nconst isStatus = (u: unknown): u is number => Predicate.isNumber(u) && Number.isInteger(u);\n\n// `ServerErrors.JsonapiError` (effect-jsonapi) and the applications' own\n// `JsonapiError`: `{ _tag: \"JsonapiError\", status, errors }`.\nconst fromJsonapiError = (cause: TaggedLike): Option.Option<CommandFailure> =>\n  isStatus(cause.status) && Array.isArray(cause.errors)\n    ? Option.some(routed(cause.status, cause.errors as ReadonlyArray<ErrorObject>))\n    : Option.none();\n\n// `Client.ErrorResponse` (effect-jsonapi): `{ _tag: \"ErrorResponse\", status,\n// message, document: Option<ErrorDocument> }`. A decoded document routes its\n// error objects; a response with none is its message alone.\nconst fromErrorResponse = (cause: TaggedLike): Option.Option<CommandFailure> => {\n  if (!isStatus(cause.status)) return Option.none();\n  const errors = Option.isOption(cause.document)\n    ? Option.flatMap(cause.document as Option.Option<unknown>, (document) =>\n        Predicate.hasProperty(document, \"errors\") &&\n        Array.isArray(document.errors) &&\n        document.errors.length > 0\n          ? Option.some(document.errors as ReadonlyArray<ErrorObject>)\n          : Option.none(),\n      )\n    : Option.none<ReadonlyArray<ErrorObject>>();\n  const status = cause.status;\n  return Option.some(\n    Option.match(errors, {\n      onSome: (errors) => routed(status, errors),\n      onNone: () =>\n        message(status, Predicate.isString(cause.message) ? cause.message : DEFAULT_MESSAGE),\n    }),\n  );\n};\n\n/**\n * The default classifier:\n *\n * - a `JsonapiError`-tagged cause (`{ status, errors }`) → its error objects,\n *   at its own status;\n * - an `ErrorResponse`-tagged cause (effect-jsonapi's client-side decoded\n *   error) → its document's error objects, or its message when the response\n *   carried no document;\n * - an `Error` carrying a numeric `status` (a transport's status error, e.g.\n *   a 413 oversize upload the transport did not map to a document) → its\n *   message, at its own status;\n * - anything else → `None` (unexpected).\n */\nexport const jsonapiFailure: Classify = (cause) => {\n  if (!Predicate.isObjectOrArray(cause)) return Option.none();\n  const tagged = cause as TaggedLike;\n  if (tagged._tag === \"JsonapiError\") return fromJsonapiError(tagged);\n  if (tagged._tag === \"ErrorResponse\") return fromErrorResponse(tagged);\n  if (Predicate.isError(cause) && isStatus(tagged.status)) {\n    return Option.some(message(tagged.status, cause.message));\n  }\n  return Option.none();\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,MAAa,UAAU,QAAgB,YAAwD;CAC7F,MAAM;CACN;CACA;AACF;;AAGA,MAAa,WAAW,QAAgB,aAAqC;CAC3E,MAAM;CACN;CACA;AACF;;AAMA,MAAa,kBAAkB;;AAG/B,MAAa,YAAY,OAAgC,WAAW,oBAClE,OAAO,UAAU,OAAO,SAAS;AAUnC,MAAM,YAAY,MAA4B,UAAU,SAAS,CAAC,KAAK,OAAO,UAAU,CAAC;AAIzF,MAAM,oBAAoB,UACxB,SAAS,MAAM,MAAM,KAAK,MAAM,QAAQ,MAAM,MAAM,IAChD,OAAO,KAAK,OAAO,MAAM,QAAQ,MAAM,MAAoC,CAAC,IAC5E,OAAO,KAAK;AAKlB,MAAM,qBAAqB,UAAqD;CAC9E,IAAI,CAAC,SAAS,MAAM,MAAM,GAAG,OAAO,OAAO,KAAK;CAChD,MAAM,SAAS,OAAO,SAAS,MAAM,QAAQ,IACzC,OAAO,QAAQ,MAAM,WAAqC,aACxD,UAAU,YAAY,UAAU,QAAQ,KACxC,MAAM,QAAQ,SAAS,MAAM,KAC7B,SAAS,OAAO,SAAS,IACrB,OAAO,KAAK,SAAS,MAAoC,IACzD,OAAO,KAAK,CAClB,IACA,OAAO,KAAiC;CAC5C,MAAM,SAAS,MAAM;CACrB,OAAO,OAAO,KACZ,OAAO,MAAM,QAAQ;EACnB,SAAS,WAAW,OAAO,QAAQ,MAAM;EACzC,cACE,QAAQ,QAAQ,UAAU,SAAS,MAAM,OAAO,IAAI,MAAM,UAAU,eAAe;CACvF,CAAC,CACH;AACF;;;;;;;;;;;;;;AAeA,MAAa,kBAA4B,UAAU;CACjD,IAAI,CAAC,UAAU,gBAAgB,KAAK,GAAG,OAAO,OAAO,KAAK;CAC1D,MAAM,SAAS;CACf,IAAI,OAAO,SAAS,gBAAgB,OAAO,iBAAiB,MAAM;CAClE,IAAI,OAAO,SAAS,iBAAiB,OAAO,kBAAkB,MAAM;CACpE,IAAI,UAAU,QAAQ,KAAK,KAAK,SAAS,OAAO,MAAM,GACpD,OAAO,OAAO,KAAK,QAAQ,OAAO,QAAQ,MAAM,OAAO,CAAC;CAE1D,OAAO,OAAO,KAAK;AACrB"}

package/dist/kit/Enhance.d.ts

@@ -0,0 +1,30 @@
+import { FormStore } from "../FormStore.svelte.js";
+import { Attachment } from "svelte/attachments";
+//#region src/kit/Enhance.d.ts
+/** The spreadable `<form>` props: the POST method plus the enhance attachment under its symbol key. */
+export interface EnhancedFormProps {
+  readonly method: "post";
+  readonly [attachmentKey: symbol]: Attachment<HTMLFormElement>;
+}
+/**
+ * Spreadable `<form>` props wiring SvelteKit's native `enhance` to the store:
+ * `method="post"` plus a Svelte attachment that flips `submitting`, applies a
+ * validation failure back to the store, and otherwise defers to SvelteKit's
+ * default `update` (with `reset: false`) for success / redirect / error, which
+ * applies the result exactly once.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { createForm } from "@thomasfosterau/effect-forms-svelte";
+ *   import { enhanceForm } from "@thomasfosterau/effect-forms-svelte/kit";
+ *   let { data } = $props();
+ *   const form = createForm(data.form);
+ * </script>
+ *
+ * <form {...enhanceForm(form)}>…</form>
+ * ```
+ */
+export declare function enhanceForm(form: FormStore<any, any, any>): EnhancedFormProps;
+//#endregion
+//# sourceMappingURL=Enhance.d.ts.map

package/dist/kit/Enhance.js

@@ -0,0 +1,57 @@
+import { applyActionResult } from "../SvelteKit.js";
+import { createAttachmentKey } from "svelte/attachments";
+import { enhance } from "$app/forms";
+//#region src/kit/Enhance.ts
+/**
+* SvelteKit `$app/forms` glue for the form store. {@link enhanceForm}
+* returns spreadable `<form>` props — `<form {...enhanceForm(form)}>` — that
+* post to the page's derived action ({@link formAction}) through SvelteKit's
+* native `enhance`.
+*
+* `$app/forms` is a SvelteKit virtual module: it resolves inside a SvelteKit
+* build (which compiles this package, as it does every `svelte`-condition
+* dependency), never from Node on its own. That is why this lives in the
+* `/kit` entry and nowhere the framework-neutral bindings can reach.
+*
+* @copyright Thomas Foster
+* @module effect-forms-svelte/kit/Enhance
+*/
+/**
+* Spreadable `<form>` props wiring SvelteKit's native `enhance` to the store:
+* `method="post"` plus a Svelte attachment that flips `submitting`, applies a
+* validation failure back to the store, and otherwise defers to SvelteKit's
+* default `update` (with `reset: false`) for success / redirect / error, which
+* applies the result exactly once.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { createForm } from "@thomasfosterau/effect-forms-svelte";
+*   import { enhanceForm } from "@thomasfosterau/effect-forms-svelte/kit";
+*   let { data } = $props();
+*   const form = createForm(data.form);
+* <\/script>
+*
+* <form {...enhanceForm(form)}>…</form>
+* ```
+*/
+function enhanceForm(form) {
+	return {
+		method: "post",
+		[createAttachmentKey()]: (node) => {
+			const enhanced = enhance(node, () => {
+				form.submitting = true;
+				return async ({ result, update }) => {
+					form.submitting = false;
+					if (applyActionResult(form, result)) return;
+					await update({ reset: false });
+				};
+			});
+			return () => enhanced.destroy();
+		}
+	};
+}
+//#endregion
+export { enhanceForm };
+
+//# sourceMappingURL=Enhance.js.map

package/dist/kit/Enhance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Enhance.js","names":[],"sources":["../../src/kit/Enhance.ts"],"sourcesContent":["/**\n * SvelteKit `$app/forms` glue for the form store. {@link enhanceForm}\n * returns spreadable `<form>` props — `<form {...enhanceForm(form)}>` — that\n * post to the page's derived action ({@link formAction}) through SvelteKit's\n * native `enhance`.\n *\n * `$app/forms` is a SvelteKit virtual module: it resolves inside a SvelteKit\n * build (which compiles this package, as it does every `svelte`-condition\n * dependency), never from Node on its own. That is why this lives in the\n * `/kit` entry and nowhere the framework-neutral bindings can reach.\n *\n * @copyright Thomas Foster\n * @module effect-forms-svelte/kit/Enhance\n */\n\n/// <reference types=\"@sveltejs/kit\" />\n\nimport { enhance } from \"$app/forms\";\nimport { type Attachment, createAttachmentKey } from \"svelte/attachments\";\nimport type { FormStore } from \"../FormStore.svelte.ts\";\nimport { applyActionResult } from \"../SvelteKit.ts\";\n\n/** The spreadable `<form>` props: the POST method plus the enhance attachment under its symbol key. */\nexport interface EnhancedFormProps {\n  readonly method: \"post\";\n  readonly [attachmentKey: symbol]: Attachment<HTMLFormElement>;\n}\n\n/**\n * Spreadable `<form>` props wiring SvelteKit's native `enhance` to the store:\n * `method=\"post\"` plus a Svelte attachment that flips `submitting`, applies a\n * validation failure back to the store, and otherwise defers to SvelteKit's\n * default `update` (with `reset: false`) for success / redirect / error, which\n * applies the result exactly once.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { createForm } from \"@thomasfosterau/effect-forms-svelte\";\n *   import { enhanceForm } from \"@thomasfosterau/effect-forms-svelte/kit\";\n *   let { data } = $props();\n *   const form = createForm(data.form);\n * </script>\n *\n * <form {...enhanceForm(form)}>…</form>\n * ```\n */\nexport function enhanceForm(\n  // oxlint-disable-next-line typescript/no-explicit-any -- accepts any concrete store\n  form: FormStore<any, any, any>,\n): EnhancedFormProps {\n  return {\n    method: \"post\",\n    [createAttachmentKey()]: (node: HTMLFormElement) => {\n      const enhanced = enhance(node, () => {\n        form.submitting = true;\n        return async ({ result, update }) => {\n          form.submitting = false;\n          if (applyActionResult(form, result)) return;\n          await update({ reset: false });\n        };\n      });\n      return () => enhanced.destroy();\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,YAEd,MACmB;CACnB,OAAO;EACL,QAAQ;GACP,oBAAoB,KAAK,SAA0B;GAClD,MAAM,WAAW,QAAQ,YAAY;IACnC,KAAK,aAAa;IAClB,OAAO,OAAO,EAAE,QAAQ,aAAa;KACnC,KAAK,aAAa;KAClB,IAAI,kBAAkB,MAAM,MAAM,GAAG;KACrC,MAAM,OAAO,EAAE,OAAO,MAAM,CAAC;IAC/B;GACF,CAAC;GACD,aAAa,SAAS,QAAQ;EAChC;CACF;AACF"}

package/dist/kit/FormAction.d.ts

@@ -0,0 +1,132 @@
+import { Classify } from "./CommandFailure.js";
+import { Form, Result, State } from "@thomasfosterau/effect-forms";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import { RequestEvent } from "@sveltejs/kit";
+//#region src/kit/FormAction.d.ts
+type FormState<A, Message = unknown> = State.FormState<A, Message>;
+type FormActionResult<A, Message = unknown> = Result.FormActionResult<A, Message>;
+type FormActionData<A = unknown, Message = unknown> = Result.FormActionData<A, Message>;
+/**
+ * A command: a Promise-returning function or one returning an `Effect` with
+ * no requirements (provide them first, e.g. through a `ManagedRuntime`).
+ */
+type Command$1<I, O> = (input: I) => Promise<O> | Effect.Effect<O, unknown>;
+/**
+ * Wrap a client-id create command so a 409 conflict on the caller's OWN
+ * submitted `id` resolves as success instead of a form error — the
+ * double-submit of a create whose id the client generated.
+ *
+ * On any 409 (a `JsonapiError` / `ErrorResponse`-tagged cause), re-fetches
+ * `input.id` via `fetchExisting` and returns that. This is deliberately
+ * unconditional on *why* the 409 fired: the re-fetch is the proof, not the
+ * status. A 409 from an unrelated precondition never left a row at
+ * `input.id`, so the re-fetch fails and the original conflict rethrows
+ * unchanged. An input with no `id`, or any other failure, rethrows as is.
+ *
+ * `input.id` is read structurally rather than through a constraint on
+ * `Input`: a constraint here would be used only contravariantly (as
+ * `create`'s parameter), which makes TypeScript infer `Input` from the
+ * constraint instead of from the command's own input type.
+ */
+export declare function idempotentCreate<Input, Output>(create: (input: Input) => Promise<Output>, fetchExisting: (id: string) => Promise<Output>): (input: Input) => Promise<Output>;
+/**
+ * Idempotent-retry wiring for a client-id create action: `clientId` gates the
+ * wrap to commands whose input actually carries a client-generated `id` (an
+ * entity form definition's own `clientId`, from `defineEntityForm`);
+ * `fetchExisting` re-fetches the submitted id (see {@link idempotentCreate}).
+ */
+export interface IdempotentCreateOptions<O> {
+  readonly clientId: boolean;
+  readonly fetchExisting: (id: string) => Promise<O> | Effect.Effect<O, unknown>;
+}
+/** Options for {@link runFormAction} and {@link formAction}. */
+export interface FormActionOptions<A, O> {
+  /** Retry a client-id create's own 409 as success (see {@link IdempotentCreateOptions}). */
+  readonly idempotent?: IdempotentCreateOptions<O> | undefined;
+  /**
+   * How a command failure is recognised. Defaults to
+   * {@link CommandFailure.jsonapiFailure}; compose with it to add an
+   * application's own failures.
+   */
+  readonly classify?: Classify | undefined;
+  /**
+   * Applied to every form state echoed back to the browser (an invalid
+   * submission, a routed command failure) — e.g. blanking password fields
+   * so a secret never rides a response body.
+   */
+  readonly redact?: ((state: FormState<A>) => FormState<A>) | undefined;
+  /**
+   * What happens to a command failure the classifier does not recognise:
+   * `"error"` (the default) answers an `Error` result at 500 carrying the
+   * cause's message; `"throw"` rethrows the cause, leaving it to SvelteKit's
+   * `handleError`.
+   */
+  readonly unrecognised?: "error" | "throw" | undefined;
+}
+/**
+ * Validate `request` against `form`, then:
+ *
+ * - invalid → a `Failure` carrying the form state (nested errors + posted
+ *   values), status 400, and the command never runs;
+ * - valid → run the command (wrapped in the idempotent retry when
+ *   `options.idempotent.clientId` is true); on success a `Redirect` (303) to
+ *   `locationFor(output, input)`;
+ * - a recognised command failure → a `Failure` at the failure's own status,
+ *   each JSON:API error routed onto its field (or the root);
+ * - an unrecognised one → an `Error` result at 500 (or a rethrow, per
+ *   `options.unrecognised`).
+ *
+ * Posted values survive every failure, so the form re-renders what was typed.
+ *
+ * `locationFor` returns the redirect target as-is: `runFormAction` does not
+ * check it. {@link formAction} hands it to SvelteKit's `redirect`, which
+ * accepts only a same-origin location (see there).
+ */
+export declare function runFormAction<S extends Schema.Top, O, Message = unknown>(form: Form.Form<S, Message>, request: Request, run: Command$1<S["Type"], O>, locationFor: (output: O, input: S["Type"]) => string, options?: FormActionOptions<S["Type"], O>): Promise<FormActionResult<S["Type"]>>;
+/**
+ * A command for {@link formAction}: like {@link Command}, and also handed the
+ * `RequestEvent` (for `locals`, `cookies`, `fetch`).
+ */
+export type ActionCommand<I, O> = (input: I, event: RequestEvent) => Promise<O> | Effect.Effect<O, unknown>;
+/**
+ * Derive a SvelteKit page form **action** from `form` plus its command. The
+ * handler validates the submission, runs the command on success, and maps
+ * the outcome onto SvelteKit's action protocol:
+ *
+ * - success → `redirect(303, locationFor(output, input))`;
+ * - an invalid submission or a recognised command failure →
+ *   `fail(status, { form })`, carrying the (redacted) state;
+ * - an unrecognised failure → `fail(500, { message })` (or a rethrow).
+ *
+ * Wire it into `export const actions`; the client `createForm` store applies
+ * the returned `form` via {@link enhanceForm} (or `applyActionResult`).
+ *
+ * `locationFor` must return a same-origin path, such as
+ * `/organisations/${id}`. SvelteKit 3's `redirect` rejects an external
+ * location unless it is passed `{ external }`, and `formAction` never passes
+ * it, so a `locationFor` that returns an absolute URL on another origin (or a
+ * protocol-relative `//host/...`) makes the action throw an `Error` instead of
+ * redirecting, after the command has already run. To send the user off-site,
+ * redirect to a same-origin route that performs the external redirect itself.
+ *
+ * @example
+ * ```ts
+ * // src/routes/organisations/create/+page.server.ts
+ * import { formAction } from "@thomasfosterau/effect-forms-svelte/kit";
+ * import { organisationForm } from "#lib/forms";
+ * import { api } from "#lib/server/api";
+ *
+ * export const actions = {
+ *   default: formAction(
+ *     organisationForm,
+ *     (input, { locals }) => api(locals).organisations.create(input),
+ *     (id) => `/organisations/${id}`,
+ *   ),
+ * };
+ * ```
+ */
+export declare function formAction<S extends Schema.Top, O, Message = unknown>(form: Form.Form<S, Message>, run: ActionCommand<S["Type"], O>, locationFor: (output: O, input: S["Type"]) => string, options?: FormActionOptions<S["Type"], O>): (event: RequestEvent) => Promise<FormActionData<S["Type"], unknown> | import("@sveltejs/kit").ActionFailure<FormActionData<S["Type"], unknown>>>;
+//#endregion
+export { Command$1 as Command };
+//# sourceMappingURL=FormAction.d.ts.map