cursedbelt 5.89.0 → 5.91.0

package/src/react/optimistic/queryTarget.spec.ts

@@ -0,0 +1,64 @@
+/**
+ * `queryTarget` refetches a cache entry once, after the LAST optimistic change on it settles.
+ * Refetching after each one drew the second of two quick deletes back for a moment: the first
+ * answer's refetch read the server before the second delete had landed (collections and desk both
+ * met it, forge task 3583). Its own file so it imports only what predates the fix.
+ */
+import { afterEach, beforeEach, describe, expect, type Mock, spyOn, test } from 'bun:test';
+import { toast } from '../Toast.js';
+import { optimistic, queryTarget } from './optimistic.js';
+
+type Row = { id: string; title: string };
+const rows: Row[] = [
+  { id: 'a', title: 'A' },
+  { id: 'b', title: 'B' },
+  { id: 'c', title: 'C' },
+];
+
+const deferred = <T,>() => {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+};
+
+let toastError: Mock<typeof toast.error>;
+beforeEach(() => {
+  toastError = spyOn(toast, 'error').mockImplementation(() => 0);
+});
+afterEach(() => toastError.mockRestore());
+
+describe('queryTarget', () => {
+  test('two changes on one cache entry refetch it ONCE, after the last settles', async () => {
+    const calls: string[] = [];
+    let data: unknown = rows;
+    const client = {
+      cancelQueries: () => undefined,
+      setQueryData: (_k: readonly unknown[], updater: (old: unknown) => unknown) => {
+        data = updater(data);
+      },
+      invalidateQueries: () => void calls.push('invalidate'),
+    };
+    const first = deferred<void>();
+    const second = deferred<void>();
+    const one = optimistic({
+      label: 'delete “A”',
+      targets: { ...queryTarget<Row[]>(client, ['rows']), apply: (r: Row[]) => r.filter((x) => x.id !== 'a') },
+      request: () => first.promise,
+    });
+    const two = optimistic({
+      label: 'delete “B”',
+      targets: { ...queryTarget<Row[]>(client, ['rows']), apply: (r: Row[]) => r.filter((x) => x.id !== 'b') },
+      request: () => second.promise,
+    });
+    first.resolve();
+    await one;
+    expect(calls).toEqual([]); // B is still in flight: a refetch now would draw it back
+    second.resolve();
+    await two;
+    expect(calls).toEqual(['invalidate']);
+    expect((data as Row[]).map((r) => r.id)).toEqual(['c']);
+  });
+
+});

package/src/react/optimistic/revert.spec.ts

