@holo-js/adapter-sveltekit 0.1.4 → 0.1.5

package/dist/chunk-FZXR22V2.mjs

@@ -0,0 +1,49 @@
+// src/transport.ts
+function isHoloModelEntityLike(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.getRepository === "function" && typeof value.toAttributes === "function" && typeof value.toJSON === "function"
+  );
+}
+function isHoloModelCollectionLike(value) {
+  const candidate = value;
+  return Boolean(
+    Array.isArray(value) && typeof candidate.modelKeys === "function" && typeof candidate.toQuery === "function" && typeof candidate.toJSON === "function"
+  );
+}
+function serializeSvelteKitData(value) {
+  if (isHoloModelEntityLike(value) || isHoloModelCollectionLike(value)) {
+    return value.toJSON();
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => serializeSvelteKitData(item));
+  }
+  if (value instanceof Date || value === null || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [key, serializeSvelteKitData(entry)])
+  );
+}
+var holoSvelteKitTransport = {
+  HoloModel: {
+    encode(value) {
+      return isHoloModelEntityLike(value) ? value.toJSON() : false;
+    },
+    decode(value) {
+      return value;
+    }
+  },
+  HoloCollection: {
+    encode(value) {
+      return isHoloModelCollectionLike(value) ? value.toJSON() : false;
+    },
+    decode(value) {
+      return value;
+    }
+  }
+};
+
+export {
+  serializeSvelteKitData,
+  holoSvelteKitTransport
+};

package/dist/client.d.ts

@@ -1,7 +1,8 @@
-import { InferSchemaData } from '@holo-js/forms';
-import { useForm as useForm$1, UseFormOptions, UseFormResult } from '@holo-js/forms/client';
-export { ClientSubmitContext, ClientSubmitResult, FormFieldState, FormFieldTree, UseFormOptions, UseFormResult, ValidateOnMode } from '@holo-js/forms/client';
+import { FormSchema, InferFormData, ValidationErrorBag } from '@holo-js/forms';
+import { UseFormOptions, UseFormResult, InferFormFieldTree } from '@holo-js/forms/internal/client';
+export { ClientSubmitContext, ClientSubmitResult, FormFieldState, FormFieldTree, UseFormOptions, UseFormResult, ValidateOnMode } from '@holo-js/forms/internal/client';
 
-declare function useForm<TSchema extends Parameters<typeof useForm$1>[0]>(schemaDefinition: TSchema, options?: UseFormOptions<InferSchemaData<TSchema['fields']>>): UseFormResult<InferSchemaData<TSchema['fields']>>;
+declare function useForm<TSchema extends FormSchema, TSuccess = unknown>(schemaDefinition: TSchema, options?: UseFormOptions<InferFormData<TSchema>, TSuccess>): UseFormResult<InferFormData<TSchema>, TSuccess, InferFormFieldTree<TSchema>>;
+declare function useValidationErrors<TData = Record<string, unknown>>(bag?: string): ValidationErrorBag<TData>;
 
-export { useForm };
+export { useForm, useValidationErrors };

package/dist/client.mjs

@@ -1,11 +1,380 @@
 // src/client.ts
 import { createSubscriber } from "svelte/reactivity";
 import {
-  useForm as createForm
-} from "@holo-js/forms/client";
+  DEFAULT_VALIDATION_BAG,
+  createErrorBag
+} from "@holo-js/forms";
+import {
+  createFormClient,
+  runWithBrowserFormElement
+} from "@holo-js/forms/internal/client";
+var registeredForms = /* @__PURE__ */ new Set();
+var invalidActionFailureMessage = "Unable to read the form response. Please try again.";
+var validationFlashCookie = "HOLO-SVELTEKIT-VALIDATION";
+var submitListenerTarget;
 function isPlainObject(value) {
   return !!value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Blob);
 }
