@wow-two-beta/ui-vue 0.0.2

package/dist/chunks/SubmitErrors-K8nmmj0P.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubmitErrors-K8nmmj0P.js","sources":["../../src/forms-engine/FormGlue.ts","../../src/forms-engine/Paths.ts","../../src/forms-engine/SchemaValidation.ts","../../src/forms-engine/SubmitErrors.ts"],"sourcesContent":["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 * `createSubscribeComponent` has no Vue counterpart — the render-prop subscription it built is\n * what `form.state` / `form.values` replace (see `AppForm.ts`). `Field` stays a component\n * because `provide()` requires one. In its place this module carries the three live-getter\n * factories BOTH adapters build their reactive surface from — the work React's per-adapter\n * `useEngineField` / `useEngineSlice` hooks did, now engine-free because there is no hook\n * involved: a getter 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: readonly 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. It is the bail-out React got\n * from `useSyncExternalStore`'s selector cache, in one line.\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","/*\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): readonly 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: readonly 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    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    } else if (!(String(segment) in current)) {\n      return false;\n    }\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: readonly 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  object[segment] = setAtDepth(object[segment], segments, depth + 1, value);\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, readonly string[]>>,\n  arrayPath: string,\n  operation: ArrayOperation,\n): Readonly<Record<string, readonly string[]>> {\n  const next: Record<string, readonly string[]> = {};\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(set: ReadonlySet<string>, arrayPath: string, operation: ArrayOperation): 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 {\n  createMessageResolver,\n  type ResolveValidationMessage,\n  type ValidationMessageCatalogue,\n  type ValidationResult,\n} from '../foundation/validation';\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/validation/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: 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, string[]> {\n  if (!result.issues) return {};\n  const errors: Record<string, string[]> = {};\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/validation` validator reports — mirrored, not imported, to keep this file runtime-free of that slice. */\nconst HOUSE_VENDOR = '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) => ValidationResult<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>): NativeValidator | null {\n  if (schema['~standard'].vendor !== HOUSE_VENDOR) 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: ValidationResult<unknown>,\n  resolveMessage?: ResolveValidationMessage,\n): Record<string, string[]> {\n  if (result.valid) return {};\n  const errors: Record<string, string[]> = {};\n  for (const issue of result.issues) {\n    const path = formatPath(issue.path as readonly 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 (\n    value !== null &&\n    typeof value === 'object' &&\n    typeof (value as { then?: unknown }).then === 'function'\n  );\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 */\nexport function runStandardSchema<TValues extends object>(\n  schema: StandardSchemaV1<TValues>,\n  values: TValues,\n  resolveMessage?: ResolveValidationMessage,\n): Record<string, string[]> | Promise<Record<string, string[]>> {\n  const native = asNativeValidator(schema);\n  // House validators are always synchronous (`Validator.ts` — a form gets its errors in the same tick\n  // as the change that caused them), so this arm never needs the promise branch below.\n  if (native) return nativeResultToFieldErrors(native.validate(values), resolveMessage);\n\n  const outcome = schema['~standard'].validate(values);\n  if (isThenable(outcome)) {\n    return Promise.resolve(outcome).then(resultToFieldErrors);\n  }\n  return resultToFieldErrors(outcome);\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(\n  getOptions: () => MessageOptions,\n): () => 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 { ApiError } from '../foundation/http';\nimport type { FieldIssue, ResolveValidationMessage } from '../foundation/validation';\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/validation/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, readonly SubmitFieldEntry[]>;\n\n/** Rewrites a server error path onto a form path — camelCase per property segment (`Rules[0].Destination` → `rules[0].destination`). */\nexport function defaultMapFieldPath(serverPath: string): string {\n  const segments = parsePath(serverPath).map((segment) =>\n    typeof segment === 'string' && segment.length > 0\n      ? segment.charAt(0).toLowerCase() + segment.slice(1)\n      : segment,\n  );\n  return formatPath(segments);\n}\n\n/**\n * Coerces any thrown value into the SDK `ApiError` — passes through an `ApiError`, wraps\n * everything else as status `0` (mirrors `/query`'s coercion). `fallbackMessage` is the\n * message for a throw that carries none of its own (not an `ApiError`, `Error`, or string) —\n * overridable for i18n; defaults to the English `'Unknown error'`.\n */\nexport function toApiError(error: unknown, fallbackMessage = 'Unknown error'): ApiError {\n  if (error instanceof ApiError) return error;\n  if (error instanceof Error) return new ApiError(0, null, error.message);\n  return new ApiError(0, null, typeof error === 'string' ? error : fallbackMessage);\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, string[]>;\n  /** The coerced failure when it was not fully represented on fields (no or partial path matches); `null` when every mapped path landed. */\n  readonly submitError: ApiError | 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: unknown,\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[]> = {};\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 ? toApiError(error, fallbackMessage) : null,\n  };\n}\n"],"names":["FormControlProvider"],"mappings":";;;;AA8DO,SAAS,eAAe,MAAc,KAAqC;AAChF,QAAM,QAAQ,SAAS,MAAM,IAAI,SAAS,IAAI,CAAC;AAC/C,SAAO;AAAA,IACL,IAAI,QAAQ;AACV,aAAO,MAAM,MAAM;AAAA,IACrB;AAAA,IACA,IAAI,MAAM,MAAe;AACvB,UAAI,SAAS,MAAM,IAAI;AAAA,IACzB;AAAA,IACA,UAAU,CAAC,UAAmB,IAAI,SAAS,MAAM,KAAK;AAAA,IACtD,QAAQ,MAAM,IAAI,KAAK,IAAI;AAAA,IAC3B,IAAI,SAAS;AACX,aAAO,MAAM,MAAM;AAAA,IACrB;AAAA,IACA,IAAI,UAAU;AACZ,aAAO,MAAM,MAAM;AAAA,IACrB;AAAA,IACA,IAAI,YAAY;AACd,aAAO,MAAM,MAAM;AAAA,IACrB;AAAA,EAAA;AAEJ;AASO,SAAS,oBACd,cACuB;AACvB,QAAM,SAAS,SAAS,MAAM,aAAA,EAAe,MAAM;AACnD,QAAM,UAAU,SAAS,MAAM,aAAA,EAAe,OAAO;AACrD,QAAM,UAAU,SAAS,MAAM,aAAA,EAAe,OAAO;AACrD,QAAM,eAAe,SAAS,MAAM,aAAA,EAAe,YAAY;AAC/D,QAAM,eAAe,SAAS,MAAM,aAAA,EAAe,YAAY;AAC/D,QAAM,cAAc,SAAS,MAAM,aAAA,EAAe,WAAW;AAC7D,QAAM,qBAAqB,SAAS,MAAM,aAAA,EAAe,kBAAkB;AAC3E,SAAO;AAAA,IACL,IAAI,SAAS;AACX,aAAO,OAAO;AAAA,IAChB;AAAA,IACA,IAAI,UAAU;AACZ,aAAO,QAAQ;AAAA,IACjB;AAAA,IACA,IAAI,UAAU;AACZ,aAAO,QAAQ;AAAA,IACjB;AAAA,IACA,IAAI,eAAe;AACjB,aAAO,aAAa;AAAA,IACtB;AAAA,IACA,IAAI,eAAe;AACjB,aAAO,aAAa;AAAA,IACtB;AAAA,IACA,IAAI,cAAc;AAChB,aAAO,YAAY;AAAA,IACrB;AAAA,IACA,IAAI,qBAAqB;AACvB,aAAO,mBAAmB;AAAA,IAC5B;AAAA,EAAA;AAEJ;AAQO,SAAS,mBAA2C,cAA2C;AACpG,SAAO,CACL,UACA,YAC0B;AAC1B,QAAI,CAAC,QAAS,QAAO,SAAS,MAAM,SAAS,aAAA,CAAc,CAAC;AAC5D,QAAI,SAAmC;AACvC,WAAO,SAAS,MAAM;AACpB,YAAM,QAAQ,SAAS,cAAc;AACrC,UAAI,UAAU,QAAQ,OAAO,OAAO,KAAK,UAAU,OAAO;AAC1D,eAAS,EAAE,MAAA;AACX,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AACF;AASO,SAAS,qBACd,aACA,gBAC4B;AAC5B,QAAM,WAAW,gBAAgB;AAAA,IAC/B,MAAM;AAAA,IACN,OAAO;AAAA,MACL,MAAM,EAAE,MAAM,QAAQ,UAAU,KAAA;AAAA;AAAA;AAAA;AAAA,MAIhC,YAAY,EAAE,MAAM,SAAS,SAAS,OAAA;AAAA,MACtC,YAAY,EAAE,MAAM,SAAS,SAAS,OAAA;AAAA,MACtC,YAAY,EAAE,MAAM,SAAS,SAAS,OAAA;AAAA,IAAU;AAAA,IAElD,MAAM,OAAO,EAAE,SAAS;AAEtB,YAAM,QAAQ,SAAS,MAAM,YAAY,MAAM,IAAI,CAAC;AACpD,aAAO,MACL;AAAA,QACEA;AAAAA,QACA;AAAA,UACE,WAAW,MAAM,MAAM,OAAO,SAAS;AAAA,UACvC,QAAQ,MAAM,MAAM;AAAA,UACpB,YAAY,MAAM,eAAe,iBAAA,KAAsB;AAAA,UACvD,YAAY,MAAM;AAAA,UAClB,YAAY,MAAM;AAAA,QAAA;AAAA,QAEpB,EAAE,SAAS,MAAM,MAAM,UAAU,MAAM,KAAK,EAAA;AAAA,MAAE;AAAA,IAEpD;AAAA,EAAA,CACD;AAID,SAAO;AACT;AC7KO,SAAS,UAAU,MAAkC;AAC1D,QAAM,WAAsB,CAAA;AAC5B,MAAI,SAAS;AACb,MAAI,QAAQ;AACZ,QAAM,QAAQ,MAAY;AACxB,QAAI,WAAW,IAAI;AACjB,eAAS,KAAK,MAAM;AACpB,eAAS;AAAA,IACX;AAAA,EACF;AACA,SAAO,QAAQ,KAAK,QAAQ;AAC1B,UAAM,OAAO,KAAK,OAAO,KAAK;AAC9B,QAAI,SAAS,KAAK;AAChB,YAAA;AACA,eAAS;AACT;AAAA,IACF;AACA,QAAI,SAAS,KAAK;AAChB,YAAA;AACA,YAAM,QAAQ,KAAK,QAAQ,KAAK,KAAK;AACrC,YAAM,QAAQ,KAAK,MAAM,QAAQ,GAAG,UAAU,KAAK,KAAK,SAAS,KAAK;AACtE,YAAM,SAAS,OAAO,KAAK;AAC3B,eAAS,KAAK,UAAU,MAAM,OAAO,UAAU,MAAM,KAAK,UAAU,IAAI,SAAS,KAAK;AACtF,cAAQ,UAAU,KAAK,KAAK,SAAS,QAAQ;AAC7C;AAAA,IACF;AACA,cAAU;AACV,aAAS;AAAA,EACX;AACA,QAAA;AACA,SAAO;AACT;AAGO,SAAS,WAAW,UAAsC;AAC/D,MAAI,OAAO;AACX,aAAW,WAAW,UAAU;AAC9B,QAAI,OAAO,YAAY,SAAU,SAAQ,IAAI,OAAO;AAAA,QAC/C,SAAQ,SAAS,KAAK,UAAU,IAAI,OAAO;AAAA,EAClD;AACA,SAAO;AACT;AAGO,SAAS,QAAQ,QAAiB,MAAuB;AAC9D,MAAI,UAAmB;AACvB,aAAW,WAAW,UAAU,IAAI,GAAG;AACrC,QAAI,YAAY,QAAQ,OAAO,YAAY,SAAU,QAAO;AAC5D,cAAW,QAAyC,OAAO;AAAA,EAC7D;AACA,SAAO;AACT;AAMO,SAAS,QAAQ,QAAiB,MAAuB;AAC9D,QAAM,WAAW,UAAU,IAAI;AAC/B,MAAI,SAAS,WAAW,EAAG,QAAO;AAClC,MAAI,UAAmB;AACvB,aAAW,WAAW,UAAU;AAC9B,QAAI,YAAY,QAAQ,OAAO,YAAY,SAAU,QAAO;AAC5D,QAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,UAAI,OAAO,YAAY,YAAY,UAAU,KAAK,WAAW,QAAQ,OAAQ,QAAO;AAAA,IACtF,WAAW,EAAE,OAAO,OAAO,KAAK,UAAU;AACxC,aAAO;AAAA,IACT;AACA,cAAW,QAAyC,OAAO;AAAA,EAC7D;AACA,SAAO;AACT;AAGO,SAAS,QAAW,QAAW,MAAc,OAAmB;AACrE,QAAM,WAAW,UAAU,IAAI;AAC/B,MAAI,SAAS,WAAW,EAAG,QAAO;AAClC,SAAO,WAAW,QAAQ,UAAU,GAAG,KAAK;AAC9C;AAEA,SAAS,WAAW,SAAkB,UAA8B,OAAe,OAAyB;AAC1G,QAAM,UAAU,SAAS,KAAK;AAC9B,MAAI,YAAY,OAAW,QAAO;AAClC,MAAI,OAAO,YAAY,UAAU;AAC/B,UAAM,QAAmB,MAAM,QAAQ,OAAO,IAAI,CAAC,GAAI,OAAqB,IAAI,CAAA;AAChF,UAAM,OAAO,IAAI,WAAW,MAAM,OAAO,GAAG,UAAU,QAAQ,GAAG,KAAK;AACtE,WAAO;AAAA,EACT;AACA,QAAM,SACJ,YAAY,QAAQ,OAAO,YAAY,YAAY,CAAC,MAAM,QAAQ,OAAO,IACrE,EAAE,GAAI,QAAA,IACN,CAAA;AACN,SAAO,OAAO,IAAI,WAAW,OAAO,OAAO,GAAG,UAAU,QAAQ,GAAG,KAAK;AACxE,SAAO;AACT;AAGO,SAAS,WAAW,MAAiB,WAAiC;AAC3E,UAAQ,UAAU,MAAA;AAAA,IAChB,KAAK;AACH,WAAK,KAAK,UAAU,KAAK;AACzB;AAAA,IACF,KAAK;AACH,WAAK,OAAO,UAAU,OAAO,GAAG,UAAU,KAAK;AAC/C;AAAA,IACF,KAAK;AACH,WAAK,OAAO,UAAU,OAAO,CAAC;AAC9B;AAAA,IACF,KAAK,QAAQ;AACX,YAAM,SAAS,KAAK,UAAU,MAAM;AACpC,WAAK,UAAU,MAAM,IAAI,KAAK,UAAU,MAAM;AAC9C,WAAK,UAAU,MAAM,IAAI;AACzB;AAAA,IACF;AAAA,IACA,KAAK,QAAQ;AACX,YAAM,CAAC,KAAK,IAAI,KAAK,OAAO,UAAU,WAAW,CAAC;AAClD,WAAK,OAAO,UAAU,SAAS,GAAG,KAAK;AACvC;AAAA,IACF;AAAA,EAAA;AAEJ;AAMA,SAAS,cAAc,OAAe,WAA0C;AAC9E,UAAQ,UAAU,MAAA;AAAA,IAChB,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO,SAAS,UAAU,QAAQ,QAAQ,IAAI;AAAA,IAChD,KAAK;AACH,UAAI,UAAU,UAAU,MAAO,QAAO;AACtC,aAAO,QAAQ,UAAU,QAAQ,QAAQ,IAAI;AAAA,IAC/C,KAAK;AACH,UAAI,UAAU,UAAU,OAAQ,QAAO,UAAU;AACjD,UAAI,UAAU,UAAU,OAAQ,QAAO,UAAU;AACjD,aAAO;AAAA,IACT,KAAK,QAAQ;AACX,YAAM,EAAE,WAAW,QAAA,IAAY;AAC/B,UAAI,UAAU,UAAW,QAAO;AAChC,UAAI,YAAY,WAAW,QAAQ,aAAa,SAAS,gBAAgB,QAAQ;AACjF,UAAI,YAAY,WAAW,SAAS,WAAW,QAAQ,kBAAkB,QAAQ;AACjF,aAAO;AAAA,IACT;AAAA,EAAA;AAEJ;AAOO,SAAS,aAAa,KAAa,WAAmB,WAA0C;AACrG,QAAM,cAAc,UAAU,GAAG;AACjC,QAAM,gBAAgB,UAAU,SAAS;AACzC,MAAI,YAAY,UAAU,cAAc,OAAQ,QAAO;AACvD,WAAS,QAAQ,GAAG,QAAQ,cAAc,QAAQ,SAAS,GAAG;AAC5D,QAAI,YAAY,KAAK,MAAM,cAAc,KAAK,EAAG,QAAO;AAAA,EAC1D;AACA,QAAM,WAAW,YAAY,cAAc,MAAM;AACjD,MAAI,OAAO,aAAa,SAAU,QAAO;AACzC,QAAM,WAAW,cAAc,UAAU,SAAS;AAClD,MAAI,aAAa,KAAM,QAAO;AAC9B,MAAI,aAAa,SAAU,QAAO;AAClC,QAAM,eAAe,CAAC,GAAG,WAAW;AACpC,eAAa,cAAc,MAAM,IAAI;AACrC,SAAO,WAAW,YAAY;AAChC;AAGO,SAAS,aACd,KACA,WACA,WAC6C;AAC7C,QAAM,OAA0C,CAAA;AAChD,aAAW,CAAC,KAAK,QAAQ,KAAK,OAAO,QAAQ,GAAG,GAAG;AACjD,UAAM,WAAW,aAAa,KAAK,WAAW,SAAS;AACvD,QAAI,aAAa,KAAM,MAAK,QAAQ,IAAI;AAAA,EAC1C;AACA,SAAO;AACT;AAGO,SAAS,aAAa,KAA0B,WAAmB,WAAgD;AACxH,QAAM,2BAAW,IAAA;AACjB,aAAW,OAAO,KAAK;AACrB,UAAM,WAAW,aAAa,KAAK,WAAW,SAAS;AACvD,QAAI,aAAa,KAAM,MAAK,IAAI,QAAQ;AAAA,EAC1C;AACA,SAAO;AACT;ACvLO,SAAS,kBAAkB,MAA8C;AAC9E,MAAI,CAAC,QAAQ,KAAK,WAAW,EAAG,QAAO;AACvC,QAAM,WAAsB,KAAK,IAAI,CAAC,YAAY;AAChD,UAAM,MAAM,OAAO,YAAY,YAAY,YAAY,QAAQ,SAAS,UAAU,QAAQ,MAAM;AAChG,WAAO,OAAO,QAAQ,WAAW,MAAM,OAAO,GAAG;AAAA,EACnD,CAAC;AACD,SAAO,WAAW,QAAQ;AAC5B;AAGO,SAAS,oBAAoB,QAAoE;AACtG,MAAI,CAAC,OAAO,OAAQ,QAAO,CAAA;AAC3B,QAAM,SAAmC,CAAA;AACzC,aAAW,SAAS,OAAO,QAAQ;AACjC,UAAM,OAAO,kBAAkB,MAAM,IAAI;AACzC,KAAC,OAAO,IAAI,MAAM,CAAA,GAAI,KAAK,MAAM,OAAO;AAAA,EAC1C;AACA,SAAO;AACT;AAGA,MAAM,eAAe;AAQrB,SAAS,kBAAkB,QAA0D;AACnF,MAAI,OAAO,WAAW,EAAE,WAAW,aAAc,QAAO;AACxD,QAAM,YAAY;AAClB,SAAO,OAAO,UAAU,aAAa,aAAc,YAAgC;AACrF;AAGA,SAAS,0BACP,QACA,gBAC0B;AAC1B,MAAI,OAAO,MAAO,QAAO,CAAA;AACzB,QAAM,SAAmC,CAAA;AACzC,aAAW,SAAS,OAAO,QAAQ;AACjC,UAAM,OAAO,WAAW,MAAM,IAA0B;AACxD,UAAM,UAAU,iBACZ,eAAe,EAAE,SAAS,MAAM,SAAS,MAAM,MAAM,MAAM,QAAQ,MAAM,OAAA,GAAU,IAAI,IACvF,MAAM;AACV,KAAC,OAAO,IAAI,MAAM,CAAA,GAAI,KAAK,OAAO;AAAA,EACpC;AACA,SAAO;AACT;AAEA,SAAS,WAAW,OAA+C;AACjE,SACE,UAAU,QACV,OAAO,UAAU,YACjB,OAAQ,MAA6B,SAAS;AAElD;AAUO,SAAS,kBACd,QACA,QACA,gBAC8D;AAC9D,QAAM,SAAS,kBAAkB,MAAM;AAGvC,MAAI,OAAQ,QAAO,0BAA0B,OAAO,SAAS,MAAM,GAAG,cAAc;AAEpF,QAAM,UAAU,OAAO,WAAW,EAAE,SAAS,MAAM;AACnD,MAAI,WAAW,OAAO,GAAG;AACvB,WAAO,QAAQ,QAAQ,OAAO,EAAE,KAAK,mBAAmB;AAAA,EAC1D;AACA,SAAO,oBAAoB,OAAO;AACpC;AAeO,SAAS,6BACd,YACgC;AAChC,MAAI,WAA4C;AAChD,MAAI;AACJ,MAAI;AAEJ,SAAO,MAAM;AACX,UAAM,EAAE,UAAU,OAAA,IAAW,WAAA;AAC7B,QAAI,aAAa,QAAQ,aAAa,gBAAgB,WAAW,YAAY;AAC3E,qBAAe;AACf,mBAAa;AACb,iBAAW,sBAAsB,UAAU,MAAM;AAAA,IACnD;AACA,WAAO;AAAA,EACT;AACF;ACtHO,SAAS,oBAAoB,YAA4B;AAC9D,QAAM,WAAW,UAAU,UAAU,EAAE;AAAA,IAAI,CAAC,YAC1C,OAAO,YAAY,YAAY,QAAQ,SAAS,IAC5C,QAAQ,OAAO,CAAC,EAAE,YAAA,IAAgB,QAAQ,MAAM,CAAC,IACjD;AAAA,EAAA;AAEN,SAAO,WAAW,QAAQ;AAC5B;AAQO,SAAS,WAAW,OAAgB,kBAAkB,iBAA2B;AACtF,MAAI,iBAAiB,SAAU,QAAO;AACtC,MAAI,iBAAiB,MAAO,QAAO,IAAI,SAAS,GAAG,MAAM,MAAM,OAAO;AACtE,SAAO,IAAI,SAAS,GAAG,MAAM,OAAO,UAAU,WAAW,QAAQ,eAAe;AAClF;AAWA,SAAS,QAAQ,OAAqC;AACpD,SAAO,OAAO,UAAU,WAAW,EAAE,SAAS,UAAU;AAC1D;AAYO,SAAS,qBACd,OACA,gBACA,cACA,cACA,iBACA,gBACyB;AACzB,QAAM,SAAS,eAAe,KAAK;AACnC,QAAM,UAAoC,CAAA;AAC1C,MAAI,WAAW;AACf,aAAW,CAAC,YAAY,OAAO,KAAK,OAAO,QAAQ,MAAM,GAAG;AAC1D,UAAM,WAAW,aAAa,UAAU;AACxC,QAAI,aAAa,QAAQ,GAAG;AAC1B,YAAM,WAAW,QAAQ,IAAI,CAAC,UAAU;AACtC,cAAM,QAAQ,QAAQ,KAAK;AAC3B,eAAO,iBAAiB,eAAe,OAAO,QAAQ,IAAI,MAAM;AAAA,MAClE,CAAC;AACD,OAAC,QAAQ,QAAQ,MAAM,CAAA,GAAI,KAAK,GAAG,QAAQ;AAAA,IAC7C,OAAO;AACL,iBAAW;AAAA,IACb;AAAA,EACF;AACA,QAAM,aAAa,OAAO,KAAK,OAAO,EAAE,SAAS;AACjD,SAAO;AAAA,IACL,aAAa;AAAA,IACb,aAAa,CAAC,cAAc,WAAW,WAAW,OAAO,eAAe,IAAI;AAAA,EAAA;AAEhF;"}