@@ -0,0 +1,114 @@
+import { describe, expect, test } from 'bun:test';
+import { counterRevert, inverseOf } from './revert.js';
+
+type Row = { id: string; title: string; liked?: boolean };
+const rows: Row[] = [
+  { id: 'a', title: 'A' },
+  { id: 'b', title: 'B' },
+  { id: 'c', title: 'C' },
+];
+const without = (list: Row[], id: string) => list.filter((r) => r.id !== id);
+const rename = (list: Row[], id: string, title: string) => list.map((r) => (r.id === id ? { ...r, title } : r));
+
+describe('inverseOf — arrays of records', () => {
+  test('a removed row comes back where it was', () => {
+    const after = without(rows, 'b');
+    expect(inverseOf(rows, after)(after)).toEqual(rows);
+  });
+
+  test('two deletes, the FIRST fails: only that row returns, the second stays gone', () => {
+    const afterA = without(rows, 'a');
+    const afterB = without(afterA, 'b');
+    expect(inverseOf(rows, afterA)(afterB).map((r) => r.id)).toEqual(['a', 'c']);
+  });
+
+  test('a removed row returns beside its surviving neighbor when rows before it went too', () => {
+    const afterB = without(rows, 'b');
+    const now = without(afterB, 'a'); // another change took A since
+    expect(inverseOf(rows, afterB)(now).map((r) => r.id)).toEqual(['b', 'c']);
+  });
+
+  test('a row the server or a refetch already put back is not doubled', () => {
+    const after = without(rows, 'b');
+    expect(inverseOf(rows, after)(rows)).toBe(rows);
+  });
+
+  test('an added row is taken out; rows added since stay', () => {
+    const after = [...rows, { id: 'tmp', title: 'New' }];
+    const now = [...after, { id: 'd', title: 'D' }];
+    expect(inverseOf(rows, after)(now).map((r) => r.id)).toEqual(['a', 'b', 'c', 'd']);
+  });
+
+  test('a patch reverts only the fields it set, and keeps a later edit to another field', () => {
+    const after = rows.map((r) => (r.id === 'b' ? { ...r, liked: true } : r));
+    const now = rename(after, 'b', 'Renamed since');
+    const reverted = inverseOf(rows, after)(now);
+    expect(reverted[1]).toEqual({ id: 'b', title: 'Renamed since' });
+  });
+
+  test('rename twice, the first fails: the second title stands', () => {
+    const first = rename(rows, 'b', 'X');
+    const second = rename(first, 'b', 'Y');
+    expect(inverseOf(rows, first)(second)[1]?.title).toBe('Y');
+  });
+
+  test('a reorder is undone only while the optimistic order still stands', () => {
+    const after = [rows[2], rows[0], rows[1]] as Row[];
+    expect(inverseOf(rows, after)(after).map((r) => r.id)).toEqual(['a', 'b', 'c']);
+    const movedAgain = [rows[0], rows[2], rows[1]] as Row[];
+    expect(inverseOf(rows, after)(movedAgain)).toBe(movedAgain);
+  });
+
+  test('nothing to revert returns the same reference, so a setter does not re-render', () => {
+    const after = without(rows, 'b');
+    const unrelated = [{ id: 'z', title: 'Z' }];
+    // `b` is not there, but neither is its neighbor; it still comes back, at the top.
+    expect(inverseOf(rows, after)(unrelated).map((r) => r.id)).toEqual(['b', 'z']);
+    expect(inverseOf(rows, rows)(unrelated)).toBe(unrelated);
+  });
+
+  test('a custom idOf names rows that carry no id', () => {
+    const files = [{ path: '/a' }, { path: '/b' }];
+    const after = files.slice(1);
+    const idOf = (f: unknown) => (f as { path: string }).path;
+    expect(inverseOf(files, after, idOf)(after)).toEqual(files);
+  });
+});
+
+describe('inverseOf — other shapes', () => {
+  test('primitive arrays behave as sets of values (a tag list)', () => {
+    const tags = ['x', 'y'];
+    const after = ['x', 'y', 'z'];
+    expect(inverseOf(tags, after)(['x', 'y', 'z', 'w'])).toEqual(['x', 'y', 'w']);
+  });
+
+  test('objects recurse key by key: a page { items, total }', () => {
+    const before = { items: rows, total: 3 };
+    const after = { items: without(rows, 'a'), total: 2 };
+    expect(inverseOf(before, after)(after)).toEqual(before);
+  });
+
+  test('a key the change added goes; one it removed comes back', () => {
+    const before: Record<string, number> = { a: 1, b: 2 };
+    const after: Record<string, number> = { a: 1, c: 3 };
+    expect(inverseOf(before, after)(after)).toEqual({ a: 1, b: 2 });
+  });
+
+  test('Set and Map members', () => {
+    const before = new Set(['a']);
+    const after = new Set(['a', 'b']);
+    expect([...inverseOf(before, after)(new Set(['a', 'b', 'c']))]).toEqual(['a', 'c']);
+    const mBefore = new Map([['a', { n: 1 }]]);
+    const mAfter = new Map<string, { n: number }>();
+    expect(inverseOf(mBefore, mAfter)(new Map()).get('a')).toEqual({ n: 1 });
+  });
+
+  test('a scalar returns only if it still holds the optimistic value', () => {
+    expect(inverseOf(false, true)(true)).toBe(false);
+    expect(inverseOf(1, 2)(3)).toBe(3);
+  });
+
+  test('counterRevert gives back the difference, whatever happened since', () => {
+    expect(counterRevert(8, 10, 9)).toBe(9);
+  });
+});