+function isSchemaField(value) {
+  return isPlainObject(value) && value.kind === "field" && isPlainObject(value.definition);
+}
+function collectSchemaPaths(value, prefix = "") {
+  if (isSchemaField(value)) {
+    return [prefix].filter(Boolean);
+  }
+  if (!isPlainObject(value)) {
+    return [];
+  }
+  return Object.entries(value).flatMap(([key, nested]) => {
+    const next = prefix ? `${prefix}.${key}` : key;
+    return collectSchemaPaths(nested, next);
+  });
+}
+function collectValuePaths(value, prefix = "") {
+  if (!isPlainObject(value)) {
+    return [prefix].filter(Boolean);
+  }
+  return Object.entries(value).flatMap(([key, nested]) => {
+    const next = prefix ? `${prefix}.${key}` : key;
+    return collectValuePaths(nested, next);
+  });
+}
+function flattenRestorableValues(value, prefix = "") {
+  if (typeof value === "undefined" || value instanceof Blob) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => flattenRestorableValues(item, prefix));
+  }
+  if (isPlainObject(value)) {
+    return Object.entries(value).flatMap(([key, nested]) => {
+      const next = prefix ? `${prefix}.${key}` : key;
+      return flattenRestorableValues(nested, next);
+    });
+  }
+  return prefix ? [[prefix, String(value)]] : [];
+}
+function restoreBrowserFormValues(values) {
+  const controls = globalThis.document?.querySelectorAll?.("input[name], textarea[name], select[name]");
+  if (!controls) {
+    return;
+  }
+  const valuesByName = /* @__PURE__ */ new Map();
+  for (const [name, value] of flattenRestorableValues(values)) {
+    valuesByName.set(name, [...valuesByName.get(name) ?? [], value]);
+  }
+  for (const control of Array.from(controls)) {
+    const name = control.name;
+    const nextValues = name ? valuesByName.get(name) : void 0;
+    if (!name || !nextValues) {
+      continue;
+    }
+    const type = control.type?.toLowerCase();
+    if (type === "file") {
+      continue;
+    }
+    if (type === "checkbox" || type === "radio") {
+      control.checked = nextValues.includes(control.value ?? "on");
+      continue;
+    }
+    control.value = nextValues[0] ?? "";
+  }
+}
+function scheduleBrowserFormValueRestore(values) {
+  restoreBrowserFormValues(values);
+  const browserWindow = globalThis.window;
+  const restore = () => restoreBrowserFormValues(values);
+  queueMicrotask(restore);
+  if (typeof browserWindow?.requestAnimationFrame === "function") {
+    browserWindow.requestAnimationFrame(restore);
+    return;
+  }
+  browserWindow?.setTimeout?.(restore, 0);
+}
+function isFormState(value) {
+  return isPlainObject(value) && typeof value.valid === "boolean" && isPlainObject(value.values) && isPlainObject(value.errors);
+}
+function stateMatchesSchema(schemaDefinition, state) {
+  const schemaPaths = collectSchemaPaths(schemaDefinition.fields);
+  const statePaths = [
+    ...Object.keys(state.errors),
+    ...collectValuePaths(state.values)
+  ];
+  return statePaths.every((path) => path === "_root" || schemaPaths.includes(path));
+}
+function parseJsonObject(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function createInvalidActionFailure(values, status) {
+  return {
+    ok: false,
+    status,
+    valid: false,
+    values,
+    errors: {
+      _root: [invalidActionFailureMessage]
+    }
+  };
+}
+function safeDecodeURIComponent(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function isFormFailurePayload(value) {
+  return isPlainObject(value) && value.ok === false && typeof value.status === "number" && value.valid === false && isPlainObject(value.values) && isPlainObject(value.errors);
+}
+function parseValidationFlashCookie(value) {
+  if (!value) {
+    return void 0;
+  }
+  const parsed = parseJsonObject(value) ?? parseJsonObject(safeDecodeURIComponent(value));
+  if (!isFormFailurePayload(parsed)) {
+    return void 0;
+  }
+  return parsed;
+}
+function readBrowserCookie(name) {
+  const cookie = globalThis.document?.cookie;
+  if (!cookie) {
+    return void 0;
+  }
+  for (const segment of cookie.split(";")) {
+    const trimmed = segment.trim();
+    const separator = trimmed.indexOf("=");
+    if (separator <= 0 || trimmed.slice(0, separator) !== name) {
+      continue;
+    }
+    return trimmed.slice(separator + 1);
+  }
+  return void 0;
+}
+function clearBrowserCookie(name) {
+  const document = globalThis.document;
+  if (!document) {
+    return;
+  }
+  document.cookie = `${name}=; Max-Age=0; Path=${getBrowserCookiePath()}; SameSite=Lax`;
+}
+function getSvelteKitRequestEvent() {
+  const store = globalThis.__holoSvelteKitRequestEventStore;
+  return store?.getStore();
+}
+function takeFlashedValidationState(schemaDefinition) {
+  if (typeof globalThis.window !== "undefined") {
+    return void 0;
+  }
+  const event = getSvelteKitRequestEvent();
+  const payload = parseValidationFlashCookie(event?.cookies.get(validationFlashCookie));
+  if (!event || !payload || !stateMatchesSchema(schemaDefinition, payload)) {
+    return void 0;
+  }
+  event.cookies.set(validationFlashCookie, "", {
+    path: event.url?.pathname || "/",
+    maxAge: 0,
+    sameSite: "lax",
+    httpOnly: true
+  });
+  return payload;
+}
+function takeValidationErrors(bag) {
+  const event = getSvelteKitRequestEvent();
+  const payload = event ? parseValidationFlashCookie(event.cookies.get(validationFlashCookie)) : parseValidationFlashCookie(readBrowserCookie(validationFlashCookie));
+  if (!payload || (payload.bag ?? DEFAULT_VALIDATION_BAG) !== bag) {
+    return void 0;
+  }
+  if (event) {
+    return payload;
+  }
+  scheduleBrowserFormValueRestore(payload.values);
+  clearBrowserCookie(validationFlashCookie);
+  return payload;
+}
+function isSvelteKitActionResult(value) {
+  return isPlainObject(value) && typeof value.type === "string" && (value.type === "failure" || value.type === "error" || value.type === "redirect" || value.type === "success");
+}
+function isJsonResponse(response) {
+  const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+  return contentType === "application/json" || contentType?.endsWith("+json") === true;
+}
+function normalizeFormDataName(name) {
+  return name.endsWith("[]") ? name.slice(0, -2) : name;
+}
+function countMatchingFormFields(form, paths) {
+  let formData;
+  try {
+    formData = Reflect.construct(FormData, [form]);
+  } catch {
+    return 0;
+  }
+  const names = new Set(Array.from(formData.entries(), ([name]) => normalizeFormDataName(name)));
+  return paths.filter((path) => names.has(path)).length;
+}
+function resolveSubmittedForm(target) {
+  if (target && typeof target === "object" && "tagName" in target && target.tagName === "FORM") {
+    return target;
+  }
+  return void 0;
+}
+function isNativePostForm(form) {
+  return (form.method || "get").toLowerCase() === "post";
+}
+function resolveRegisteredForm(form) {
+  if (!isNativePostForm(form)) {
+    return void 0;
+  }
+  let match;
+  let matchedFields = 0;
+  for (const candidate of registeredForms) {
+    const count = countMatchingFormFields(form, candidate.paths);
+    if (count > 0 && count >= matchedFields) {
+      match = candidate;
+      matchedFields = count;
+    }
+  }
+  return match;
+}
+function ensureSubmitListener() {
+  const document = globalThis.document;
+  const browserWindow = globalThis.window;
+  const target = typeof browserWindow?.addEventListener === "function" ? browserWindow : document && "addEventListener" in document && typeof document.addEventListener === "function" ? document : void 0;
+  if (!target) {
+    return;
+  }
+  if (submitListenerTarget === target) {
+    return;
+  }
+  submitListenerTarget = target;
+  target.addEventListener("submit", (event) => {
+    const form = resolveSubmittedForm(event.target);
+    const registeredForm = form ? resolveRegisteredForm(form) : void 0;
+    if (!form || !registeredForm) {
+      return;
+    }
+    event.preventDefault();
+    event.stopImmediatePropagation();
+    void registeredForm.submit(form);
+  }, true);
+}
+function registerForm(schemaDefinition, form) {
+  if (typeof globalThis.window === "undefined") {
+    return () => {
+    };
+  }
+  const registeredForm = {
+    paths: collectSchemaPaths(schemaDefinition.fields),
+    async submit(liveForm) {
+      await runWithBrowserFormElement(form, liveForm);
+    }
+  };
+  registeredForms.add(registeredForm);
+  ensureSubmitListener();
+  let registered = true;
+  return () => {
+    if (!registered) {
+      return;
+    }
+    registered = false;
+    registeredForms.delete(registeredForm);
+  };
+}
+function currentLocationHref() {
+  const location = globalThis.window?.location;
+  return location?.href;
+}
+function redirectBrowser(location) {
+  const browserLocation = globalThis.window?.location;
+  if (typeof browserLocation?.assign === "function") {
+    browserLocation.assign(location);
+    return;
+  }
+  if (browserLocation && "href" in browserLocation) {
+    browserLocation.href = location;
+  }
+}
+function getBrowserCookiePath() {
+  const pathname = globalThis.window?.location?.pathname;
+  return (pathname || "/").replace(/[;\r\n]/g, "") || "/";
+}
+async function submitSvelteKitAction(context) {
+  const action = context.action ?? currentLocationHref();
+  if (typeof fetch !== "function" || !action) {
+    return {
+      ok: true,
+      status: 200,
+      data: context.values
+    };
+  }
+  const method = context.method.toUpperCase();
+  const init = method === "GET" || method === "HEAD" ? {
+    method,
+    credentials: "same-origin",
+    headers: {
+      accept: "application/json"
+    }
+  } : {
+    method,
+    credentials: "same-origin",
+    body: context.formData,
+    headers: {
+      accept: "application/json",
+      "x-sveltekit-action": "true"
+    }
+  };
+  const response = await fetch(action, init);
+  if (!isJsonResponse(response)) {
+    return {
+      ok: response.ok,
+      status: response.status,
+      data: void 0
+    };
+  }
+  const result = await response.json();
+  if (!isSvelteKitActionResult(result)) {
+    return result;
+  }
+  if (result.type === "failure") {
+    const parsed = parseJsonObject(result.data);
+    return isPlainObject(parsed) ? parsed : createInvalidActionFailure(context.values, result.status);
+  }
+  if (result.type === "error") {
+    return result.error;
+  }
+  if (result.type === "redirect") {
+    redirectBrowser(result.location);
+    return {
+      ok: true,
+      status: result.status,
+      data: void 0
+    };
+  }
+  return {
+    ok: true,
+    status: result.status,
+    data: result.data
+  };
+}
+async function hydrateActionFormState(form, schemaDefinition) {
+  if (typeof globalThis.window === "undefined") {
+    return;
+  }
+  const stores = await import("$app/stores");
+  let unsubscribe = () => {
+  };
+  unsubscribe = stores.page.subscribe((value) => {
+    const state = value.form;
+    if (isFormState(state) && stateMatchesSchema(schemaDefinition, state)) {
+      form.applyServerState(state);
+    }
+    queueMicrotask(unsubscribe);
+  });
+}
 function createReactiveView(target, subscribe, cache) {
   const cached = cache.get(target);
   if (cached) {
@@ -50,11 +419,30 @@ function createReactiveView(target, subscribe, cache) {
   return proxy;
 }
 function useForm(schemaDefinition, options = {}) {
-  const form = createForm(schemaDefinition, options);
-  const subscribe = createSubscriber((update) => form.subscribe(update));
+  const formOptions = {
+    ...options,
+    action: options.action ?? currentLocationHref(),
+    initialState: options.initialState ?? takeFlashedValidationState(schemaDefinition),
+    submitter: options.submitter ?? submitSvelteKitAction
+  };
+  const form = createFormClient(schemaDefinition, formOptions);
+  void hydrateActionFormState(form, schemaDefinition);
+  const unregisterForm = registerForm(schemaDefinition, form);
+  const subscribe = createSubscriber((update) => {
+    const unsubscribe = form.subscribe(update);
+    return () => {
+      unsubscribe();
+      unregisterForm();
+    };
+  });
   const cache = /* @__PURE__ */ new WeakMap();
   return createReactiveView(form, subscribe, cache);
 }
+function useValidationErrors(bag = DEFAULT_VALIDATION_BAG) {
+  const payload = takeValidationErrors(bag);
+  return createErrorBag(payload?.errors ?? {});
+}
 export {
-  useForm
+  useForm,
+  useValidationErrors
 };

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+import { Config } from '@sveltejs/kit';
+
+declare function withHoloSvelteKit<TConfig extends Config = Config>(config?: TConfig): TConfig;
+
+export { withHoloSvelteKit };

package/dist/config.mjs

@@ -0,0 +1,253 @@
+// src/preprocess.ts
+var clientImportPattern = /import\s*\{([^}]*)\}\s*from\s*['"]@holo-js\/adapter-sveltekit\/client['"]/g;
+var identifier = String.raw`[$A-Z_a-z][$\w]*`;
+var HOLO_SVELTE_PREPROCESS_NAME = "holo-sveltekit";
+function collectUseFormAliases(script) {
+  const aliases = /* @__PURE__ */ new Set();
+  for (const match of script.matchAll(clientImportPattern)) {
+    const imports = match[1] ?? "";
+    for (const rawSpecifier of imports.split(",")) {
+      const specifier = rawSpecifier.trim();
+      const aliased = specifier.match(new RegExp(String.raw`^useForm\s+as\s+(${identifier})$`));
+      if (specifier === "useForm") {
+        aliases.add("useForm");
+      } else if (aliased?.[1]) {
+        aliases.add(aliased[1]);
+      }
+    }
+  }
+  return [...aliases];
+}
+function collectScriptBlocks(content) {
+  const blocks = [];
+  const pattern = /<script\b[^>]*>/g;
+  for (const match of content.matchAll(pattern)) {
+    const contentStart = match.index + match[0].length;
+    const closeIndex = content.indexOf("</script>", contentStart);
+    if (closeIndex === -1) {
+      continue;
+    }
+    blocks.push({
+      contentStart,
+      contentEnd: closeIndex,
+      content: content.slice(contentStart, closeIndex)
+    });
+  }
+  return blocks;
+}
+function skipString(source, index, quote) {
+  let cursor = index + 1;
+  while (cursor < source.length) {
+    const char = source[cursor];
+    if (char === "\\") {
+      cursor += 2;
+      continue;
+    }
+    if (char === quote) {
+      return cursor + 1;
+    }
+    cursor += 1;
+  }
+  return cursor;
+}
+function skipLineComment(source, index) {
+  const end = source.indexOf("\n", index + 2);
+  return end === -1 ? source.length : end + 1;
+}
+function skipBlockComment(source, index) {
+  const end = source.indexOf("*/", index + 2);
+  return end === -1 ? source.length : end + 2;
+}
+function skipTypeArguments(source, index) {
+  if (source[index] !== "<") {
+    return index;
+  }
+  let depth = 0;
+  let cursor = index;
+  while (cursor < source.length) {
+    const char = source[cursor];
+    const next = source[cursor + 1];
+    if (char === '"' || char === "'" || char === "`") {
+      cursor = skipString(source, cursor, char);
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      cursor = skipLineComment(source, cursor);
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      cursor = skipBlockComment(source, cursor);
+      continue;
+    }
+    if (char === "<") {
+      depth += 1;
+    } else if (char === ">") {
+      depth -= 1;
+      if (depth === 0) {
+        return cursor + 1;
+      }
+    }
+    cursor += 1;
+  }
+  return index;
+}
+function findOpeningParen(source, index) {
+  let cursor = index;
+  while (/\s/.test(source[cursor] ?? "")) {
+    cursor += 1;
+  }
+  cursor = skipTypeArguments(source, cursor);
+  while (/\s/.test(source[cursor] ?? "")) {
+    cursor += 1;
+  }
+  return source[cursor] === "(" ? cursor : -1;
+}
+function findClosingParen(source, index) {
+  let depth = 0;
+  let cursor = index;
+  while (cursor < source.length) {
+    const char = source[cursor];
+    const next = source[cursor + 1];
+    if (char === '"' || char === "'" || char === "`") {
+      cursor = skipString(source, cursor, char);
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      cursor = skipLineComment(source, cursor);
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      cursor = skipBlockComment(source, cursor);
+      continue;
+    }
+    if (char === "(") {
+      depth += 1;
+    } else if (char === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        return cursor;
+      }
+    }
+    cursor += 1;
+  }
+  return -1;
+}
+function applyReplacements(source, replacements) {
+  if (replacements.length === 0) {
+    return source;
+  }
+  let output = "";
+  let cursor = 0;
+  const orderedReplacements = [...replacements].sort((left, right) => left.start - right.start);
+  for (const replacement of orderedReplacements) {
+    output += source.slice(cursor, replacement.start);
+    output += replacement.text;
+    cursor = replacement.end;
+  }
+  return output + source.slice(cursor);
+}
+function transformScript(script) {
+  const aliases = collectUseFormAliases(script);
+  if (aliases.length === 0) {
+    return script;
+  }
+  const aliasPattern = aliases.map((alias) => alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  const declarationPattern = new RegExp(
+    String.raw`(^|\n)([ \t]*)const\s+(${identifier})\s*=\s*(${aliasPattern})\b`,
+    "g"
+  );
+  const replacements = [];
+  for (const match of script.matchAll(declarationPattern)) {
+    const indentation = match[2] ?? "";
+    const variable = match[3];
+    if (!variable || script.includes(`${variable}.subscribe(() => { ${variable} = ${variable} })`)) {
+      continue;
+    }
+    const constStart = match.index + (match[1]?.length ?? 0) + indentation.length;
+    const calleeEnd = match.index + match[0].length;
+    const openingParen = findOpeningParen(script, calleeEnd);
+    if (openingParen === -1) {
+      continue;
+    }
+    const closingParen = findClosingParen(script, openingParen);
+    if (closingParen === -1) {
+      continue;
+    }
+    replacements.push({
+      start: constStart,
+      end: constStart + "const".length,
+      text: "let"
+    }, {
+      start: closingParen + 1,
+      end: closingParen + 1,
+      text: `
+${indentation}${variable}.subscribe(() => { ${variable} = ${variable} })`
+    });
+  }
+  return applyReplacements(script, replacements);
+}
+function transformSvelteUseFormReactivity(content) {
+  const replacements = collectScriptBlocks(content).flatMap((block) => {
+    const transformed = transformScript(block.content);
+    return transformed === block.content ? [] : [{
+      start: block.contentStart,
+      end: block.contentEnd,
+      text: transformed
+    }];
+  });
+  return applyReplacements(content, replacements);
+}
+function holoSveltePreprocess() {
+  return {
+    name: HOLO_SVELTE_PREPROCESS_NAME,
+    markup({ content }) {
+      return {
+        code: transformSvelteUseFormReactivity(content)
+      };
+    }
+  };
+}
+
+// src/config.ts
+var managedServerHooksPath = ".holo-js/generated/hooks.server";
+var managedUniversalHooksPath = ".holo-js/generated/hooks";
+function toPreprocessorArray(preprocess) {
+  if (!preprocess) {
+    return [];
+  }
+  return Array.isArray(preprocess) ? [...preprocess] : [preprocess];
+}
+function hasHoloPreprocess(preprocessors) {
+  return preprocessors.some((preprocessor) => preprocessor.name === HOLO_SVELTE_PREPROCESS_NAME);
+}
+function assertNoCustomManagedHooks(config) {
+  const hooks = config.kit?.files?.hooks;
+  const customServerHook = hooks?.server && hooks.server !== managedServerHooksPath;
+  const customUniversalHook = hooks?.universal && hooks.universal !== managedUniversalHooksPath;
+  if (customServerHook || customUniversalHook) {
+    throw new Error("[@holo-js/adapter-sveltekit] Custom SvelteKit server or universal hook entrypoints are not supported. Move user hook code to src/hooks.ts and src/hooks.server.ts so Holo can manage the hook bridge.");
+  }
+}
+function withHoloSvelteKit(config = {}) {
+  assertNoCustomManagedHooks(config);
+  const preprocessors = toPreprocessorArray(config.preprocess);
+  const mergedPreprocessors = hasHoloPreprocess(preprocessors) ? preprocessors : [...preprocessors, holoSveltePreprocess()];
+  return {
+    ...config,
+    preprocess: mergedPreprocessors,
+    kit: {
+      ...config.kit ?? {},
+      files: {
+        ...config.kit?.files ?? {},
+        hooks: {
+          ...config.kit?.files?.hooks ?? {},
+          server: managedServerHooksPath,
+          universal: managedUniversalHooksPath
+        }
+      }
+    }
+  };
+}
+export {
+  withHoloSvelteKit
+};

package/dist/index.d.ts

@@ -1,17 +1,50 @@
 import * as _holo_js_core from '@holo-js/core';
 import { HoloFrameworkOptions, HoloAdapterProject } from '@holo-js/core';
+import { SerializedValidationException } from '@holo-js/forms/schema';
 import { HoloConfigMap } from '@holo-js/config';
+export { SvelteKitTransportDefinition, holoSvelteKitTransport } from './transport.js';
 
 type SvelteKitHoloOptions = HoloFrameworkOptions;
 type SvelteKitHoloProject<TCustom extends HoloConfigMap = HoloConfigMap> = HoloAdapterProject<TCustom>;
+type SvelteKitRequestEvent = {
+    readonly url?: URL;
+    readonly cookies: {
+        get(name: string): string | undefined;
+        set(name: string, value: string, options: SvelteKitCookieOptions): void;
+    };
+    readonly request: {
+        readonly method?: string;
+        readonly headers: Headers;
+    };
+};
+type SvelteKitCookieOptions = {
+    path: string;
+    domain?: string;
+    maxAge?: number;
+    expires?: Date;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'lax' | 'strict' | 'none';
+    partitioned?: boolean;
+};
+declare function isApiEvent(event: SvelteKitRequestEvent): boolean;
+declare function serializeValidationException(error: unknown): SerializedValidationException | undefined;
+declare function mapValidationActionResponse(event: SvelteKitRequestEvent, response: Response): Promise<Response>;
+declare function rememberValidationActionFailure(event: SvelteKitRequestEvent, payload: SerializedValidationException): void;
 declare const svelteKitHoloCapabilities: Readonly<_holo_js_core.HoloAdapterCapabilities>;
+declare function runWithSvelteKitRequestEvent<TValue>(event: SvelteKitRequestEvent, callback: () => TValue): TValue;
 declare function createSvelteKitHoloProject<TCustom extends HoloConfigMap = HoloConfigMap>(options?: SvelteKitHoloOptions): Promise<SvelteKitHoloProject<TCustom>>;
 declare function initializeSvelteKitHoloProject<TCustom extends HoloConfigMap = HoloConfigMap>(options?: SvelteKitHoloOptions): Promise<SvelteKitHoloProject<TCustom>>;
 declare function createSvelteKitHoloHelpers<TCustom extends HoloConfigMap = HoloConfigMap>(options?: SvelteKitHoloOptions): _holo_js_core.HoloAdapterProjectAccessors<TCustom>;
 declare function resetSvelteKitHoloProject(): Promise<void>;
 declare const adapterSvelteKitInternals: {
+    mapValidationActionResponse: typeof mapValidationActionResponse;
+    rememberValidationActionFailure: typeof rememberValidationActionFailure;
+    isApiEvent: typeof isApiEvent;
+    serializeValidationException: typeof serializeValidationException;
+    validationFlashCookie: string;
     getState: () => _holo_js_core.HoloFrameworkAdapterState<HoloAdapterProject<object>>;
     resolveOptions: (projectOptions?: HoloFrameworkOptions) => _holo_js_core.ResolvedHoloFrameworkOptions;
 };
 
-export { type SvelteKitHoloOptions, type SvelteKitHoloProject, adapterSvelteKitInternals, createSvelteKitHoloHelpers, createSvelteKitHoloProject, initializeSvelteKitHoloProject, resetSvelteKitHoloProject, svelteKitHoloCapabilities };
+export { type SvelteKitHoloOptions, type SvelteKitHoloProject, adapterSvelteKitInternals, createSvelteKitHoloHelpers, createSvelteKitHoloProject, initializeSvelteKitHoloProject, resetSvelteKitHoloProject, runWithSvelteKitRequestEvent, svelteKitHoloCapabilities };

package/dist/index.mjs

@@ -1,30 +1,355 @@
+import {
+  holoSvelteKitTransport
+} from "./chunk-FZXR22V2.mjs";
+
 // src/index.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { error as svelteKitError } from "@sveltejs/kit";
 import {
   createHoloFrameworkAdapter
 } from "@holo-js/core";
+import {
+  isValidationException,
+  validationInternals
+} from "@holo-js/forms/schema";
 var svelteKitAdapter = createHoloFrameworkAdapter({
   stateKey: "__holoSvelteKitAdapter__",
   displayName: "SvelteKit"
 });
+var validationFlashCookie = "HOLO-SVELTEKIT-VALIDATION";
+var validationExceptionThrowerRegistered = false;
+var validationActionFailures = /* @__PURE__ */ new WeakMap();
+var validationActionFailureKeys = /* @__PURE__ */ new Map();
+function getSvelteKitRequestEventStore() {
+  const runtimeGlobal = globalThis;
+  runtimeGlobal.__holoSvelteKitRequestEventStore ??= new AsyncLocalStorage();
+  return runtimeGlobal.__holoSvelteKitRequestEventStore;
+}
+function toSvelteKitErrorStatus(status) {
+  return status >= 400 && status <= 599 ? status : 500;
+}
+function isApiEvent(event) {
+  return event.url?.pathname.startsWith("/api/") === true;
+}
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isSerializedValidationException(value) {
+  return isPlainObject(value) && value.ok === false && typeof value.status === "number" && value.valid === false && typeof value.message === "string" && typeof value.bag === "string" && isPlainObject(value.values) && isPlainObject(value.errors);
+}
+function serializeValidationException(error) {
+  return isValidationException(error) ? error.toJSON() : void 0;
+}
+function toSvelteKitValidationBody(payload) {
+  return payload;
+}
+function isSvelteKitActionJsonRequest(event) {
+  return event.request.method?.toUpperCase() === "POST" && event.request.headers.get("accept")?.toLowerCase().includes("application/json") === true;
+}
+async function mapValidationActionResponse(event, response) {
+  if (isApiEvent(event)) {
+    const apiPayload = takeValidationActionFailure(event);
+    if (apiPayload) {
+      return Response.json(apiPayload, { status: apiPayload.status });
+    }
+    return response;
+  }
+  const flashedPayload = takeValidationActionFailure(event);
+  if (flashedPayload) {
+    return isSvelteKitActionJsonRequest(event) ? createValidationActionFailureResponse(flashedPayload, response, true) : createValidationActionRedirectResponse(event, flashedPayload);
+  }
+  if (!isSvelteKitActionJsonRequest(event)) {
+    return response;
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.toLowerCase().includes("application/json")) {
+    return response;
+  }
+  let actionResult;
+  try {
+    actionResult = await response.clone().json();
+  } catch {
+    return response;
+  }
+  if (actionResult.type !== "error" || !isSerializedValidationException(actionResult.error)) {
+    return response;
+  }
+  return createValidationActionFailureResponse(actionResult.error, response, false);
+}
+function encodeValidationFlashPayload(payload) {
+  return encodeURIComponent(JSON.stringify({
+    ...payload,
+    values: filterFlashValues(payload.values)
+  }));
+}
+function isSensitiveFlashKey(key) {
+  const normalized = key.toLowerCase().replace(/[-_\s]/g, "");
+  return normalized.startsWith("_") || normalized.includes("password") || normalized.includes("token") || normalized.includes("secret") || normalized.includes("credential");
+}
+function filterFlashValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => filterFlashValue(item)).filter((item) => typeof item !== "undefined");
+  }
+  if (!isPlainObject(value)) {
+    return void 0;
+  }
+  return filterFlashValues(value);
+}
+function filterFlashValues(values) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(values)) {
+    if (isSensitiveFlashKey(key)) {
+      continue;
+    }
+    const next = filterFlashValue(value);
+    if (typeof next !== "undefined") {
+      filtered[key] = next;
+    }
+  }
+  return filtered;
+}
+function flashValidationPayload(event, payload) {
+  if (!event.url) {
+    return;
+  }
+  event.cookies.set(validationFlashCookie, encodeValidationFlashPayload(payload), {
+    path: normalizeCookiePath(event),
+    maxAge: 60,
+    sameSite: "lax"
+  });
+}
+function normalizeCookiePath(event) {
+  return (event.url?.pathname || "/").replace(/[;\r\n]/g, "") || "/";
+}
+function createValidationFlashCookie(event, payload) {
+  return [
+    `${validationFlashCookie}=${encodeValidationFlashPayload(payload)}`,
+    "Max-Age=60",
+    `Path=${normalizeCookiePath(event)}`,
+    "SameSite=Lax"
+  ].join("; ");
+}
+function createValidationActionFailureResponse(payload, response, reloadWithFlash) {
+  const headers = new Headers(response.headers);
+  headers.delete("content-length");
+  headers.set("content-type", "application/json");
+  if (reloadWithFlash) {
+    headers.set("x-holo-validation-flash", "1");
+  }
+  return Response.json({
+    type: "failure",
+    status: payload.status,
+    data: JSON.stringify(payload)
+  }, {
+    status: 200,
+    headers
+  });
+}
+function createValidationActionRedirectResponse(event, payload) {
+  return new Response(null, {
+    status: 303,
+    headers: {
+      location: event.url?.pathname || "/",
+      "cache-control": "no-store",
+      "set-cookie": createValidationFlashCookie(event, payload)
+    }
+  });
+}
+function getValidationActionFailureKey(event) {
+  if (!event.url) {
+    return void 0;
+  }
+  return `${event.request.method?.toUpperCase() ?? "GET"} ${event.url.href}`;
+}
+function takeValidationActionFailure(event) {
+  const key = getValidationActionFailureKey(event);
+  const eventPayload = validationActionFailures.get(event);
+  if (eventPayload) {
+    validationActionFailures.delete(event);
+    validationActionFailures.delete(event.request);
+    if (key) {
+      validationActionFailureKeys.delete(key);
+    }
+    return eventPayload;
+  }
+  const requestPayload = validationActionFailures.get(event.request);
+  if (requestPayload) {
+    validationActionFailures.delete(event);
+    validationActionFailures.delete(event.request);
+    if (key) {
+      validationActionFailureKeys.delete(key);
+    }
+    return requestPayload;
+  }
+  if (!key) {
+    return void 0;
+  }
+  const keyedPayload = validationActionFailureKeys.get(key);
+  validationActionFailureKeys.delete(key);
+  return keyedPayload;
+}
+function rememberValidationActionFailure(event, payload) {
+  flashValidationPayload(event, payload);
+  validationActionFailures.set(event, payload);
+  validationActionFailures.set(event.request, payload);
+  const key = getValidationActionFailureKey(event);
+  if (key) {
+    validationActionFailureKeys.set(key, payload);
+  }
+}
+function registerValidationExceptionThrower() {
+  if (validationExceptionThrowerRegistered) {
+    return;
+  }
+  validationExceptionThrowerRegistered = true;
+  validationInternals.setValidationExceptionThrower((exception) => {
+    const event = getSvelteKitRequestEventStore().getStore();
+    if (!event) {
+      return;
+    }
+    const payload = exception.toJSON();
+    if (!isApiEvent(event)) {
+      rememberValidationActionFailure(event, payload);
+    }
+    svelteKitError(toSvelteKitErrorStatus(payload.status), toSvelteKitValidationBody(payload));
+  });
+}
+function safeDecodeCookieSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function parseResponseCookie(cookie) {
+  const [nameValue = "", ...attributes] = cookie.split(";");
+  const separator = nameValue.indexOf("=");
+  if (!nameValue || separator <= 0) {
+    return null;
+  }
+  const options = { path: "/" };
+  for (const rawAttribute of attributes) {
+    const attribute = rawAttribute.trim();
+    if (!attribute) {
+      continue;
+    }
+    const attributeSeparator = attribute.indexOf("=");
+    const key = (attributeSeparator === -1 ? attribute : attribute.slice(0, attributeSeparator)).trim().toLowerCase();
+    const value = attributeSeparator === -1 ? "" : attribute.slice(attributeSeparator + 1).trim();
+    switch (key) {
+      case "path":
+        options.path = value || "/";
+        break;
+      case "domain":
+        options.domain = value;
+        break;
+      case "max-age": {
+        const maxAge = Number(value);
+        if (Number.isFinite(maxAge)) {
+          options.maxAge = maxAge;
+        }
+        break;
+      }
+      case "expires": {
+        const expires = new Date(value);
+        if (!Number.isNaN(expires.getTime())) {
+          options.expires = expires;
+        }
+        break;
+      }
+      case "secure":
+        options.secure = true;
+        break;
+      case "httponly":
+        options.httpOnly = true;
+        break;
+      case "samesite":
+        if (value.toLowerCase() === "lax" || value.toLowerCase() === "strict" || value.toLowerCase() === "none") {
+          options.sameSite = value.toLowerCase();
+        }
+        break;
+      case "partitioned":
+        options.partitioned = value ? value.toLowerCase() === "true" : true;
+        break;
+    }
+  }
+  return {
+    name: safeDecodeCookieSegment(nameValue.slice(0, separator)),
+    value: safeDecodeCookieSegment(nameValue.slice(separator + 1)),
+    options
+  };
+}
+function resolveSvelteKitAuthRequestAccessors() {
+  return {
+    async getCookie(name) {
+      const event = getSvelteKitRequestEventStore().getStore();
+      return event?.cookies.get(name) ?? void 0;
+    },
+    async getHeader(name) {
+      const event = getSvelteKitRequestEventStore().getStore();
+      return event?.request.headers.get(name) ?? void 0;
+    },
+    appendResponseCookie(cookie) {
+      const event = getSvelteKitRequestEventStore().getStore();
+      const parsed = parseResponseCookie(cookie);
+      if (!event || !parsed) {
+        return;
+      }
+      event.cookies.set(parsed.name, parsed.value, parsed.options);
+    },
+    async redirectResponse(url, status = 307) {
+      const { redirect } = await import("@sveltejs/kit");
+      redirect(status, url);
+    }
+  };
+}
+function resolveSvelteKitOptions(options) {
+  return {
+    ...options,
+    authRequest: options.authRequest ?? resolveSvelteKitAuthRequestAccessors(),
+    authorizationError: options.authorizationError ?? {
+      createError(decision) {
+        const status = decision.status === 404 ? 404 : 403;
+        svelteKitError(status, decision.message ?? "You are not authorized to perform this action.");
+      }
+    }
+  };
+}
 var svelteKitHoloCapabilities = svelteKitAdapter.capabilities;