package/dist/chunks/SurfaceStyles-ChdpGRBO.js

@@ -0,0 +1,143 @@
+import { T as Tones } from "./Tones-CI65uuq9.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-none 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-ChdpGRBO.js.map

package/dist/chunks/SurfaceStyles-ChdpGRBO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SurfaceStyles-ChdpGRBO.js","sources":["../../src/foundation/utils/SurfaceStyles/SurfaceStyles.ts"],"sourcesContent":["/* Provides the cross-domain surface style engine — variant × tone × radius × padding × elevation. */\n\nimport { tv, type VariantProps } from '../tv';\nimport { Tones } from '../Tones';\nimport { Tone } from '../StyleTokens';\n\n/** Defines the visual-recipe axis of a surface (solid · soft · surface · outline · glass · etc.). */\nexport const SurfaceVariant = {\n  /** Refers to an opaque fill, no border, light shadow. */\n  Solid: 'solid',\n  /** Refers to a muted/tinted fill, no border, light shadow. */\n  Soft: 'soft',\n  /** Refers to an opaque fill + visible border + medium shadow. */\n  Surface: 'surface',\n  /** Refers to a transparent fill + visible border. */\n  Outline: 'outline',\n  /** Refers to a translucent + blur fill, no border, medium shadow. */\n  Glass: 'glass',\n  /** Refers to a translucent + blur fill + subtle border. */\n  GlassOutline: 'glass-outline',\n  /** Refers to an opaque fill, no border, heavy shadow. */\n  Elevated: 'elevated',\n  /** Refers to an opaque fill, no border, no shadow. */\n  Flat: 'flat',\n  /** Refers to a low-alpha tinted fill + neutral border, no shadow. */\n  Subtle: 'subtle',\n} as const;\n\nexport type SurfaceVariant = (typeof SurfaceVariant)[keyof typeof SurfaceVariant];\n\n/** Provides the tailwind-variants config for every \"block with a visual treatment\" surface. */\nexport const surfaceVariants = tv({\n  base: 'outline-none transition-colors',\n  variants: {\n    variant: {\n      /* Opaque fill, no border, light shadow — tooltips, chips, inline pills. */\n      solid: 'shadow-sm',\n      /* Muted/tinted fill, no border, light shadow — chat bubbles, inline groups. */\n      soft: 'shadow-sm',\n      /* Opaque fill + visible border + medium shadow — default for popovers/menus. */\n      surface: 'border shadow-md',\n      /* Transparent fill + visible border — static cards, embedded info blocks. */\n      outline: 'border bg-transparent',\n      /* Translucent + blur, no border, medium shadow — image overlays. */\n      glass: 'backdrop-blur-md shadow-md',\n      /* Translucent + blur + subtle border — premium / hero overlays. */\n      'glass-outline': 'border backdrop-blur-md shadow-md',\n      /* Opaque fill, no border, heavy shadow — modals, drawers, command palette. */\n      elevated: 'shadow-xl',\n      /* Opaque fill, no border, no shadow — embedded sub-panels inside another surface. */\n      flat: '',\n      /* Low-alpha tinted fill + neutral border, no shadow — section bands, tinted panels. */\n      subtle: 'border',\n    },\n\n    tone: { neutral: '', primary: '', danger: '', success: '', warning: '', info: '' },\n\n    radius: {\n      none: 'rounded-none',\n      sm: 'rounded-sm',\n      md: 'rounded-md',\n      lg: 'rounded-lg',\n      xl: 'rounded-xl',\n      '2xl': 'rounded-2xl',\n      full: 'rounded-full',\n    },\n\n    padding: {\n      none: 'p-0',\n      xs: 'p-1',\n      sm: 'p-2',\n      md: 'p-3',\n      lg: 'p-4',\n      xl: 'p-6',\n      '2xl': 'p-8',\n    },\n\n    /* Optional shadow override — beats variant's default shadow via tailwind-merge precedence. */\n    elevation: {\n      0: 'shadow-none',\n      1: 'shadow-sm',\n      2: 'shadow-md',\n      3: 'shadow-lg',\n      4: 'shadow-xl',\n      5: 'shadow-2xl',\n    },\n\n    /* 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. */\n    ambient: {\n      none: '',\n      sheen: 'surface-sheen',\n      glow: 'surface-glow',\n    },\n  },\n\n  compoundVariants: [\n    /* solid / elevated / flat share the same palette — opaque tone bg + tone foreground. */\n    { variant: ['solid', 'elevated', 'flat'], tone: 'neutral', class: Tones.solid.neutral },\n    { variant: ['solid', 'elevated', 'flat'], tone: 'primary', class: Tones.solid.primary },\n    { variant: ['solid', 'elevated', 'flat'], tone: 'danger', class: Tones.solid.danger },\n    { variant: ['solid', 'elevated', 'flat'], tone: 'success', class: Tones.solid.success },\n    { variant: ['solid', 'elevated', 'flat'], tone: 'warning', class: Tones.solid.warning },\n    { variant: ['solid', 'elevated', 'flat'], tone: 'info', class: Tones.solid.info },\n\n    /* soft — muted/tinted bg, tone-readable text. */\n    { variant: 'soft', tone: 'neutral', class: Tones.soft.neutral },\n    { variant: 'soft', tone: 'primary', class: Tones.soft.primary },\n    { variant: 'soft', tone: 'danger', class: Tones.soft.danger },\n    { variant: 'soft', tone: 'success', class: Tones.soft.success },\n    { variant: 'soft', tone: 'warning', class: Tones.soft.warning },\n    { variant: 'soft', tone: 'info', class: Tones.soft.info },\n\n    /* surface — popover bg + tone-accent border. */\n    { variant: 'surface', tone: 'neutral', class: Tones.surface.neutral },\n    { variant: 'surface', tone: 'primary', class: Tones.surface.primary },\n    { variant: 'surface', tone: 'danger', class: Tones.surface.danger },\n    { variant: 'surface', tone: 'success', class: Tones.surface.success },\n    { variant: 'surface', tone: 'warning', class: Tones.surface.warning },\n    { variant: 'surface', tone: 'info', class: Tones.surface.info },\n\n    /* outline — transparent fill, tone border + tone text. */\n    { variant: 'outline', tone: 'neutral', class: Tones.outline.neutral },\n    { variant: 'outline', tone: 'primary', class: Tones.outline.primary },\n    { variant: 'outline', tone: 'danger', class: Tones.outline.danger },\n    { variant: 'outline', tone: 'success', class: Tones.outline.success },\n    { variant: 'outline', tone: 'warning', class: Tones.outline.warning },\n    { variant: 'outline', tone: 'info', class: Tones.outline.info },\n\n    /* glass — translucent tinted fill + blur. */\n    { variant: 'glass', tone: 'neutral', class: Tones.glass.neutral },\n    { variant: 'glass', tone: 'primary', class: Tones.glass.primary },\n    { variant: 'glass', tone: 'danger', class: Tones.glass.danger },\n    { variant: 'glass', tone: 'success', class: Tones.glass.success },\n    { variant: 'glass', tone: 'warning', class: Tones.glass.warning },\n    { variant: 'glass', tone: 'info', class: Tones.glass.info },\n\n    /* glass-outline — glass + tone border at 50% alpha. */\n    { variant: 'glass-outline', tone: 'neutral', class: Tones.glassOutline.neutral },\n    { variant: 'glass-outline', tone: 'primary', class: Tones.glassOutline.primary },\n    { variant: 'glass-outline', tone: 'danger', class: Tones.glassOutline.danger },\n    { variant: 'glass-outline', tone: 'success', class: Tones.glassOutline.success },\n    { variant: 'glass-outline', tone: 'warning', class: Tones.glassOutline.warning },\n    { variant: 'glass-outline', tone: 'info', class: Tones.glassOutline.info },\n\n    /* subtle — low-alpha tinted fill + neutral border, no shadow. */\n    { variant: 'subtle', tone: 'neutral', class: Tones.subtle.neutral },\n    { variant: 'subtle', tone: 'primary', class: Tones.subtle.primary },\n    { variant: 'subtle', tone: 'danger', class: Tones.subtle.danger },\n    { variant: 'subtle', tone: 'success', class: Tones.subtle.success },\n    { variant: 'subtle', tone: 'warning', class: Tones.subtle.warning },\n    { variant: 'subtle', tone: 'info', class: Tones.subtle.info },\n  ],\n\n  defaultVariants: {\n    variant: 'surface',\n    tone: 'neutral',\n    radius: 'md',\n    padding: 'none',\n  },\n});\n\n/** Represents the union of every surface variant prop. */\nexport type SurfaceVariants = VariantProps<typeof surfaceVariants>;\n\n/* Compile-time lock: enum values ≡ tv variant/tone value-sets (drift = type error). */\ntype AssertExact<A, B> = [A] extends [B] ? ([B] extends [A] ? true : never) : never;\nconst _assertSurfaceVariant: AssertExact<\n  SurfaceVariant,\n  NonNullable<VariantProps<typeof surfaceVariants>['variant']>\n> = true;\nconst _assertSurfaceTone: AssertExact<\n  SurfaceTone,\n  NonNullable<VariantProps<typeof surfaceVariants>['tone']>\n> = true;\nvoid _assertSurfaceVariant;\nvoid _assertSurfaceTone;\n\n/** Represents the semantic colour axis — identical to the shared `Tone` (neutral · primary · danger · success · warning · info). */\nexport type SurfaceTone = Tone;\n\n/** Represents the corner-roundness axis (none · sm · md · lg · xl · 2xl · full). */\nexport type SurfaceRadius = NonNullable<SurfaceVariants['radius']>;\n\n/** Represents the interior-padding axis (none · xs · sm · md · lg · xl · 2xl). */\nexport type SurfacePadding = NonNullable<SurfaceVariants['padding']>;\n\n/** Represents the shadow-depth override (0–5); omitted means the variant decides. */\nexport type SurfaceElevation = NonNullable<SurfaceVariants['elevation']>;\n\n/** Represents the optional ambient gradient overlay (none · sheen · glow); omitted = none. */\nexport type SurfaceAmbient = NonNullable<SurfaceVariants['ambient']>;\n"],"names":[],"mappings":"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"}