@wow-two-beta/ui-vue 0.0.5 → 0.0.6

package/dist/chunks/SubmitErrors-1_5oKOb1.js

@@ -0,0 +1,402 @@
+import { A as AriaAttribute } from "./AriaAttribute-CmUjjXjp.js";
+import { A as AppErrorFactory } from "./AppErrorFactory-DCdNbVfv.js";
+import { c as createMessageResolver } from "./Messages-CSW3nyTs.js";
+import { computed, defineComponent, h } from "vue";
+import { _ as _sfc_main } from "./FormControlProvider.vue_vue_type_script_setup_true_lang-D_yikT2o.js";
+function focusFirstInvalid(root) {
+  if (!root) return null;
+  for (const candidate of root.querySelectorAll('[aria-invalid="true"]')) {
+    if (candidate.closest('[inert], [hidden], [aria-hidden="true"]')) continue;
+    if (candidate.matches(":disabled") || candidate.getAttribute(AriaAttribute.Disabled) === "true") continue;
+    if (candidate.tabIndex < 0) continue;
+    candidate.focus();
+    if (candidate.ownerDocument.activeElement === candidate) return candidate;
+  }
+  return null;
+}
+function parsePath(path) {
+  const segments = [];
+  let buffer = "";
+  let index = 0;
+  const flush = () => {
+    if (buffer !== "") {
+      segments.push(buffer);
+      buffer = "";
+    }
+  };
+  while (index < path.length) {
+    const char = path.charAt(index);
+    if (char === ".") {
+      flush();
+      index += 1;
+      continue;
+    }
+    if (char === "[") {
+      flush();
+      const close = path.indexOf("]", index);
+      const inner = path.slice(index + 1, close === -1 ? path.length : close);
+      const parsed = Number(inner);
+      segments.push(inner !== "" && Number.isInteger(parsed) && parsed >= 0 ? parsed : inner);
+      index = close === -1 ? path.length : close + 1;
+      continue;
+    }
+    buffer += char;
+    index += 1;
+  }
+  flush();
+  return segments;
+}
+function formatPath(segments) {
+  let path = "";
+  for (const segment of segments) {
+    if (typeof segment === "number") path += `[${segment}]`;
+    else path += path === "" ? segment : `.${segment}`;
+  }
+  return path;
+}
+function getPath(target, path) {
+  let current = target;
+  for (const segment of parsePath(path)) {
+    if (current === null || typeof current !== "object") return void 0;
+    if (!Object.hasOwn(current, segment)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function hasPath(target, path) {
+  const segments = parsePath(path);
+  if (segments.length === 0) return false;
+  let current = target;
+  for (const segment of segments) {
+    if (current === null || typeof current !== "object") return false;
+    if (Array.isArray(current)) {
+      if (typeof segment !== "number" || segment < 0 || segment >= current.length) return false;
+    }
+    if (!Object.hasOwn(current, segment)) return false;
+    current = current[segment];
+  }
+  return true;
+}
+function setPath(target, path, value) {
+  const segments = parsePath(path);
+  if (segments.length === 0) return target;
+  return setAtDepth(target, segments, 0, value);
+}
+function setAtDepth(current, segments, depth, value) {
+  const segment = segments[depth];
+  if (segment === void 0) return value;
+  if (typeof segment === "number") {
+    const array = Array.isArray(current) ? [...current] : [];
+    array[segment] = setAtDepth(array[segment], segments, depth + 1, value);
+    return array;
+  }
+  const object = current !== null && typeof current === "object" && !Array.isArray(current) ? { ...current } : {};
+  const previous = Object.hasOwn(object, segment) ? object[segment] : void 0;
+  Object.defineProperty(object, segment, {
+    value: setAtDepth(previous, segments, depth + 1, value),
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+  return object;
+}
+function mutateRows(rows, operation) {
+  switch (operation.kind) {
+    case "push":
+      rows.push(operation.value);
+      return;
+    case "insert":
+      rows.splice(operation.index, 0, operation.value);
+      return;
+    case "remove":
+      rows.splice(operation.index, 1);
+      return;
+    case "swap": {
+      const valueA = rows[operation.indexA];
+      rows[operation.indexA] = rows[operation.indexB];
+      rows[operation.indexB] = valueA;
+      return;
+    }
+    case "move": {
+      const [moved] = rows.splice(operation.fromIndex, 1);
+      rows.splice(operation.toIndex, 0, moved);
+      return;
+    }
+  }
+}
+function remapRowIndex(index, operation) {
+  switch (operation.kind) {
+    case "push":
+      return index;
+    case "insert":
+      return index >= operation.index ? index + 1 : index;
+    case "remove":
+      if (index === operation.index) return null;
+      return index > operation.index ? index - 1 : index;
+    case "swap":
+      if (index === operation.indexA) return operation.indexB;
+      if (index === operation.indexB) return operation.indexA;
+      return index;
+    case "move": {
+      const { fromIndex, toIndex } = operation;
+      if (index === fromIndex) return toIndex;
+      if (fromIndex < toIndex && index > fromIndex && index <= toIndex) return index - 1;
+      if (fromIndex > toIndex && index >= toIndex && index < fromIndex) return index + 1;
+      return index;
+    }
+  }
+}
+function remapPathKey(key, arrayPath, operation) {
+  const keySegments = parsePath(key);
+  const arraySegments = parsePath(arrayPath);
+  if (keySegments.length <= arraySegments.length) return key;
+  for (let index = 0; index < arraySegments.length; index += 1) {
+    if (keySegments[index] !== arraySegments[index]) return key;
+  }
+  const rowIndex = keySegments[arraySegments.length];
+  if (typeof rowIndex !== "number") return key;
+  const remapped = remapRowIndex(rowIndex, operation);
+  if (remapped === null) return null;
+  if (remapped === rowIndex) return key;
+  const nextSegments = [...keySegments];
+  nextSegments[arraySegments.length] = remapped;
+  return formatPath(nextSegments);
+}
+function remapPathMap(map, arrayPath, operation) {
+  const next = /* @__PURE__ */ Object.create(null);
+  for (const [key, messages] of Object.entries(map)) {
+    const remapped = remapPathKey(key, arrayPath, operation);
+    if (remapped !== null) next[remapped] = messages;
+  }
+  return next;
+}
+function remapPathSet(set, arrayPath, operation) {
+  const next = /* @__PURE__ */ new Set();
+  for (const key of set) {
+    const remapped = remapPathKey(key, arrayPath, operation);
+    if (remapped !== null) next.add(remapped);
+  }
+  return next;
+}
+function issuePathToString(path) {
+  if (!path || path.length === 0) return "";
+  const segments = path.map((segment) => {
+    const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
+    return typeof key === "number" ? key : String(key);
+  });
+  return formatPath(segments);
+}
+function resultToFieldErrors(result) {
+  if (!result.issues) return {};
+  const errors = /* @__PURE__ */ Object.create(null);
+  for (const issue of result.issues) {
+    const path = issuePathToString(issue.path);
+    (errors[path] ??= []).push(issue.message);
+  }
+  return errors;
+}
+const HouseVendor = "wow-two-beta";
+function asNativeValidator(schema) {
+  if (schema["~standard"].vendor !== HouseVendor) return null;
+  const candidate = schema;
+  return typeof candidate.validate === "function" ? candidate : null;
+}
+function nativeResultToFieldErrors(result, resolveMessage) {
+  if (result.ok) return {};
+  const errors = /* @__PURE__ */ Object.create(null);
+  for (const issue of result.failure.issues) {
+    const path = formatPath(issue.path);
+    const message = resolveMessage ? resolveMessage({ message: issue.message, code: issue.code, params: issue.params }, path) : issue.message;
+    (errors[path] ??= []).push(message);
+  }
+  return errors;
+}
+function isThenable(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function formParseFailure(fieldErrors) {
+  return { ok: false, failure: { ...AppErrorFactory.validation(), fieldErrors } };
+}
+function parseStandardSchema(schema, values, resolveMessage) {
+  const native = asNativeValidator(schema);
+  if (native) {
+    const result = native.validate(values);
+    return result.ok ? { ok: true, value: result.value } : formParseFailure(nativeResultToFieldErrors(result, resolveMessage));
+  }
+  const convert = (result) => result.issues ? formParseFailure(resultToFieldErrors(result)) : { ok: true, value: result.value };
+  const outcome = schema["~standard"].validate(values);
+  return isThenable(outcome) ? Promise.resolve(outcome).then(convert) : convert(outcome);
+}
+function runStandardSchema(schema, values, resolveMessage) {
+  const outcome = parseStandardSchema(schema, values, resolveMessage);
+  return outcome instanceof Promise ? outcome.then((result) => result.ok ? {} : result.failure.fieldErrors) : outcome.ok ? {} : outcome.failure.fieldErrors;
+}
+function createOptionsMessageResolver(getOptions) {
+  let resolver = null;
+  let lastMessages;
+  let lastLabels;
+  return () => {
+    const { messages, labels } = getOptions();
+    if (resolver === null || messages !== lastMessages || labels !== lastLabels) {
+      lastMessages = messages;
+      lastLabels = labels;
+      resolver = createMessageResolver(messages, labels);
+    }
+    return resolver;
+  };
+}
+function createFieldApi(path, ops) {
+  const slice = computed(() => ops.getState(path));
+  return {
+    get value() {
+      return slice.value.value;
+    },
+    set value(next) {
+      ops.setValue(path, next);
+    },
+    setValue: (value) => ops.setValue(path, value),
+    onBlur: () => ops.blur(path),
+    get errors() {
+      return slice.value.errors;
+    },
+    get isDirty() {
+      return slice.value.isDirty;
+    },
+    get isTouched() {
+      return slice.value.isTouched;
+    }
+  };
+}
+function createFormStateView(getFormState) {
+  const values = computed(() => getFormState().values);
+  const isDirty = computed(() => getFormState().isDirty);
+  const isValid = computed(() => getFormState().isValid);
+  const isSubmitting = computed(() => getFormState().isSubmitting);
+  const isValidating = computed(() => getFormState().isValidating);
+  const submitError = computed(() => getFormState().submitError);
+  const isSubmitSuccessful = computed(() => getFormState().isSubmitSuccessful);
+  return {
+    get values() {
+      return values.value;
+    },
+    get isDirty() {
+      return isDirty.value;
+    },
+    get isValid() {
+      return isValid.value;
+    },
+    get isSubmitting() {
+      return isSubmitting.value;
+    },
+    get isValidating() {
+      return isValidating.value;
+    },
+    get submitError() {
+      return submitError.value;
+    },
+    get isSubmitSuccessful() {
+      return isSubmitSuccessful.value;
+    }
+  };
+}
+function createUseFormState(getFormState) {
+  return (selector, isEqual) => {
+    if (!isEqual) return computed(() => selector(getFormState()));
+    let cached = null;
+    return computed(() => {
+      const slice = selector(getFormState());
+      if (cached && isEqual(cached.slice, slice)) return cached.slice;
+      cached = { slice };
+      return slice;
+    });
+  };
+}
+function createFieldComponent(getFieldApi, isFormDisabled) {
+  const AppField = defineComponent({
+    name: "AppField",
+    props: {
+      name: { type: String, required: true },
+      // `default: undefined` on every optional boolean — Vue casts an undefaulted `Boolean` prop
+      // to `false`, which would forward "explicitly enabled" where the field meant "unset" and
+      // shadow the form-level flag below.
+      isDisabled: { type: Boolean, default: void 0 },
+      isRequired: { type: Boolean, default: void 0 },
+      isReadOnly: { type: Boolean, default: void 0 }
+    },
+    setup(props, { slots }) {
+      const field = computed(() => getFieldApi(props.name));
+      return () => h(
+        _sfc_main,
+        {
+          isInvalid: field.value.errors.length > 0,
+          errors: field.value.errors,
+          isDisabled: props.isDisabled || (isFormDisabled?.() ?? false),
+          isRequired: props.isRequired,
+          isReadOnly: props.isReadOnly
+        },
+        { default: () => slots.default?.(field.value) }
+      );
+    }
+  });
+  return AppField;
+}
+function defaultMapFieldPath(serverPath) {
+  const segments = parsePath(serverPath).map(
+    (segment) => typeof segment === "string" && segment.length > 0 ? segment.charAt(0).toLowerCase() + segment.slice(1) : segment
+  );
+  return formatPath(segments);
+}
+function toSubmitError(_error, fallbackMessage) {
+  const failure = AppErrorFactory.unexpected();
+  return fallbackMessage ? { ...failure, message: fallbackMessage } : failure;
+}
+function toIssue(entry) {
+  return typeof entry === "string" ? { message: entry } : entry;
+}
+function resolveSubmitFailure(error, mapSubmitError, mapFieldPath, isKnownField, _fallbackMessage, resolveMessage) {
+  const mapped = mapSubmitError(error);
+  const matched = /* @__PURE__ */ Object.create(null);
+  let unplaced = false;
+  for (const [serverPath, entries] of Object.entries(mapped)) {
+    const formPath = mapFieldPath(serverPath);
+    if (isKnownField(formPath)) {
+      const messages = entries.map((entry) => {
+        const issue = toIssue(entry);
+        return resolveMessage ? resolveMessage(issue, formPath) : issue.message;
+      });
+      (matched[formPath] ??= []).push(...messages);
+    } else {
+      unplaced = true;
+    }
+  }
+  const hasMatches = Object.keys(matched).length > 0;
+  return {
+    fieldErrors: matched,
+    submitError: !hasMatches || unplaced ? error : null
+  };
+}
+export {
+  createFieldComponent as a,
+  createFormStateView as b,
+  createFieldApi as c,
+  createOptionsMessageResolver as d,
+  createUseFormState as e,
+  defaultMapFieldPath as f,
+  getPath as g,
+  focusFirstInvalid as h,
+  formatPath as i,
+  hasPath as j,
+  issuePathToString as k,
+  resultToFieldErrors as l,
+  runStandardSchema as m,
+  parseStandardSchema as n,
+  mutateRows as o,
+  parsePath as p,
+  remapPathSet as q,
+  resolveSubmitFailure as r,
+  setPath as s,
+  toSubmitError as t,
+  remapPathMap as u,
+  formParseFailure as v
+};
+//# sourceMappingURL=SubmitErrors-1_5oKOb1.js.map

package/dist/chunks/SubmitErrors-1_5oKOb1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubmitErrors-1_5oKOb1.js","sources":["../../src/formsEngine/FocusFirstInvalid.ts","../../src/formsEngine/Paths.ts","../../src/formsEngine/SchemaValidation.ts","../../src/formsEngine/FormGlue.ts","../../src/formsEngine/SubmitErrors.ts"],"sourcesContent":["import { AriaAttribute } from '../foundation/dom';\n\n/*\n * Focus-first-invalid — the submit-rejection a11y hop (docs/analysis/forms-vector-next.md F-2e).\n * Contract-neutral by construction: it reads the `aria-invalid=\"true\"` the FormControlContext\n * glue stamps on every wired control, so it behaves identically on every engine adapter\n * (house, tanstack) and for client AND server errors — anything that flips a field invalid.\n * DOM order = visual order, so \"first\" matches what the user sees.\n */\n\n/**\n * Focuses the first invalid, focusable control inside `root` and returns it (`null` when\n * nothing qualifies — the form is valid, or every invalid control is disabled/hidden).\n *\n * `handleSubmit(event)` integrates this after a failed manual attempt. Imperative callers can\n * provide `focusRoot`; a focusable `[data-form-error-summary]` is its fallback. This helper\n * remains available for custom orchestration.\n */\nexport function focusFirstInvalid(root: ParentNode | null | undefined): HTMLElement | null {\n  if (!root) return null;\n  for (const candidate of root.querySelectorAll<HTMLElement>('[aria-invalid=\"true\"]')) {\n    // Disabled controls (native or ARIA widget) never take focus — skip to the next invalid one.\n    if (candidate.closest('[inert], [hidden], [aria-hidden=\"true\"]')) continue;\n    if (candidate.matches(':disabled') || candidate.getAttribute(AriaAttribute.Disabled) === 'true') continue;\n    // Focusable = in the tab order: native controls default 0; ARIA widgets need an explicit tabindex.\n    if (candidate.tabIndex < 0) continue;\n    candidate.focus();\n    // `focus()` silently no-ops on undisplayed nodes — only a verified move counts.\n    if (candidate.ownerDocument.activeElement === candidate) return candidate;\n  }\n  return null;\n}\n","/*\n * Loose string-path utilities shared by the contract pipeline and the house engine.\n * Paths use dot + index notation (`rules[0].destination`); segments are property\n * names or non-negative array indices. Deep TYPED paths are deliberately out of\n * scope — loose paths are the documented contract gap.\n */\n\n/** A parsed path segment — a property name or an array index. */\nexport type PathKey = string | number;\n\n/** An array mutation at a path — the vocabulary `AppArrayApi` compiles down to. */\nexport type ArrayOperation =\n  | { readonly kind: 'push'; readonly value: unknown }\n  | { readonly kind: 'insert'; readonly index: number; readonly value: unknown }\n  | { readonly kind: 'remove'; readonly index: number }\n  | { readonly kind: 'swap'; readonly indexA: number; readonly indexB: number }\n  | { readonly kind: 'move'; readonly fromIndex: number; readonly toIndex: number };\n\n/** Parses `'rules[0].destination'` into `['rules', 0, 'destination']`. Tolerant of empty segments; never throws. */\nexport function parsePath(path: string): ReadonlyArray<PathKey> {\n  const segments: PathKey[] = [];\n  let buffer = '';\n  let index = 0;\n  const flush = (): void => {\n    if (buffer !== '') {\n      segments.push(buffer);\n      buffer = '';\n    }\n  };\n  while (index < path.length) {\n    const char = path.charAt(index);\n    if (char === '.') {\n      flush();\n      index += 1;\n      continue;\n    }\n    if (char === '[') {\n      flush();\n      const close = path.indexOf(']', index);\n      const inner = path.slice(index + 1, close === -1 ? path.length : close);\n      const parsed = Number(inner);\n      segments.push(inner !== '' && Number.isInteger(parsed) && parsed >= 0 ? parsed : inner);\n      index = close === -1 ? path.length : close + 1;\n      continue;\n    }\n    buffer += char;\n    index += 1;\n  }\n  flush();\n  return segments;\n}\n\n/** Formats parsed segments back into the canonical string form (`['rules', 0] → 'rules[0]'`). */\nexport function formatPath(segments: ReadonlyArray<PathKey>): string {\n  let path = '';\n  for (const segment of segments) {\n    if (typeof segment === 'number') path += `[${segment}]`;\n    else path += path === '' ? segment : `.${segment}`;\n  }\n  return path;\n}\n\n/** Reads the value at a path; `undefined` when any hop is missing or non-object. */\nexport function getPath(target: unknown, path: string): unknown {\n  let current: unknown = target;\n  for (const segment of parsePath(path)) {\n    if (current === null || typeof current !== 'object') return undefined;\n    if (!Object.hasOwn(current, segment)) return undefined;\n    current = (current as Record<PropertyKey, unknown>)[segment];\n  }\n  return current;\n}\n\n/**\n * Checks structural presence of a path — used to decide whether a mapped server\n * error path \"matches a field\". Array hops require the index to be in range.\n */\nexport function hasPath(target: unknown, path: string): boolean {\n  const segments = parsePath(path);\n  if (segments.length === 0) return false;\n  let current: unknown = target;\n  for (const segment of segments) {\n    if (current === null || typeof current !== 'object') return false;\n    if (Array.isArray(current)) {\n      if (typeof segment !== 'number' || segment < 0 || segment >= current.length) return false;\n    }\n    if (!Object.hasOwn(current, segment)) return false;\n    current = (current as Record<PropertyKey, unknown>)[segment];\n  }\n  return true;\n}\n\n/** Sets the value at a path immutably — clones only the spine, keeps untouched branches by reference. */\nexport function setPath<T>(target: T, path: string, value: unknown): T {\n  const segments = parsePath(path);\n  if (segments.length === 0) return target;\n  return setAtDepth(target, segments, 0, value) as T;\n}\n\nfunction setAtDepth(current: unknown, segments: ReadonlyArray<PathKey>, depth: number, value: unknown): unknown {\n  const segment = segments[depth];\n  if (segment === undefined) return value;\n  if (typeof segment === 'number') {\n    const array: unknown[] = Array.isArray(current) ? [...(current as unknown[])] : [];\n    array[segment] = setAtDepth(array[segment], segments, depth + 1, value);\n    return array;\n  }\n  const object: Record<string, unknown> =\n    current !== null && typeof current === 'object' && !Array.isArray(current)\n      ? { ...(current as Record<string, unknown>) }\n      : {};\n  const previous = Object.hasOwn(object, segment) ? object[segment] : undefined;\n  Object.defineProperty(object, segment, {\n    value: setAtDepth(previous, segments, depth + 1, value),\n    enumerable: true,\n    configurable: true,\n    writable: true,\n  });\n  return object;\n}\n\n/** Applies an array operation to a row array in place (callers pass a fresh copy). Indices are assumed in range. */\nexport function mutateRows(rows: unknown[], operation: ArrayOperation): void {\n  switch (operation.kind) {\n    case 'push':\n      rows.push(operation.value);\n      return;\n    case 'insert':\n      rows.splice(operation.index, 0, operation.value);\n      return;\n    case 'remove':\n      rows.splice(operation.index, 1);\n      return;\n    case 'swap': {\n      const valueA = rows[operation.indexA];\n      rows[operation.indexA] = rows[operation.indexB];\n      rows[operation.indexB] = valueA;\n      return;\n    }\n    case 'move': {\n      const [moved] = rows.splice(operation.fromIndex, 1);\n      rows.splice(operation.toIndex, 0, moved);\n      return;\n    }\n  }\n}\n\n/**\n * Remaps a row index through an array operation: `null` = the entry belongs to a\n * removed row and should be dropped; otherwise the index the row now lives at.\n */\nfunction remapRowIndex(index: number, operation: ArrayOperation): number | null {\n  switch (operation.kind) {\n    case 'push':\n      return index;\n    case 'insert':\n      return index >= operation.index ? index + 1 : index;\n    case 'remove':\n      if (index === operation.index) return null;\n      return index > operation.index ? index - 1 : index;\n    case 'swap':\n      if (index === operation.indexA) return operation.indexB;\n      if (index === operation.indexB) return operation.indexA;\n      return index;\n    case 'move': {\n      const { fromIndex, toIndex } = operation;\n      if (index === fromIndex) return toIndex;\n      if (fromIndex < toIndex && index > fromIndex && index <= toIndex) return index - 1;\n      if (fromIndex > toIndex && index >= toIndex && index < fromIndex) return index + 1;\n      return index;\n    }\n  }\n}\n\n/**\n * Remaps a single row-scoped path key (`rules[1].destination`) through an array\n * operation at `arrayPath`. Returns the key unchanged when it does not sit under\n * a row of that array, or `null` when its row was removed.\n */\nexport function remapPathKey(key: string, arrayPath: string, operation: ArrayOperation): string | null {\n  const keySegments = parsePath(key);\n  const arraySegments = parsePath(arrayPath);\n  if (keySegments.length <= arraySegments.length) return key;\n  for (let index = 0; index < arraySegments.length; index += 1) {\n    if (keySegments[index] !== arraySegments[index]) return key;\n  }\n  const rowIndex = keySegments[arraySegments.length];\n  if (typeof rowIndex !== 'number') return key;\n  const remapped = remapRowIndex(rowIndex, operation);\n  if (remapped === null) return null;\n  if (remapped === rowIndex) return key;\n  const nextSegments = [...keySegments];\n  nextSegments[arraySegments.length] = remapped;\n  return formatPath(nextSegments);\n}\n\n/** Remaps every row-scoped key of an error map through an array operation; removed-row entries drop. */\nexport function remapPathMap(\n  map: Readonly<Record<string, ReadonlyArray<string>>>,\n  arrayPath: string,\n  operation: ArrayOperation,\n): Readonly<Record<string, ReadonlyArray<string>>> {\n  const next: Record<string, ReadonlyArray<string>> = Object.create(null);\n  for (const [key, messages] of Object.entries(map)) {\n    const remapped = remapPathKey(key, arrayPath, operation);\n    if (remapped !== null) next[remapped] = messages;\n  }\n  return next;\n}\n\n/** Remaps every row-scoped member of a touched set through an array operation; removed-row entries drop. */\nexport function remapPathSet(\n  set: ReadonlySet<string>,\n  arrayPath: string,\n  operation: ArrayOperation,\n): ReadonlySet<string> {\n  const next = new Set<string>();\n  for (const key of set) {\n    const remapped = remapPathKey(key, arrayPath, operation);\n    if (remapped !== null) next.add(remapped);\n  }\n  return next;\n}\n","import { AppErrorFactory, type AppError, type Result } from '../foundation/results';\nimport {\n  createMessageResolver,\n  type ResolveValidationMessage,\n  type ValidationMessageCatalogue,\n  type ValidatorParseResult,\n} from '../foundation/validators';\n\nimport { formatPath, type PathKey } from './Paths';\nimport type { StandardSchemaV1 } from './StandardSchema';\n\n/*\n * Whole-schema Standard Schema plumbing: run `schema['~standard'].validate` over the\n * form values and normalize failure issues to a `path → messages` map keyed by the\n * same loose string paths fields use. Root-level issues (no path) key under `''` —\n * they hold `isValid` false even though no field renders them.\n *\n * THE SPEC HAS NO SLOT FOR A RULE CODE. `StandardSchemaV1.Issue` is `{ message, path }`, so a schema's\n * machine tags are erased the moment it is read through the spec — including our own validators', which\n * carry one on every issue. That erasure is why the client could not render from a message catalogue\n * (`foundation/validators/Messages.ts`) even though the codes existed all along.\n *\n * SO A HOUSE VALIDATOR IS READ NATIVELY. When the schema reports our vendor, `validate()` is called\n * directly for the un-erased result, and its codes reach the catalogue. Detection is a string compare on\n * `['~standard'].vendor` plus a shape probe — deliberately NOT an `instanceof Validator`, which would\n * pull the validator slice's runtime into this bundle for every consumer, including the ones on zod.\n * A third-party spec schema takes the plain path and renders its own messages, exactly as before.\n */\n\n/** Normalizes a spec issue path (`PropertyKey | { key }` segments) to the canonical string form. */\nexport function issuePathToString(path: StandardSchemaV1.Issue['path']): string {\n  if (!path || path.length === 0) return '';\n  const segments: ReadonlyArray<PathKey> = path.map((segment) => {\n    const key = typeof segment === 'object' && segment !== null && 'key' in segment ? segment.key : segment;\n    return typeof key === 'number' ? key : String(key);\n  });\n  return formatPath(segments);\n}\n\n/** Folds failure issues into `path → messages`; a success result yields `{}`. */\nexport function resultToFieldErrors(result: StandardSchemaV1.Result<unknown>): Record<string, ReadonlyArray<string>> {\n  if (!result.issues) return {};\n  const errors: Record<string, string[]> = Object.create(null);\n  for (const issue of result.issues) {\n    const path = issuePathToString(issue.path);\n    (errors[path] ??= []).push(issue.message);\n  }\n  return errors;\n}\n\n/** The vendor every `foundation/validators` validator reports, mirrored to keep this file runtime-free. */\nconst HouseVendor = 'wow-two-beta';\n\n/** The native surface a house validator adds to the spec — the un-erased, code-carrying result. */\ninterface NativeValidator {\n  readonly validate: (value: unknown) => ValidatorParseResult<unknown>;\n}\n\n/** Detects a house validator by its reported vendor plus the native `validate` it adds to the spec. */\nfunction asNativeValidator(schema: StandardSchemaV1<object, unknown>): NativeValidator | null {\n  if (schema['~standard'].vendor !== HouseVendor) return null;\n  const candidate = schema as unknown as Partial<NativeValidator>;\n  return typeof candidate.validate === 'function' ? (candidate as NativeValidator) : null;\n}\n\n/** Folds a native house result into `path → messages`, rendering each issue through the catalogue. */\nfunction nativeResultToFieldErrors(\n  result: ValidatorParseResult<unknown>,\n  resolveMessage?: ResolveValidationMessage,\n): Record<string, ReadonlyArray<string>> {\n  if (result.ok) return {};\n  const errors: Record<string, string[]> = Object.create(null);\n  for (const issue of result.failure.issues) {\n    const path = formatPath(issue.path as ReadonlyArray<PathKey>);\n    const message = resolveMessage\n      ? resolveMessage({ message: issue.message, code: issue.code, params: issue.params }, path)\n      : issue.message;\n    (errors[path] ??= []).push(message);\n  }\n  return errors;\n}\n\nfunction isThenable(value: unknown): value is PromiseLike<unknown> {\n  return value !== null && typeof value === 'object' && typeof (value as { then?: unknown }).then === 'function';\n}\n\n/**\n * Validates `values` against a Standard Schema. Sync schemas resolve synchronously\n * (no promise tick between a change and its errors); async schemas return a promise —\n * the engine's `isValidating` covers them.\n *\n * `resolveMessage` renders a house validator's issues through the form's message catalogue; it has no\n * effect on a third-party spec schema, whose codes the spec already erased.\n */\n/** A schema result retaining parsed output alongside display-ready field errors. */\nexport type FormParseResult<TOutput> = Result<\n  TOutput,\n  AppError & { readonly fieldErrors: Record<string, ReadonlyArray<string>> }\n>;\n\n/** Normalizes failed parsing to the shared result contract. */\nexport function formParseFailure(fieldErrors: Record<string, ReadonlyArray<string>>): FormParseResult<never> {\n  return { ok: false, failure: { ...AppErrorFactory.validation(), fieldErrors } };\n}\n\n/** Parses the editing snapshot once, preserving the Standard Schema output protocol. */\nexport function parseStandardSchema<TValues extends object, TOutput>(\n  schema: StandardSchemaV1<TValues, TOutput>,\n  values: TValues,\n  resolveMessage?: ResolveValidationMessage,\n): FormParseResult<TOutput> | Promise<FormParseResult<TOutput>> {\n  const native = asNativeValidator(schema);\n  if (native) {\n    const result = native.validate(values);\n    return result.ok\n      ? { ok: true, value: result.value as TOutput }\n      : formParseFailure(nativeResultToFieldErrors(result, resolveMessage));\n  }\n  const convert = (result: StandardSchemaV1.Result<TOutput>): FormParseResult<TOutput> =>\n    result.issues ? formParseFailure(resultToFieldErrors(result)) : { ok: true, value: result.value };\n  const outcome = schema['~standard'].validate(values);\n  return isThenable(outcome) ? Promise.resolve(outcome).then(convert) : convert(outcome);\n}\n\n/** Validates a schema for display-only callers that do not consume parsed output. */\nexport function runStandardSchema<TValues extends object, TOutput = TValues>(\n  schema: StandardSchemaV1<TValues, TOutput>,\n  values: TValues,\n  resolveMessage?: ResolveValidationMessage,\n): Record<string, ReadonlyArray<string>> | Promise<Record<string, ReadonlyArray<string>>> {\n  const outcome = parseStandardSchema(schema, values, resolveMessage);\n  return outcome instanceof Promise\n    ? outcome.then((result) => (result.ok ? {} : result.failure.fieldErrors))\n    : outcome.ok\n      ? {}\n      : outcome.failure.fieldErrors;\n}\n\n/** The options an adapter reads a message resolver from — the `messages` / `labels` cluster alone. */\ninterface MessageOptions {\n  readonly messages?: ValidationMessageCatalogue;\n  readonly labels?: Readonly<Record<string, string>>;\n}\n\n/**\n * Memoizes the form's message resolver against the identity of its `messages` / `labels` options —\n * an adapter calls this on every validation run and every submit failure, and `createMessageResolver`\n * merges a table over the defaults each time it is called. Shared by both in-repo adapters; an\n * adapter author wanting the catalogue wires this once and passes the result to `runStandardSchema` and\n * `resolveSubmitFailure`.\n */\nexport function createOptionsMessageResolver(getOptions: () => MessageOptions): () => ResolveValidationMessage {\n  let resolver: ResolveValidationMessage | null = null;\n  let lastMessages: ValidationMessageCatalogue | undefined;\n  let lastLabels: Readonly<Record<string, string>> | undefined;\n\n  return () => {\n    const { messages, labels } = getOptions();\n    if (resolver === null || messages !== lastMessages || labels !== lastLabels) {\n      lastMessages = messages;\n      lastLabels = labels;\n      resolver = createMessageResolver(messages, labels);\n    }\n    return resolver;\n  };\n}\n","import { computed, defineComponent, h, type Ref } from 'vue';\n\n// The one primitive this entry needs, imported from its own folder rather than the `primitives`\n// barrel: the barrel makes every other primitive's dependency (`@floating-ui/vue`) REACHABLE from\n// the zero-peer `/forms-engine` entry, and a promise that rests on a bundler's tree-shaking is a\n// weaker promise than one the import graph makes on its own.\nimport { FormControlProvider } from '../foundation/primitives/formControlContext';\n\nimport type { AppFieldApi, AppFieldComponent, AppFormState } from './AppForm';\n\n/*\n * Engine-free `Field` glue — adapters feed their per-field accessor in, apps get an identical\n * component back regardless of engine. `Field` always mounts a `FormControlProvider`\n * (foundation) with `isInvalid`, the merged `errors`, and the per-mode flags, so every SDK\n * control that reads `useFormControl()` auto-wires aria unmodified — and the presentation\n * `Field` / `FormErrorMessage` composed inside the slot ADOPT this provider (no second\n * provider, no `:error=\"f.errors[0]\"` hand-wiring): label/helper/error chrome renders straight\n * from the context. Boundaries: this module never imports presentation — the chrome side of the\n * seam is the foundation `FormControlContext` alone.\n *\n * Whole-form subscription runs through `form.state` / `form.values` (see `AppForm.ts`); `Field`\n * stays a component because `provide()` requires one. This module also carries the three\n * live-getter factories BOTH adapters build their reactive surface from, engine-free: a getter\n * reads the engine's `shallowRef` and whoever reads the getter is subscribed.\n *\n * Authored as `defineComponent` + `h` in plain `.ts`, not an SFC: the glue renders no markup of\n * its own, and runtime props sidestep the SFC type resolver entirely.\n */\n\n/** The per-field read slice an engine hands back — both adapters' internal field states satisfy it. */\nexport interface FieldSlice {\n  readonly value: unknown;\n  readonly errors: ReadonlyArray<string>;\n  readonly isDirty: boolean;\n  readonly isTouched: boolean;\n}\n\n/** The per-field write seam an engine hands in. */\nexport interface FieldOps {\n  readonly getState: (path: string) => FieldSlice;\n  readonly setValue: (path: string, value: unknown) => void;\n  readonly blur: (path: string) => void;\n}\n\n/**\n * Builds one path's field API — every member a live getter, so a read inside a template /\n * `computed` subscribes to exactly that field. `value` is writable, which is what makes\n * `v-model=\"field.value\"` bind a control with no handler.\n *\n * EVERY READ GOES THROUGH ONE `computed`, and that is what makes the subscription per-FIELD rather\n * than per-form. An engine commits by replacing one state object, so a raw getter would wake every\n * reader in the form on any commit — the \"form-wide re-render\" the contract exists to avoid. A\n * `computed` only notifies when its value changes, and `ops.getState` hands back the SAME slice\n * object while nothing about the field moved (both engines cache per-path identity), so a control\n * re-renders on its own edits and sits still through everyone else's.\n *\n * Adapters memoize this per path: the object identity is then stable across commits, so a slot\n * payload does not churn.\n */\nexport function createFieldApi(path: string, ops: FieldOps): AppFieldApi<unknown> {\n  const slice = computed(() => ops.getState(path));\n  return {\n    get value() {\n      return slice.value.value;\n    },\n    set value(next: unknown) {\n      ops.setValue(path, next);\n    },\n    setValue: (value: unknown) => ops.setValue(path, value),\n    onBlur: () => ops.blur(path),\n    get errors() {\n      return slice.value.errors;\n    },\n    get isDirty() {\n      return slice.value.isDirty;\n    },\n    get isTouched() {\n      return slice.value.isTouched;\n    },\n  };\n}\n\n/**\n * Builds the `form.state` view — live getters, each backed by its OWN `computed`, so a reader of\n * `state.isSubmitting` wakes when that flag flips and stays asleep through every unrelated commit.\n * `values` is one computed too: it re-emits when the values object is replaced (any field write),\n * which is the granularity a whole-values read can have — narrow further with a `computed` of your\n * own, or with `form.useFormState`.\n */\nexport function createFormStateView<TValues extends object>(\n  getFormState: () => AppFormState<TValues>,\n): AppFormState<TValues> {\n  const values = computed(() => getFormState().values);\n  const isDirty = computed(() => getFormState().isDirty);\n  const isValid = computed(() => getFormState().isValid);\n  const isSubmitting = computed(() => getFormState().isSubmitting);\n  const isValidating = computed(() => getFormState().isValidating);\n  const submitError = computed(() => getFormState().submitError);\n  const isSubmitSuccessful = computed(() => getFormState().isSubmitSuccessful);\n  return {\n    get values() {\n      return values.value;\n    },\n    get isDirty() {\n      return isDirty.value;\n    },\n    get isValid() {\n      return isValid.value;\n    },\n    get isSubmitting() {\n      return isSubmitting.value;\n    },\n    get isValidating() {\n      return isValidating.value;\n    },\n    get submitError() {\n      return submitError.value;\n    },\n    get isSubmitSuccessful() {\n      return isSubmitSuccessful.value;\n    },\n  };\n}\n\n/**\n * Builds `form.useFormState` — a selected slice as a `Ref`. Without `isEqual` it is a plain\n * `computed`. With one, the previous slice is HELD when the comparison says nothing changed:\n * `computed` only ever compares with `Object.is`, so a composite selector (`() => ({a, b})`)\n * would otherwise hand every downstream effect a fresh object on every store commit.\n */\nexport function createUseFormState<TValues extends object>(getFormState: () => AppFormState<TValues>) {\n  return <TSlice>(\n    selector: (state: AppFormState<TValues>) => TSlice,\n    isEqual?: (a: TSlice, b: TSlice) => boolean,\n  ): Readonly<Ref<TSlice>> => {\n    if (!isEqual) return computed(() => selector(getFormState()));\n    let cached: { slice: TSlice } | null = null;\n    return computed(() => {\n      const slice = selector(getFormState());\n      if (cached && isEqual(cached.slice, slice)) return cached.slice;\n      cached = { slice };\n      return slice;\n    });\n  };\n}\n\n/**\n * Builds the `form.Field` component from an adapter's per-field accessor.\n * `getFieldApi(path)` returns a live-getter API object for that path — the adapter memoizes it\n * per path, so a slot payload keeps its identity across commits. `isFormDisabled` (optional)\n * reads the whole-form `isDisabled` option per render and ORs it into every field's\n * control-disabled flag — the lowest-leverage read-only / role-locked path.\n */\nexport function createFieldComponent<TValues extends object>(\n  getFieldApi: (path: string) => AppFieldApi<unknown>,\n  isFormDisabled?: () => boolean,\n): AppFieldComponent<TValues> {\n  const AppField = defineComponent({\n    name: 'AppField',\n    props: {\n      name: { type: String, required: true },\n      // `default: undefined` on every optional boolean — Vue casts an undefaulted `Boolean` prop\n      // to `false`, which would forward \"explicitly enabled\" where the field meant \"unset\" and\n      // shadow the form-level flag below.\n      isDisabled: { type: Boolean, default: undefined },\n      isRequired: { type: Boolean, default: undefined },\n      isReadOnly: { type: Boolean, default: undefined },\n    },\n    setup(props, { slots }) {\n      // Recomputed only when the bound path changes; the API's own getters carry the reactivity.\n      const field = computed(() => getFieldApi(props.name));\n      return () =>\n        h(\n          FormControlProvider,\n          {\n            isInvalid: field.value.errors.length > 0,\n            errors: field.value.errors,\n            isDisabled: props.isDisabled || (isFormDisabled?.() ?? false),\n            isRequired: props.isRequired,\n            isReadOnly: props.isReadOnly,\n          },\n          { default: () => slots.default?.(field.value) },\n        );\n    },\n  });\n\n  // `defineComponent`'s inferred type is the runtime-props one; the contract's constructor shape\n  // is what gives a consumer `TPath`-narrowed slot payloads.\n  return AppField as unknown as AppFieldComponent<TValues>;\n}\n","import { AppErrorFactory, type AppError } from '../foundation/results';\nimport type { FieldIssue, ResolveValidationMessage } from '../foundation/validators';\n\nimport { formatPath, parsePath } from './Paths';\n\n/*\n * Server-error → form wiring shared by every adapter (R5): map a thrown submit error\n * to `path → issues` (default: `foundation/http` `fieldIssues`, both .NET shapes),\n * rewrite each server path onto a form path, land matches on fields, and coerce the\n * remainder into the form-level `submitError`.\n *\n * WHY ENTRIES ARE `string | FieldIssue`: the default mapper now keeps each failure's rule code, so a\n * message catalogue can re-render it in the client's voice (`foundation/validators/Messages.ts`). A\n * custom `mapSubmitError` that still returns plain strings stays valid — a string is read as a\n * code-less issue, which resolves to itself. Adopting the catalogue is therefore additive at every\n * call site, and a form that ignores it behaves exactly as it did before.\n */\n\n/** One mapped failure: a bare message, or the wide form carrying its rule code and operands. */\nexport type SubmitFieldEntry = string | FieldIssue;\n\n/** What a `mapSubmitError` returns — server path → its failures. */\nexport type SubmitErrorMap = Record<string, ReadonlyArray<SubmitFieldEntry>>;\n\n/** Rewrites a server error path onto a form path, camelCasing each property segment. */\nexport function defaultMapFieldPath(serverPath: string): string {\n  const segments = parsePath(serverPath).map((segment) =>\n    typeof segment === 'string' && segment.length > 0 ? segment.charAt(0).toLowerCase() + segment.slice(1) : segment,\n  );\n  return formatPath(segments);\n}\n\n/** Converts unexpected delegate throws into a safe failure without rendering exception text. */\nexport function toSubmitError(_error: unknown, fallbackMessage?: string): AppError {\n  const failure = AppErrorFactory.unexpected();\n  return fallbackMessage ? { ...failure, message: fallbackMessage } : failure;\n}\n\n/** The outcome of resolving a thrown submit error: per-field server errors + the form-level remainder. */\nexport interface SubmitFailureResolution {\n  /** Mapped messages whose form path matched a field — apply as the server-error overlay. */\n  readonly fieldErrors: Record<string, ReadonlyArray<string>>;\n  /** The coerced failure when fields did not fully represent it; `null` when every mapped path landed. */\n  readonly submitError: AppError | null;\n}\n\n/** Widens a mapped entry to the issue shape — a bare string is a failure that reported no rule code. */\nfunction toIssue(entry: SubmitFieldEntry): FieldIssue {\n  return typeof entry === 'string' ? { message: entry } : entry;\n}\n\n/**\n * Resolves a thrown submit error: `mapSubmitError` → `mapFieldPath` per entry →\n * partition by `isKnownField`. Matches become field errors; if nothing matched — or\n * some messages could not be placed — the coerced error also lands in `submitError`\n * so no server message silently disappears.\n *\n * `resolveMessage` renders each failure through the form's message catalogue\n * (`createMessageResolver`); omitted, every failure renders the message the server sent. Resolution\n * runs AFTER the path rewrite, so a catalogue entry sees the form path its label is keyed by.\n */\nexport function resolveSubmitFailure(\n  error: AppError,\n  mapSubmitError: (error: unknown) => SubmitErrorMap,\n  mapFieldPath: (serverPath: string) => string,\n  isKnownField: (path: string) => boolean,\n  _fallbackMessage?: string,\n  resolveMessage?: ResolveValidationMessage,\n): SubmitFailureResolution {\n  const mapped = mapSubmitError(error);\n  const matched: Record<string, string[]> = Object.create(null);\n  let unplaced = false;\n  for (const [serverPath, entries] of Object.entries(mapped)) {\n    const formPath = mapFieldPath(serverPath);\n    if (isKnownField(formPath)) {\n      const messages = entries.map((entry) => {\n        const issue = toIssue(entry);\n        return resolveMessage ? resolveMessage(issue, formPath) : issue.message;\n      });\n      (matched[formPath] ??= []).push(...messages);\n    } else {\n      unplaced = true;\n    }\n  }\n  const hasMatches = Object.keys(matched).length > 0;\n  return {\n    fieldErrors: matched,\n    submitError: !hasMatches || unplaced ? error : null,\n  };\n}\n"],"names":["FormControlProvider"],"mappings":"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"}

package/dist/chunks/SurfaceStyles-BYLzCbuJ.js

@@ -0,0 +1,144 @@
+import { T as Tones } from "./Tones-DSlTgkaB.js";
+import { tv } from "tailwind-variants";
+const SurfaceVariant = {
+  /** Refers to an opaque fill, no border, light shadow. */
+  Solid: "solid",
+  /** Refers to a muted/tinted fill, no border, light shadow. */
+  Soft: "soft",
+  /** Refers to an opaque fill + visible border + medium shadow. */
+  Surface: "surface",
+  /** Refers to a transparent fill + visible border. */
+  Outline: "outline",
+  /** Refers to a translucent + blur fill, no border, medium shadow. */
+  Glass: "glass",
+  /** Refers to a translucent + blur fill + subtle border. */
+  GlassOutline: "glass-outline",
+  /** Refers to an opaque fill, no border, heavy shadow. */
+  Elevated: "elevated",
+  /** Refers to an opaque fill, no border, no shadow. */
+  Flat: "flat",
+  /** Refers to a low-alpha tinted fill + neutral border, no shadow. */
+  Subtle: "subtle"
+};
+const surfaceVariants = tv({
+  base: "outline-hidden transition-colors",
+  variants: {
+    variant: {
+      /* Opaque fill, no border, light shadow — tooltips, chips, inline pills. */
+      solid: "shadow-sm",
+      /* Muted/tinted fill, no border, light shadow — chat bubbles, inline groups. */
+      soft: "shadow-sm",
+      /* Opaque fill + visible border + medium shadow — default for popovers/menus. */
+      surface: "border shadow-md",
+      /* Transparent fill + visible border — static cards, embedded info blocks. */
+      outline: "border bg-transparent",
+      /* Translucent + blur, no border, medium shadow — image overlays. */
+      glass: "backdrop-blur-md shadow-md",
+      /* Translucent + blur + subtle border — premium / hero overlays. */
+      "glass-outline": "border backdrop-blur-md shadow-md",
+      /* Opaque fill, no border, heavy shadow — modals, drawers, command palette. */
+      elevated: "shadow-xl",
+      /* Opaque fill, no border, no shadow — embedded sub-panels inside another surface. */
+      flat: "",
+      /* Low-alpha tinted fill + neutral border, no shadow — section bands, tinted panels. */
+      subtle: "border"
+    },
+    tone: { neutral: "", primary: "", danger: "", success: "", warning: "", info: "" },
+    radius: {
+      none: "rounded-none",
+      sm: "rounded-sm",
+      md: "rounded-md",
+      lg: "rounded-lg",
+      xl: "rounded-xl",
+      "2xl": "rounded-2xl",
+      full: "rounded-full"
+    },
+    padding: {
+      none: "p-0",
+      xs: "p-1",
+      sm: "p-2",
+      md: "p-3",
+      lg: "p-4",
+      xl: "p-6",
+      "2xl": "p-8"
+    },
+    /* Optional shadow override — beats variant's default shadow via tailwind-merge precedence. */
+    elevation: {
+      0: "shadow-none",
+      1: "shadow-sm",
+      2: "shadow-md",
+      3: "shadow-lg",
+      4: "shadow-xl",
+      5: "shadow-2xl"
+    },
+    /* Optional ambient gradient overlay — layers over the variant's bg-color. Dark-leaning: `sheen` lifts
+     * the top edge (≈ invisible on light), `glow` adds a primary-tinted corner wash. */
+    ambient: {
+      none: "",
+      sheen: "surface-sheen",
+      glow: "surface-glow"
+    }
+  },
+  compoundVariants: [
+    /* solid / elevated / flat share the same palette — opaque tone bg + tone foreground. */
+    { variant: ["solid", "elevated", "flat"], tone: "neutral", class: Tones.solid.neutral },
+    { variant: ["solid", "elevated", "flat"], tone: "primary", class: Tones.solid.primary },
+    { variant: ["solid", "elevated", "flat"], tone: "danger", class: Tones.solid.danger },
+    { variant: ["solid", "elevated", "flat"], tone: "success", class: Tones.solid.success },
+    { variant: ["solid", "elevated", "flat"], tone: "warning", class: Tones.solid.warning },
+    { variant: ["solid", "elevated", "flat"], tone: "info", class: Tones.solid.info },
+    /* soft — muted/tinted bg, tone-readable text. */
+    { variant: "soft", tone: "neutral", class: Tones.soft.neutral },
+    { variant: "soft", tone: "primary", class: Tones.soft.primary },
+    { variant: "soft", tone: "danger", class: Tones.soft.danger },
+    { variant: "soft", tone: "success", class: Tones.soft.success },
+    { variant: "soft", tone: "warning", class: Tones.soft.warning },
+    { variant: "soft", tone: "info", class: Tones.soft.info },
+    /* surface — popover bg + tone-accent border. */
+    { variant: "surface", tone: "neutral", class: Tones.surface.neutral },
+    { variant: "surface", tone: "primary", class: Tones.surface.primary },
+    { variant: "surface", tone: "danger", class: Tones.surface.danger },
+    { variant: "surface", tone: "success", class: Tones.surface.success },
+    { variant: "surface", tone: "warning", class: Tones.surface.warning },
+    { variant: "surface", tone: "info", class: Tones.surface.info },
+    /* outline — transparent fill, tone border + tone text. */
+    { variant: "outline", tone: "neutral", class: Tones.outline.neutral },
+    { variant: "outline", tone: "primary", class: Tones.outline.primary },
+    { variant: "outline", tone: "danger", class: Tones.outline.danger },
+    { variant: "outline", tone: "success", class: Tones.outline.success },
+    { variant: "outline", tone: "warning", class: Tones.outline.warning },
+    { variant: "outline", tone: "info", class: Tones.outline.info },
+    /* glass — translucent tinted fill + blur. */
+    { variant: "glass", tone: "neutral", class: Tones.glass.neutral },
+    { variant: "glass", tone: "primary", class: Tones.glass.primary },
+    { variant: "glass", tone: "danger", class: Tones.glass.danger },
+    { variant: "glass", tone: "success", class: Tones.glass.success },
+    { variant: "glass", tone: "warning", class: Tones.glass.warning },
+    { variant: "glass", tone: "info", class: Tones.glass.info },
+    /* glass-outline — glass + tone border at 50% alpha. */
+    { variant: "glass-outline", tone: "neutral", class: Tones.glassOutline.neutral },
+    { variant: "glass-outline", tone: "primary", class: Tones.glassOutline.primary },
+    { variant: "glass-outline", tone: "danger", class: Tones.glassOutline.danger },
+    { variant: "glass-outline", tone: "success", class: Tones.glassOutline.success },
+    { variant: "glass-outline", tone: "warning", class: Tones.glassOutline.warning },
+    { variant: "glass-outline", tone: "info", class: Tones.glassOutline.info },
+    /* subtle — low-alpha tinted fill + neutral border, no shadow. */
+    { variant: "subtle", tone: "neutral", class: Tones.subtle.neutral },
+    { variant: "subtle", tone: "primary", class: Tones.subtle.primary },
+    { variant: "subtle", tone: "danger", class: Tones.subtle.danger },
+    { variant: "subtle", tone: "success", class: Tones.subtle.success },
+    { variant: "subtle", tone: "warning", class: Tones.subtle.warning },
+    { variant: "subtle", tone: "info", class: Tones.subtle.info }
+  ],
+  defaultVariants: {
+    variant: "surface",
+    tone: "neutral",
+    radius: "md",
+    padding: "none"
+  }
+});
+export {
+  SurfaceVariant as S,
+  surfaceVariants as s
+};
+//# sourceMappingURL=SurfaceStyles-BYLzCbuJ.js.map