@cosmicdrift/kumiko-framework 0.327.0 → 0.328.1

package/src/testing/e2e-generator.ts

@@ -1,494 +0,0 @@
-// @runtime tooling
-//
-// E2E-Generator — leitet strukturierte TestSpecs aus der Registry ab.
-//
-// Grundidee: jede r.screen(...) ist eine testbare Oberfläche. Der Generator
-// iteriert getAllScreens() und baut pro Screen einen Satz TestSpecs (vier
-// Kinds, einer pro "was muss mindestens funktionieren"). Die Specs sind
-// JSON-serialisierbar — Consumer (Sample/Package-e2e) schreiben sie via
-// bun-Script als JSON auf Platte, und ein Playwright-globalSetup triggert
-// das vor jedem Run. Der eigentliche Playwright-Runner liest die JSON und
-// iteriert mit kind-spezifischen Handlern gegen den echten Renderer.
-//
-// Vorteil des 2-Prozess-Modells: die framework-runtime (Registry, drizzle,
-// ioredis-types etc.) lädt NIE im Playwright-Worker. Würde sie das, kollidierte
-// sie mit Playwrights Object.prototype-Symbolen ($$jest-matchers-object) und
-// der Worker würde beim spec-import crashen.
-//
-// Zwei Stufen, jede einzeln testbar:
-//   1. generateE2ESpec(registry)   — Registry → TestSpec[]
-//   2. generateZodFixture(schema)  — ZodType  → plausibler Value
-//
-// Stufe 2 ist intentionally minimal (Strategy a aus dem Plan): string/number/
-// boolean/date/enum/uuid + ZodOptional/ZodDefault-Unwrap. Alles andere wirft
-// "not supported yet" — wir füllen nach, wenn ein echter Caller es braucht.
-// Fake-komplexe-Werte würden nur False-Green-Tests produzieren.
-
-import type * as z from "zod";
-import {
-  type EntityDefinition,
-  type EntityEditScreenDefinition,
-  type EntityListScreenDefinition,
-  type FieldDefinition,
-  isFieldsEditSection,
-  normalizeEditField,
-  normalizeListColumn,
-  parseQn,
-  qn,
-  type Registry,
-  sectionFieldSpecs,
-  toKebab,
-} from "../engine";
-
-// --- Spec-Shape ---
-
-// Jeder TestSpec-Variant enthält alles was der Renderer zum Templaten braucht
-// — keine Registry-Referenz, keine Lazy-Lookups. So sind Specs JSON-fähig
-// (debug-dump, Snapshot-Vergleich) und der Renderer bleibt rein Template.
-export type E2ETestSpec =
-  | {
-      readonly kind: "list-renders";
-      readonly screenQn: string;
-      readonly title: string;
-      readonly urlPath: string;
-    }
-  | {
-      readonly kind: "list-has-fixture-row";
-      readonly screenQn: string;
-      readonly title: string;
-      readonly urlPath: string;
-      readonly writeHandlerQn: string;
-      readonly fixture: Readonly<Record<string, unknown>>;
-      readonly identifyingValue: string;
-    }
-  | {
-      readonly kind: "edit-validates-required";
-      readonly screenQn: string;
-      readonly title: string;
-      readonly urlPath: string;
-      readonly requiredFields: readonly string[];
-    }
-  | {
-      readonly kind: "edit-save-persists";
-      readonly screenQn: string;
-      readonly title: string;
-      readonly urlPath: string;
-      readonly listUrlPath?: string;
-      readonly fills: readonly EditFillOp[];
-      readonly identifyingValue: string;
-      readonly identifyingField: string;
-    };
-
-// Strukturierte Anweisung für den edit-save-persists-Renderer. Der Fixture
-// allein sagt nicht, ob ein String in ein Text-Feld (`.fill`) oder in ein
-// Dropdown (`.selectOption`) gehört — der Generator entscheidet anhand der
-// FieldDefinition, der Renderer templated nur.
-export type EditFillOp =
-  | { readonly kind: "fill"; readonly field: string; readonly value: string }
-  | { readonly kind: "check"; readonly field: string; readonly value: boolean }
-  | { readonly kind: "select"; readonly field: string; readonly value: string };
-
-export type E2EGeneratorOptions = {
-  // Tenant-Slug/UUID als Template-Placeholder. Default "{tenant}" — der
-  // Test-Runner ersetzt zur Laufzeit. Wer die URL fix tenant-scoped will,
-  // setzt hier den Slug.
-  readonly tenantPlaceholder?: string;
-};
-
-// --- Stufe 1: Spec-Ableitung aus der Registry ---
-
-export function generateE2ESpec(
-  registry: Registry,
-  options: E2EGeneratorOptions = {},
-): readonly E2ETestSpec[] {
-  const tenant = options.tenantPlaceholder ?? "{tenant}";
-  const specs: E2ETestSpec[] = [];
-
-  for (const [screenQn, screen] of registry.getAllScreens()) {
-    if (screen.type === "custom") continue; // keine generische Annahme möglich
-    // actionForm: kein generischer E2E-Spec — Author-defined Handler
-    // braucht Author-defined Test-Daten, die der Generator nicht kennt.
-    if (screen.type === "actionForm") continue;
-    // secretMint: same reasoning — author-defined write handler, no generic spec.
-    if (screen.type === "secretMint") continue;
-    // configEdit: dito — die Werte werden über config:write:set
-    // pro Field geschrieben, ohne CRUD-Zustand zu generieren wäre der
-    // Spec wertlos. Branding/SMTP/etc. sind Author-spezifisch.
-    if (screen.type === "configEdit") continue;
-    // secretsEdit: dito — writes go through secrets:write:set with
-    // plaintext values the generator has no author-defined test data for.
-    if (screen.type === "secretsEdit") continue;
-    // projectionList: query-getrieben, Author-spezifische Projection —
-    // kein generischer CRUD-Spec ableitbar (wie actionForm/configEdit).
-    if (screen.type === "projectionList") continue;
-    // projectionDetail: dito — read-only single-row inspector, kein CRUD-Zustand.
-    if (screen.type === "projectionDetail") continue;
-    // dashboard: panel-getrieben (Stat/Chart/List-Queries) — dito, keine
-    // generische CRUD-Annahme möglich.
-    if (screen.type === "dashboard") continue;
-    const { scope: feature, name: short } = parseQn(screenQn);
-    const urlPath = `/t/${tenant}/${feature}/${short}`;
-    const title = `${feature}/${short}`;
-
-    if (screen.type === "entityList") {
-      specs.push(...buildListSpecs(screen, screenQn, title, urlPath, registry));
-    } else {
-      specs.push(...buildEditSpecs(screen, screenQn, title, urlPath, registry, tenant));
-    }
-  }
-
-  return specs;
-}
-
-function buildListSpecs(
-  screen: EntityListScreenDefinition,
-  screenQn: string,
-  title: string,
-  urlPath: string,
-  registry: Registry,
-): E2ETestSpec[] {
-  const out: E2ETestSpec[] = [{ kind: "list-renders", screenQn, title, urlPath }];
-
-  const entity = registry.getEntity(screen.entity);
-  if (!entity) return out;
-
-  const writeHandlerQn = findCreateHandlerQn(registry, screen.entity);
-  if (!writeHandlerQn) return out;
-
-  const fixture = buildEntityFixture(entity);
-  const identifyingValue = pickIdentifyingValue(fixture, screen, entity);
-  if (identifyingValue === undefined) return out;
-
-  out.push({
-    kind: "list-has-fixture-row",
-    screenQn,
-    title,
-    urlPath,
-    writeHandlerQn,
-    fixture,
-    identifyingValue,
-  });
-
-  return out;
-}
-
-function buildEditSpecs(
-  screen: EntityEditScreenDefinition,
-  screenQn: string,
-  title: string,
-  urlPath: string,
-  registry: Registry,
-  tenant: string,
-): E2ETestSpec[] {
-  const out: E2ETestSpec[] = [];
-  const entity = registry.getEntity(screen.entity);
-  if (!entity) return out;
-
-  const requiredFields = collectRequiredEditFields(screen, entity);
-  if (requiredFields.length > 0) {
-    out.push({ kind: "edit-validates-required", screenQn, title, urlPath, requiredFields });
-  }
-
-  const fixture = buildEntityFixture(entity);
-  const listScreen = findListScreenForEntity(registry, screen.entity);
-  const listUrlPath = listScreen ? buildScreenUrlPath(listScreen.qn, tenant) : undefined;
-
-  const identifying = pickIdentifyingForEdit(fixture, screen, entity, listScreen?.def);
-  if (identifying) {
-    const fills = buildEditFillOps(screen, entity, fixture);
-    out.push({
-      kind: "edit-save-persists",
-      screenQn,
-      title,
-      urlPath,
-      listUrlPath,
-      fills,
-      identifyingValue: identifying.value,
-      identifyingField: identifying.field,
-    });
-  }
-
-  return out;
-}
-
-function buildScreenUrlPath(qn: string, tenant: string): string {
-  const { scope, name } = parseQn(qn);
-  return `/t/${tenant}/${scope}/${name}`;
-}
-
-function findCreateHandlerQn(registry: Registry, entityName: string): string | undefined {
-  // feature.writeHandlers ist mit Short-Names gekeyt ("task:create"), der
-  // Registry-Lookup braucht die qualified Form ("tasks:write:task:create").
-  // Wir qualifizieren via qn() + toKebab wie die Registry selbst — das ist
-  // der Vertrag aus qualified-name.ts.
-  for (const feature of registry.features.values()) {
-    for (const shortName of Object.keys(feature.writeHandlers ?? {})) {
-      if (!shortName.endsWith(":create")) continue;
-      const qualified = qn(toKebab(feature.name), "write", toKebab(shortName));
-      if (registry.getHandlerEntity(qualified) === entityName) return qualified;
-    }
-  }
-  return undefined;
-}
-
-function findListScreenForEntity(
-  registry: Registry,
-  entityName: string,
-): { qn: string; def: EntityListScreenDefinition } | undefined {
-  for (const [qn, screen] of registry.getAllScreens()) {
-    if (screen.type === "entityList" && screen.entity === entityName) {
-      return { qn, def: screen };
-    }
-  }
-  return undefined;
-}
-
-function collectRequiredEditFields(
-  screen: EntityEditScreenDefinition,
-  entity: EntityDefinition,
-): string[] {
-  const out: string[] = [];
-  for (const section of screen.layout.sections) {
-    if (!isFieldsEditSection(section)) continue;
-    for (const rawField of sectionFieldSpecs(section)) {
-      const { field } = normalizeEditField(rawField);
-      const def = entity.fields[field];
-      if (def && "required" in def && def.required === true) {
-        out.push(field);
-      }
-    }
-  }
-  return out;
-}
-
-function pickIdentifyingValue(
-  fixture: Readonly<Record<string, unknown>>,
-  screen: EntityListScreenDefinition,
-  entity: EntityDefinition,
-): string | undefined {
-  // Erste Text-Spalte mit Fixture-Wert — das ist die visuell zuverlässigste
-  // Identifikation in einer generischen Tabelle.
-  for (const raw of screen.columns) {
-    const { field } = normalizeListColumn(raw);
-    if (entity.fields[field]?.type !== "text") continue;
-    const v = fixture[field];
-    if (typeof v === "string" && v.length > 0) return v;
-  }
-  return undefined;
-}
-
-function buildEditFillOps(
-  screen: EntityEditScreenDefinition,
-  entity: EntityDefinition,
-  fixture: Readonly<Record<string, unknown>>,
-): EditFillOp[] {
-  // Laufe die Layout-Reihenfolge — das Resultat spiegelt, was ein User
-  // tatsächlich ausfüllt. Per Field-Typ entscheiden wir die Interaktions-
-  // form; Felder ohne Fixture-Wert (file/image/…) werden übersprungen.
-  const ops: EditFillOp[] = [];
-  for (const section of screen.layout.sections) {
-    if (!isFieldsEditSection(section)) continue;
-    for (const raw of sectionFieldSpecs(section)) {
-      const { field } = normalizeEditField(raw);
-      const def = entity.fields[field];
-      if (!def) continue;
-      const v = fixture[field];
-      if (v === undefined) continue;
-
-      switch (def.type) {
-        case "boolean":
-          if (typeof v === "boolean") ops.push({ kind: "check", field, value: v });
-          break;
-        case "select":
-          if (typeof v === "string") ops.push({ kind: "select", field, value: v });
-          break;
-        case "text":
-        case "longText":
-        case "number":
-        case "date":
-        case "tz":
-          // date: ein Text-Input, akzeptiert getippte ISO-Werte direkt.
-          ops.push({ kind: "fill", field, value: String(v) });
-          break;
-        // embedded/money/timestamp/locatedTimestamp/file/image/files/images:
-        // keine generische Interaktion. timestamp rendert seit #369 zwei
-        // Inputs (Datum + Uhrzeit), die ein einzelnes .fill() nicht bedienen
-        // kann — der Test-Autor liefert einen Hand-Override oder überspringt.
-        default:
-          break;
-      }
-    }
-  }
-  return ops;
-}
-
-function pickIdentifyingForEdit(
-  fixture: Readonly<Record<string, unknown>>,
-  editScreen: EntityEditScreenDefinition,
-  entity: EntityDefinition,
-  listScreen: EntityListScreenDefinition | undefined,
-): { field: string; value: string } | undefined {
-  // Bevorzugt ein Feld das im List-Screen als Column auftaucht — sonst ist
-  // die "taucht in Liste auf"-Assertion nicht durchführbar.
-  const columns = listScreen
-    ? new Set(listScreen.columns.map((c) => normalizeListColumn(c).field))
-    : undefined;
-
-  for (const section of editScreen.layout.sections) {
-    if (!isFieldsEditSection(section)) continue;
-    for (const rawField of sectionFieldSpecs(section)) {
-      const { field } = normalizeEditField(rawField);
-      if (entity.fields[field]?.type !== "text") continue;
-      if (columns && !columns.has(field)) continue;
-      const v = fixture[field];
-      if (typeof v === "string" && v.length > 0) return { field, value: v };
-    }
-  }
-  return undefined;
-}
-
-// --- Stufe 2: Zod-Fixture (Strategy a) ---
-
-// Zod 4 stabilisiert die Introspection auf `._def.type` (lowercase Discriminator)
-// + `._def.format` für String-Formate (email/url/uuid/datetime) + `._def.entries`
-// für Enums + `._def.innerType` für optional/default/nullable. Wir greifen
-// gezielt auf diese Felder zu — genau die Form die unser buildInsertSchema
-// emittiert. Andere Typen werfen "not supported yet", bis ein Sample den Fall
-// konkret braucht.
-
-type ZodInternals = {
-  readonly type?: string;
-  readonly format?: string;
-  readonly innerType?: z.ZodTypeAny;
-  readonly entries?: Record<string, string>;
-  readonly out?: z.ZodTypeAny;
-};
-
-function readZodInternals(schema: z.ZodTypeAny): ZodInternals | undefined {
-  return (schema as unknown as { _def?: ZodInternals })._def;
-}
-
-export function generateZodFixture(schema: z.ZodTypeAny): unknown {
-  const def = readZodInternals(schema);
-  const typeName = def?.type;
-
-  switch (typeName) {
-    case "optional":
-    case "nullable":
-    case "default": {
-      if (!def?.innerType) throw new Error(`zod ${typeName} without innerType`);
-      return generateZodFixture(def.innerType);
-    }
-    case "string":
-      return fixtureString(def?.format);
-    case "number":
-      return 1;
-    case "boolean":
-      return true;
-    case "enum": {
-      const first = def?.entries ? Object.values(def.entries)[0] : undefined;
-      return first ?? "";
-    }
-    case "date":
-      return new Date("2026-01-01T00:00:00Z");
-    case "pipe": {
-      if (!def?.out) throw new Error("zod pipe without out");
-      return generateZodFixture(def.out);
-    }
-    default:
-      throw new Error(`generateZodFixture: not supported yet: ${typeName ?? "<unknown>"}`);
-  }
-}
-
-function fixtureString(format: string | undefined): string {
-  if (format === "email") return "e2e@example.com";
-  if (format === "url") return "https://example.com";
-  if (format === "uuid" || format === "guid") return "00000000-0000-4000-8000-000000000000";
-  if (format === "datetime" || format === "date") return "2026-01-01T00:00:00Z";
-  return "e2e-fixture";
-}
-
-// --- Fixture aus FieldDefinition (für Stufe 1 statt Zod-Schema) ---
-//
-// Bewusstes Duplicate zu generateZodFixture. Die beiden haben unterschiedliche
-// Aufgaben:
-//   generateZodFixture   — public, generisch, weiß nur Zod-Primitives
-//   buildEntityFixture   — intern, Kumiko-Domain, weiß über file-skip,
-//                          embedded-Shape, money/tz-Objekte und nutzt den
-//                          Feldnamen für lesbare Prefixes ("e2e-email@...")
-//
-// Ein Zusammenziehen über buildInsertSchema + generateZodFixture würde entweder
-// den Feldnamen-Hint verlieren (alle email-Fixtures bekämen denselben Wert —
-// Unique-Constraints wären inkonsistent) oder einen hint-Parameter in die
-// public API von generateZodFixture drücken, den externe Caller nie brauchen.
-function buildEntityFixture(entity: EntityDefinition): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [name, field] of Object.entries(entity.fields)) {
-    const value = fieldToFixture(name, field);
-    if (value !== undefined) out[name] = value;
-  }
-  return out;
-}
-
-function fieldToFixture(name: string, field: FieldDefinition): unknown {
-  switch (field.type) {
-    case "text": {
-      if (field.format === "email") return `e2e-${name}@example.com`;
-      if (field.format === "url") return "https://example.com";
-      return `e2e ${name}`;
-    }
-    case "longText":
-      // longText hat keine format-Optionen — generic placeholder reicht.
-      return `e2e ${name} (long-form content)`;
-    case "boolean":
-      return true;
-    case "select":
-      return field.options[0] ?? "";
-    case "multiSelect": {
-      const first = field.options[0];
-      return first ? [first] : [];
-    }
-    case "number":
-      return 1;
-    case "money":
-      return { amount: 1, currency: "EUR" };
-    case "date":
-      return "2026-01-01";
-    case "timestamp":
-      return field.locatedBy !== undefined ? "2026-01-01T00:00:00" : "2026-01-01T00:00:00Z";
-    case "tz":
-      return "Europe/Berlin";
-    case "locatedTimestamp":
-      return { at: "2026-01-01T00:00:00", tz: "Europe/Berlin" };
-    case "embedded": {
-      const sub: Record<string, unknown> = {};
-      for (const [subName, subDef] of Object.entries(field.schema)) {
-        sub[subName] =
-          subDef.type === "text"
-            ? `e2e ${subName}`
-            : subDef.type === "number" || subDef.type === "decimal"
-              ? 1
-              : subDef.type === "money"
-                ? 100
-                : subDef.type === "boolean"
-                  ? true
-                  : "2026-01-01";
-      }
-      return field.multiple === true ? [sub] : sub;
-    }
-    case "jsonb":
-      // Free-form jsonb — e2e-generator returns empty-object.
-      return {};
-    case "file":
-    case "image":
-    case "files":
-    case "images":
-      // File-Upload-Fixture ist noch nicht generisch: Playwright müsste
-      // Dateiinhalte mitliefern, und die Write-API verlangt bereits ge-
-      // uploadete fileRef-UUIDs. Lässt sich nachziehen, sobald Sample die
-      // Pfade klärt (M4).
-      return undefined;
-    default:
-      return undefined;
-  }
-}