+function runWithSvelteKitRequestEvent(event, callback) {
+  registerValidationExceptionThrower();
+  return getSvelteKitRequestEventStore().run(event, callback);
+}
 async function createSvelteKitHoloProject(options = {}) {
-  return svelteKitAdapter.createProject(options);
+  return svelteKitAdapter.createProject(resolveSvelteKitOptions(options));
 }
 async function initializeSvelteKitHoloProject(options = {}) {
-  return svelteKitAdapter.initializeProject(options);
+  return svelteKitAdapter.initializeProject(resolveSvelteKitOptions(options));
 }
 function createSvelteKitHoloHelpers(options = {}) {
-  return svelteKitAdapter.createHelpers(options);
+  return svelteKitAdapter.createHelpers(resolveSvelteKitOptions(options));
 }
 async function resetSvelteKitHoloProject() {
   await svelteKitAdapter.resetProject();
 }
-var adapterSvelteKitInternals = svelteKitAdapter.internals;
+var adapterSvelteKitInternals = {
+  ...svelteKitAdapter.internals,
+  mapValidationActionResponse,
+  rememberValidationActionFailure,
+  isApiEvent,
+  serializeValidationException,
+  validationFlashCookie
+};
 export {
   adapterSvelteKitInternals,
   createSvelteKitHoloHelpers,
   createSvelteKitHoloProject,
+  holoSvelteKitTransport,
   initializeSvelteKitHoloProject,
   resetSvelteKitHoloProject,
+  runWithSvelteKitRequestEvent,
   svelteKitHoloCapabilities
 };