package/src/react/optimistic/revert.ts

@@ -0,0 +1,238 @@
+/**
+ * The rollback half of an optimistic change, DERIVED from the change itself.
+ *
+ * A caller writes only the forward edit (`rows => rows.filter(r => r.id !== id)`); this works out
+ * what that edit touched by comparing the state before and after it, and returns an inverse that
+ * undoes exactly that — applied to whatever the state is when the request fails, not to a
+ * snapshot. That difference is the whole reason this file exists:
+ *
+ *   delete A, delete B, A fails → restoring the snapshot taken before A would bring back B too
+ *   (or, taken before B, drop a rename made since). The inverse instead puts A back where it
+ *   was and leaves B gone and the rename standing.
+ *
+ * The rules, by shape (recursing through plain objects and arrays, so a patch three levels down
+ * reverts three levels down):
+ *
+ * | shape | the change | its inverse, against the current state |
+ * |---|---|---|
+ * | array of records (`id`) or primitives | item removed | put back after its nearest surviving neighbor, unless it is back already |
+ * | | item added | taken out by id |
+ * | | item changed | recurse into it by id (only fields still holding the optimistic value revert) |
+ * | | reordered | the old order back, only if the current order is still the optimistic one |
+ * | plain object | key changed / added / removed | per key, recursing |
+ * | `Set` / `Map` | member added / removed | the member out / back |
+ * | anything else | replaced | the old value back only if the current one is still the optimistic one |
+ *
+ * "Only if it still holds the optimistic value" is what lets two edits race: rename to "B", then
+ * to "C" — if the first request fails, the title is "C" by now, so it stays "C".
+ *
+ * Returns the current state UNCHANGED (same reference) when nothing needs reverting, so a React
+ * setter given the inverse does not re-render.
+ */
+
+/** How an array item is identified. Records by `id` (or `key`), primitives by value. */
+export type IdOf = (item: unknown) => unknown;
+
+const NO_ID = Symbol('no-id');
+
+export const defaultIdOf: IdOf = (item) => {
+  if (item === null || typeof item !== 'object') return item;
+  const record = item as { id?: unknown; key?: unknown };
+  if (record.id !== undefined) return record.id;
+  if (record.key !== undefined) return record.key;
+  return NO_ID;
+};
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (value === null || typeof value !== 'object') return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+
+/**
+ * The inverse of the change `before → after`, as a function of the state at revert time.
+ * `idOf` names array items; the default reads `id`, then `key`, and uses a primitive's value.
+ */
+export function inverseOf<S>(before: S, after: S, idOf: IdOf = defaultIdOf): (current: S) => S {
+  return (current) => revertValue(before, after, current, idOf) as S;
+}
+
+function revertValue(before: unknown, after: unknown, current: unknown, idOf: IdOf): unknown {
+  if (Object.is(before, after)) return current;
+  if (Array.isArray(before) && Array.isArray(after) && Array.isArray(current)) {
+    const reverted = revertArray(before, after, current, idOf);
+    if (reverted !== undefined) return reverted;
+  }
+  if (before instanceof Set && after instanceof Set && current instanceof Set) {
+    return revertSet(before, after, current);
+  }
+  if (before instanceof Map && after instanceof Map && current instanceof Map) {
+    return revertMap(before, after, current, idOf);
+  }
+  if (isPlainObject(before) && isPlainObject(after) && isPlainObject(current)) {
+    return revertObject(before, after, current, idOf);
+  }
+  return Object.is(current, after) ? before : current;
+}
+
+function revertObject(
+  before: Record<string, unknown>,
+  after: Record<string, unknown>,
+  current: Record<string, unknown>,
+  idOf: IdOf,
+): Record<string, unknown> {
+  let out: Record<string, unknown> | undefined;
+  const write = (key: string, value: unknown, remove = false) => {
+    out ??= { ...current };
+    if (remove) delete out[key];
+    else out[key] = value;
+  };
+  for (const key of new Set([...Object.keys(before), ...Object.keys(after)])) {
+    const had = Object.hasOwn(before, key);
+    const has = Object.hasOwn(after, key);
+    if (had && has) {
+      if (Object.is(before[key], after[key])) continue;
+      if (!Object.hasOwn(current, key)) continue; // removed since — not ours to bring back
+      const next = revertValue(before[key], after[key], current[key], idOf);
+      if (!Object.is(next, current[key])) write(key, next);
+    } else if (has) {
+      // Added by the change: take it out if it is still what the change put there.
+      if (Object.hasOwn(current, key) && Object.is(current[key], after[key])) write(key, undefined, true);
+    } else if (!Object.hasOwn(current, key)) {
+      write(key, before[key]); // removed by the change, and still gone
+    }
+  }
+  return out ?? current;
+}
+
+/** `undefined` when the items cannot be identified — the caller falls back to whole-value. */
+function revertArray(before: unknown[], after: unknown[], current: unknown[], idOf: IdOf): unknown[] | undefined {
+  const ids = (list: unknown[]) => list.map(idOf);
+  const beforeIds = ids(before);
+  const afterIds = ids(after);
+  const unique = (list: unknown[]) => !list.includes(NO_ID) && new Set(list).size === list.length;
+  if (!unique(beforeIds) || !unique(afterIds)) return undefined;
+
+  const beforeById = new Map(beforeIds.map((id, i) => [id, before[i]]));
+  const afterById = new Map(afterIds.map((id, i) => [id, after[i]]));
+  let out = current;
+  let touched = false;
+  const edit = () => {
+    if (!touched) {
+      out = [...current];
+      touched = true;
+    }
+  };
+
+  // 1 · Items the change ADDED go, if they are still there.
+  const added = afterIds.filter((id) => !beforeById.has(id));
+  if (added.length > 0) {
+    const drop = new Set(added);
+    const kept = out.filter((item) => !drop.has(idOf(item)));
+    if (kept.length !== out.length) {
+      out = kept;
+      touched = true;
+    }
+  }
+
+  // 2 · Items the change CHANGED revert field by field.
+  for (const [id, was] of beforeById) {
+    const now = afterById.get(id);
+    if (now === undefined || Object.is(was, now)) continue;
+    const at = out.findIndex((item) => Object.is(idOf(item), id));
+    if (at < 0) continue;
+    const next = revertValue(was, now, out[at], idOf);
+    if (!Object.is(next, out[at])) {
+      edit();
+      out[at] = next;
+    }
+  }
+
+  // 3 · Items the change REMOVED come back beside the neighbor they had.
+  const removed = beforeIds.flatMap((id, index) => (afterById.has(id) ? [] : [{ id, index }]));
+  for (const { id, index } of removed) {
+    if (out.some((item) => Object.is(idOf(item), id))) continue;
+    edit();
+    let at = 0;
+    for (let i = index - 1; i >= 0; i--) {
+      const neighbor = out.findIndex((item) => Object.is(idOf(item), beforeIds[i]));
+      if (neighbor >= 0) {
+        at = neighbor + 1;
+        break;
+      }
+    }
+    out.splice(at, 0, beforeById.get(id));
+  }
+
+  // 4 · A REORDER: the old order back, only where the optimistic order still stands.
+  const kept = beforeIds.filter((id) => afterById.has(id));
+  const keptAfter = afterIds.filter((id) => beforeById.has(id));
+  if (kept.some((id, i) => !Object.is(id, keptAfter[i]))) {
+    const keep = new Set(kept);
+    const positions: number[] = [];
+    out.forEach((item, i) => {
+      if (keep.has(idOf(item))) positions.push(i);
+    });
+    const nowOrder = positions.map((i) => idOf(out[i]));
+    if (nowOrder.length === keptAfter.length && nowOrder.every((id, i) => Object.is(id, keptAfter[i]))) {
+      const byId = new Map(positions.map((i) => [idOf(out[i]), out[i]]));
+      edit();
+      positions.forEach((slot, i) => {
+        out[slot] = byId.get(kept[i]);
+      });
+    }
+  }
+
+  return touched ? out : current;
+}
+
+function revertSet(before: Set<unknown>, after: Set<unknown>, current: Set<unknown>): Set<unknown> {
+  let out: Set<unknown> | undefined;
+  const copy = () => {
+    out ??= new Set(current);
+    return out;
+  };
+  for (const member of after) {
+    if (!before.has(member) && current.has(member)) copy().delete(member);
+  }
+  for (const member of before) {
+    if (!after.has(member) && !current.has(member)) copy().add(member);
+  }
+  return out ?? current;
+}
+
+function revertMap(
+  before: Map<unknown, unknown>,
+  after: Map<unknown, unknown>,
+  current: Map<unknown, unknown>,
+  idOf: IdOf,
+): Map<unknown, unknown> {
+  let out: Map<unknown, unknown> | undefined;
+  const copy = () => {
+    out ??= new Map(current);
+    return out;
+  };
+  for (const key of new Set([...before.keys(), ...after.keys()])) {
+    const had = before.has(key);
+    const has = after.has(key);
+    if (had && has) {
+      if (Object.is(before.get(key), after.get(key)) || !current.has(key)) continue;
+      const next = revertValue(before.get(key), after.get(key), current.get(key), idOf);
+      if (!Object.is(next, current.get(key))) copy().set(key, next);
+    } else if (has) {
+      if (current.has(key) && Object.is(current.get(key), after.get(key))) copy().delete(key);
+    } else if (!current.has(key)) {
+      copy().set(key, before.get(key));
+    }
+  }
+  return out ?? current;
+}
+
+/**
+ * A counter's inverse: give back the difference the change made, whatever has happened since.
+ * The whole-value rule is wrong for a count — two deletes take a total 10 → 9 → 8, and when the
+ * first fails the total is 8, not 9, so "revert only if still optimistic" would never fire. Pass
+ * it as a target's `revert`: `{ set: setTotal, apply: (n) => n - 1, revert: counterRevert }`.
+ */
+export const counterRevert = (current: number, before: number, after: number): number =>
+  current + (before - after);