package/src/testing/expect-error.ts

@@ -1,25 +0,0 @@
-import { expect } from "bun:test";
-import type { WriteErrorInfo } from "../errors";
-
-// Vitest's toContain doesn't operate on plain objects, so after the move from
-// string errors to typed WriteErrorInfo the legacy `expect(error).toContain(x)`
-// assertions break. This helper concatenates code, message, and serialized
-// details so existing substring checks against short reason strings keep
-// working without each call site needing to know the new shape.
-//
-// Accepts `string | null` too, so call sites that still get raw strings
-// (e.g. helpers that haven't moved to typed errors yet) keep working.
-export function expectErrorIncludes(
-  err: WriteErrorInfo | string | null | undefined,
-  substring: string,
-): void {
-  let haystack: string;
-  if (err === null || err === undefined) {
-    haystack = String(err);
-  } else if (typeof err === "string") {
-    haystack = err;
-  } else {
-    haystack = `${err.code} ${err.message} ${JSON.stringify(err.details ?? {})}`;
-  }
-  expect(haystack).toContain(substring);
-}

package/src/testing/file-provider-contract.ts

@@ -1,123 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import type { FileStorageProvider } from "../files/types";
-
-const bytes = (s: string) => new TextEncoder().encode(s);
-const decode = (u: Uint8Array) => new TextDecoder().decode(u);
-
-async function* fromChunks(chunks: Uint8Array[]): AsyncIterable<Uint8Array> {
-  for (const c of chunks) yield c;
-}
-
-// Mirrors describeKmsAdapterContract (crypto/__tests__/kms-adapter-contract.ts):
-// pins the FileStorageProvider contract against whatever implementation the
-// factory returns. Provider-specific behavior (error messages, buffer
-// copies, multipart details) stays in each provider's dedicated tests.
-export function describeFileProviderContract(
-  name: string,
-  factory: () => FileStorageProvider | Promise<FileStorageProvider>,
-): void {
-  describe(`${name} — FileStorageProvider contract`, () => {
-    let provider: FileStorageProvider;
-    // Self-cleaning: every key this contract creates gets deleted in
-    // afterEach, so a persistent backend (local `kumiko dev` against a
-    // long-lived Minio, as opposed to CI's ephemeral one) doesn't leak
-    // `contract/<uuid>` objects into the next developer's session. delete()
-    // on a key that was never actually written is covered by the
-    // "no-op on a missing key" contract test above, so tracking generated
-    // keys unconditionally (even ones a test never got around to writing)
-    // is safe.
-    let writtenKeys: string[];
-
-    function trackedKey(ext: string): string {
-      const key = `contract/${crypto.randomUUID()}.${ext}`;
-      writtenKeys.push(key);
-      return key;
-    }
-
-    beforeEach(async () => {
-      provider = await factory();
-      writtenKeys = [];
-    });
-
-    afterEach(async () => {
-      for (const key of writtenKeys) await provider.delete(key);
-    });
-
-    test("write + read roundtrip preserves bytes", async () => {
-      const key = trackedKey("bin");
-      await provider.write(key, bytes("hello contract"));
-      expect(decode(await provider.read(key))).toBe("hello contract");
-    });
-
-    test("write on an existing key overwrites it (last-write-wins)", async () => {
-      const key = trackedKey("bin");
-      await provider.write(key, bytes("first"));
-      await provider.write(key, bytes("second"));
-      expect(decode(await provider.read(key))).toBe("second");
-    });
-
-    test("read throws for a missing key", async () => {
-      await expect(provider.read(`contract/missing-${crypto.randomUUID()}`)).rejects.toThrow();
-    });
-
-    test("exists reflects write + delete", async () => {
-      const key = trackedKey("txt");
-      expect(await provider.exists(key)).toBe(false);
-      await provider.write(key, bytes("x"));
-      expect(await provider.exists(key)).toBe(true);
-      await provider.delete(key);
-      expect(await provider.exists(key)).toBe(false);
-    });
-
-    test("delete on a missing key is a no-op", async () => {
-      await expect(
-        provider.delete(`contract/never-existed-${crypto.randomUUID()}`),
-      ).resolves.toBeUndefined();
-    });
-
-    test("writeStream + readStream roundtrip preserves bytes", async () => {
-      const key = trackedKey("stream");
-      await provider.writeStream(key, fromChunks([bytes("foo"), bytes("bar")]));
-      let out = "";
-      for await (const chunk of provider.readStream(key)) out += decode(chunk);
-      expect(out).toBe("foobar");
-    });
-
-    test("readStream on a missing key throws on the first chunk pull", async () => {
-      const it = provider
-        .readStream(`contract/missing-${crypto.randomUUID()}`)
-        [Symbol.asyncIterator]();
-      await expect(it.next()).rejects.toThrow();
-    });
-
-    test("list returns only keys under the given prefix", async () => {
-      const group = `contract/list-${crypto.randomUUID()}`;
-      const keyA = `${group}/a.txt`;
-      const keyB = `${group}/b.txt`;
-      const outsideKey = `contract/list-${crypto.randomUUID()}/c.txt`;
-      writtenKeys.push(keyA, keyB, outsideKey);
-      await provider.write(keyA, bytes("a"));
-      await provider.write(keyB, bytes("b"));
-      await provider.write(outsideKey, bytes("c"));
-
-      const listed = await provider.list(`${group}/`);
-      expect(new Set(listed)).toEqual(new Set([keyA, keyB]));
-    });
-
-    test("list on a prefix with no matches returns an empty array", async () => {
-      const listed = await provider.list(`contract/list-missing-${crypto.randomUUID()}/`);
-      expect(listed).toEqual([]);
-    });
-
-    test("getSignedUrl, when implemented, returns a URL string", async () => {
-      // skip: getSignedUrl is optional on the contract — feature-detected
-      if (!provider.getSignedUrl) return;
-
-      const key = trackedKey("txt");
-      await provider.write(key, bytes("signed"));
-      const url = await provider.getSignedUrl(key, 60);
-      expect(typeof url).toBe("string");
-      expect(url.length).toBeGreaterThan(0);
-    });
-  });
-}