package/dist/transport.d.ts

@@ -0,0 +1,18 @@
+type JsonSerializable = {
+    toJSON(): unknown;
+};
+type SerializedSvelteKitData<TValue> = TValue extends Date ? Date : TValue extends JsonSerializable ? ReturnType<TValue['toJSON']> : TValue extends readonly (infer TItem)[] ? SerializedSvelteKitData<TItem>[] : TValue extends object ? {
+    [K in keyof TValue]: SerializedSvelteKitData<TValue[K]>;
+} : TValue;
+type HoloTransportEncoder = {
+    encode: (value: unknown) => false | unknown[] | Record<string, unknown>;
+    decode: (value: unknown[] | Record<string, unknown>) => unknown;
+};
+type SvelteKitTransportDefinition = Readonly<{
+    HoloModel: HoloTransportEncoder;
+    HoloCollection: HoloTransportEncoder;
+}>;
+declare function serializeSvelteKitData<TValue>(value: TValue): SerializedSvelteKitData<TValue>;
+declare const holoSvelteKitTransport: SvelteKitTransportDefinition;
+
+export { type SerializedSvelteKitData, type SvelteKitTransportDefinition, holoSvelteKitTransport, serializeSvelteKitData };

package/dist/transport.mjs

@@ -0,0 +1,8 @@
+import {
+  holoSvelteKitTransport,
+  serializeSvelteKitData
+} from "./chunk-FZXR22V2.mjs";
+export {
+  holoSvelteKitTransport,
+  serializeSvelteKitData
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/adapter-sveltekit",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Holo-JS Framework - SvelteKit adapter",
   "type": "module",
   "license": "MIT",
@@ -10,10 +10,20 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.mjs",
+      "default": "./dist/config.mjs"
+    },
     "./client": {
       "types": "./dist/client.d.ts",
       "import": "./dist/client.mjs",
       "default": "./dist/client.mjs"
+    },
+    "./transport": {
+      "types": "./dist/transport.d.ts",
+      "import": "./dist/transport.mjs",
+      "default": "./dist/transport.mjs"
     }
   },
   "main": "./dist/index.mjs",
@@ -28,21 +38,19 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/config": "^0.1.4",
-    "@holo-js/core": "^0.1.4"
+    "@holo-js/config": "^0.1.5",
+    "@holo-js/core": "^0.1.5",
+    "svelte": "^5.55.5"
   },
   "peerDependencies": {
-    "@holo-js/forms": "^0.1.4"
-  },
-  "peerDependenciesMeta": {
-    "@holo-js/forms": {
-      "optional": true
-    }
+    "@holo-js/forms": "^0.1.5",
+    "@sveltejs/kit": "^2.59.1"
   },
   "devDependencies": {
+    "@sveltejs/kit": "^2.59.1",
     "@types/node": "^22.10.2",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vitest": "^4.1.5"
   }
 }