package/src/react/optimistic/staysOffTheEntry.spec.ts

@@ -0,0 +1,38 @@
+/**
+ * 🔴 `optimistic()` is on every app's busiest paths, so whatever it imports STATICALLY lands on
+ * their entry chunks. Its first version imported `../Toast.js` at the top, which put sonner
+ * (~10 kB gzip) back on flix's and roms' entries — the bytes cursedbelt 5.64 took off them
+ * (forge task 2900) — and both apps had to raise their asset budgets (forge task 3583).
+ *
+ * The toast is loaded at the first refusal instead. This fails if any file of the module reaches
+ * the toast or sonner without `import()`.
+ */
+import { describe, expect, test } from 'bun:test';
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const dir = import.meta.dir;
+// `LazyToaster` is the other half: the stack an app mounts must not pull sonner in statically either.
+const sources = [
+  ...readdirSync(dir)
+    .filter((f) => /\.tsx?$/.test(f) && !/\.spec\.tsx?$/.test(f))
+    .map((f) => join(dir, f)),
+  join(dir, '..', 'LazyToaster.tsx'),
+];
+const STATIC = /^\s*import\s+(?!type\b)[^;]*?from\s+['"]([^'"]+)['"]/gm;
+
+describe('the optimistic module stays off the entry chunk', () => {
+  test('no file imports the toast or sonner statically', () => {
+    const offenders = sources.flatMap((file) =>
+      [...readFileSync(file, 'utf8').matchAll(STATIC)]
+        .map((m) => m[1] ?? '')
+        .filter((spec) => spec === 'sonner' || /Toast(\.js)?$/.test(spec))
+        .map((spec) => `${file} → ${spec}`),
+    );
+    expect(offenders).toEqual([]);
+  });
+
+  test('the check sees a static import when there is one', () => {
+    expect([..."import { toast } from '../Toast.js';".matchAll(STATIC)].map((m) => m[1])).toEqual(['../Toast.js']);
+  });
+});

package/src/styles-areas/analytics.css

@@ -18,7 +18,7 @@
  * after an app's responsive variant (task 2124). An app that imports every area gets exactly
  * what `cursedbelt/styles-utilities.css` emits — proved rule by rule in
  * src/stylesAreas.spec.ts, which is also what fails when this file is stale.
- * 156 candidate(s).
+ * 159 candidate(s).
  *
  * Written by scripts/generateAreaStyles.ts (`bun run styles:areas`), which
  * `bun run build` runs. The map of what is in which area, and why the areas are
@@ -33,19 +33,19 @@
 @source inline("@max-6xl:text-[length:0] @max-6xl:w-0! @max-xl:contents @xl:basis-auto @xl:block @xl:hidden");
 @source inline("[&>*]:hidden [&>*]:max-w-none [&>svg]:size-3.5 [&_svg]:size-3 active:cursor-grabbing basis");
 @source inline("basis-full bg-[var(--cb-frozen-bg)] bg-accent/15 bg-card/95 bg-gradient-to-t bg-muted/30");
-@source inline("bg-muted/50 border-accent-solid border-accent/60 border-field-error border-solid border-t-2 col");
-@source inline("collapse cursor-grab data-[ending-style]:opacity-0 data-[ending-style]:scale-95");
+@source inline("bg-muted/50 border-accent-solid border-accent/60 border-b-0! border-field-error border-solid");
+@source inline("border-t-2 col collapse cursor-grab data-[ending-style]:opacity-0 data-[ending-style]:scale-95");
 @source inline("data-[highlighted]:bg-accent/10 data-[highlighted]:text-accent-strong");
 @source inline("data-[starting-style]:opacity-0 data-[starting-style]:scale-95 disabled:opacity-40 duration-100");
 @source inline("fade-in focus-visible:ring-field-ring/40 focus-within:border-field-ring focus-within:ring-2");
-@source inline("focus-within:ring-field-ring/30 from-card gap-x-6 h-105");
+@source inline("focus-within:ring-field-ring/30 from-card gap-x-6 h-0 h-105");
 @source inline("has-[[aria-invalid=true]]:border-field-error hover:bg-background hover:bg-muted/40");
 @source inline("hover:border-field-ring hover:text-warning italic justify-self-end last:border-0 left-11");
 @source inline("left-2.5 list-none max-h-64 max-h-88 max-sm:flex-1 max-sm:flex-wrap max-sm:min-w-0");
 @source inline("max-sm:min-w-24 max-sm:min-w-32 max-sm:ml-13.5 max-sm:w-auto max-w-32 max-w-36 max-w-45 max-w-48");
 @source inline("max-w-60 min-h-20 min-h-dvh min-w-0! min-w-20 min-w-24 min-w-4 min-w-52");
 @source inline("min-w-[var(--anchor-width)] min-w-max mr-2 mt-1.5 mt-3 mt-4 not-italic ordinal p-0! pb-1.5");
-@source inline("pl-1.5 pl-2 pr-0.5 pr-1 pr-10 pr-16 pr-3 pr-9 pt-1 resize-none resize-y right-3");
+@source inline("pl-1.5 pl-2 pr-0.5 pr-1 pr-10 pr-16 pr-3 pr-9 pt-1 py-0! resize-none resize-y right-3");
 @source inline("ring-field-error/30 self self-stretch shadow-[1px_0_0_0_var(--color-border)] shrink-[2] size-7");
 @source inline("slide-in-from-top-1 table-fixed text-[length:0] text-accent-solid-foreground");
 @source inline("text-field-placeholder text-success text-xl to-transparent top-3 transition-[transform,opacity]");

package/src/styles-areas/data-table.css

@@ -18,7 +18,7 @@
  * after an app's responsive variant (task 2124). An app that imports every area gets exactly
  * what `cursedbelt/styles-utilities.css` emits — proved rule by rule in
  * src/stylesAreas.spec.ts, which is also what fails when this file is stale.
- * 151 candidate(s).
+ * 154 candidate(s).
  *
  * Written by scripts/generateAreaStyles.ts (`bun run styles:areas`), which
  * `bun run build` runs. The map of what is in which area, and why the areas are
@@ -33,19 +33,19 @@
 @source inline("@max-6xl:text-[length:0] @max-6xl:w-0! @max-xl:contents @xl:basis-auto @xl:block @xl:hidden");
 @source inline("[&>*]:hidden [&>*]:max-w-none [&>svg]:size-3.5 [&_svg]:size-3 active:cursor-grabbing basis-full");
 @source inline("bg-[var(--cb-frozen-bg)] bg-accent/15 bg-card/95 bg-gradient-to-t bg-muted/30 bg-muted/50");
-@source inline("border-accent-solid border-accent/60 border-field-error border-solid border-t-2 col collapse");
-@source inline("cursor-grab data-[ending-style]:opacity-0 data-[ending-style]:scale-95");
+@source inline("border-accent-solid border-accent/60 border-b-0! border-field-error border-solid border-t-2 col");
+@source inline("collapse cursor-grab data-[ending-style]:opacity-0 data-[ending-style]:scale-95");
 @source inline("data-[highlighted]:bg-accent/10 data-[highlighted]:text-accent-strong");
 @source inline("data-[starting-style]:opacity-0 data-[starting-style]:scale-95 disabled:opacity-40 duration-100");
 @source inline("fade-in focus-visible:ring-field-ring/40 focus-within:border-field-ring focus-within:ring-2");
-@source inline("focus-within:ring-field-ring/30 from-card gap-x-6 h-105");
+@source inline("focus-within:ring-field-ring/30 from-card gap-x-6 h-0 h-105");
 @source inline("has-[[aria-invalid=true]]:border-field-error hover:bg-background hover:bg-muted/40");
 @source inline("hover:border-field-ring hover:text-warning justify-self-end last:border-0 left-11 left-2.5");
 @source inline("list-none max-h-64 max-h-88 max-sm:flex-1 max-sm:flex-wrap max-sm:min-w-0 max-sm:min-w-24");
 @source inline("max-sm:min-w-32 max-sm:ml-13.5 max-sm:w-auto max-w-32 max-w-36 max-w-45 max-w-48 max-w-60");
 @source inline("min-h-20 min-h-dvh min-w-0! min-w-24 min-w-4 min-w-52 min-w-[var(--anchor-width)] min-w-max mr-2");
 @source inline("mt-1.5 mt-3 mt-4 not-italic ordinal p-0! pb-1.5 pl-1.5 pl-2 pr-0.5 pr-1 pr-10 pr-16 pr-3 pr-9");
-@source inline("pt-1 resize-none resize-y right-3 ring-field-error/30 self self-stretch");
+@source inline("pt-1 py-0! resize-none resize-y right-3 ring-field-error/30 self self-stretch");
 @source inline("shadow-[1px_0_0_0_var(--color-border)] size-7 slide-in-from-top-1 table-fixed text-[length:0]");
 @source inline("text-accent-solid-foreground text-field-placeholder text-success text-xl to-transparent top-3");
 @source inline("transition-[transform,opacity] w-0! w-11 w-12 w-20 w-32 w-36 w-40 w-88");

package/src/styles-utilities.css

@@ -656,6 +656,9 @@
     width: 100%;
     height: 100%;
   }
+  .h-0 {
+    height: 0px;
+  }
   .h-0\.5 {
     height: calc(var(--spacing) * 0.5);
   }
@@ -1726,6 +1729,10 @@
     border-bottom-style: var(--tw-border-style);
     border-bottom-width: 0px;
   }
+  .border-b-0\! {
+    border-bottom-style: var(--tw-border-style) !important;
+    border-bottom-width: 0px !important;
+  }
   .border-b-2 {
     border-bottom-style: var(--tw-border-style);
     border-bottom-width: 2px;
@@ -2639,6 +2646,9 @@
   .py-0 {
     padding-block: 0px;
   }
+  .py-0\! {
+    padding-block: 0px !important;
+  }
   .py-0\.5 {
     padding-block: calc(var(--spacing) * 0.5);
   }