@cosmicdrift/kumiko-framework 0.327.0 → 0.328.1

package/src/engine/__tests__/factories-number-unit.test.ts

@@ -1,23 +0,0 @@
-// createNumberField({ unit }) passthrough — pins that NumberFieldDef.unit
-// survives the factory's Partial<Omit<...>> spread, static string and
-// sibling-field-reference form alike.
-
-import { describe, expect, test } from "bun:test";
-import { createNumberField } from "../factories";
-
-describe("createNumberField — unit passthrough", () => {
-  test("static unit string is preserved", () => {
-    const f = createNumberField({ unit: "km" });
-    expect(f.unit).toBe("km");
-  });
-
-  test("sibling-field unit reference is preserved", () => {
-    const f = createNumberField({ unit: { field: "mileageUnit" } });
-    expect(f.unit).toEqual({ field: "mileageUnit" });
-  });
-
-  test("omitted unit stays undefined", () => {
-    const f = createNumberField();
-    expect(f.unit).toBeUndefined();
-  });
-});

package/src/engine/__tests__/factories-personal.test.ts

@@ -1,216 +0,0 @@
-// Unit tests for the `personal`/`find` PII annotation resolution
-// (kumiko-framework#2250) — the `expandPersonalAnnotations` helper in
-// ../factories, exercised through the public factory functions.
-
-import { describe, expect, test } from "bun:test";
-import {
-  createLongTextField,
-  createNumberField,
-  createTextField,
-  createTimestampField,
-} from "../factories";
-
-describe("createTextField — personal/find resolution", () => {
-  // kumiko-framework#2921 — a text field can no longer be constructed
-  // without declaring whose data it holds, neither at the type level nor
-  // at runtime (fail-closed for untyped JS callers).
-  test("no argument at all throws", () => {
-    expect(() =>
-      // @ts-expect-error overrides (with a personal stance) is now required
-      createTextField(),
-    ).toThrow(/must declare an explicit personal-data stance/);
-  });
-
-  test("options without `personal` throws", () => {
-    expect(() =>
-      // @ts-expect-error `personal` is required on the options object
-      createTextField({ required: true }),
-    ).toThrow(/createTextField\(\.\.\.\) must declare an explicit personal-data stance/);
-  });
-
-  test("an untyped JS caller passing null throws the same guidance instead of a raw TypeError", () => {
-    // Simulated untyped-boundary call — a real JS consumer has no compiler
-    // to reject this, so the runtime gate must catch it. Cast only here.
-    const call = () => createTextField(null as unknown as Parameters<typeof createTextField>[0]);
-    expect(call).toThrow(/must declare an explicit personal-data stance/);
-  });
-
-  test("an untyped JS caller passing personal: null throws the guidance message, not a raw TypeError", () => {
-    // Same untyped-boundary simulation, but `personal` itself is null
-    // instead of the whole options object — the object-branch subject
-    // check must not dereference `.of` on it.
-    const call = () =>
-      createTextField({ personal: null } as unknown as Parameters<typeof createTextField>[0]);
-    expect(call).toThrow(/must declare an explicit personal-data stance/);
-  });
-
-  test('personal: "self" without find throws', () => {
-    expect(() =>
-      // @ts-expect-error `find` is required alongside a named subject
-      createTextField({ personal: "self" }),
-    ).toThrow(/must declare an explicit personal-data stance/);
-  });
-
-  test("personal: false without a reason throws", () => {
-    expect(() =>
-      // @ts-expect-error `reason` is required alongside `personal: false`
-      createTextField({ personal: false }),
-    ).toThrow(/must declare an explicit personal-data stance/);
-  });
-
-  test("personal: false with a reason works", () => {
-    const f = createTextField({ personal: false, reason: "is_business_data" });
-    expect(f.allowPlaintext).toBe("is_business_data");
-  });
-
-  test("an invalid personal value throws and lists every valid stance", () => {
-    const call = () =>
-      createTextField({
-        // @ts-expect-error "yes" is not a valid personal stance
-        personal: "yes",
-      });
-    expect(call).toThrow(/must declare an explicit personal-data stance/);
-    try {
-      call();
-      throw new Error("expected createTextField to throw");
-    } catch (error) {
-      const message = String(error);
-      expect(message).toContain('personal: "self"');
-      expect(message).toContain('personal: "tenant"');
-      expect(message).toContain('personal: { of: "<ownerField>" }');
-      expect(message).toContain('personal: "ref"');
-      expect(message).toContain("personal: false, reason:");
-    }
-  });
-
-  test('personal: "self", find: "exact" → pii + lookupable', () => {
-    const f = createTextField({ personal: "self", find: "exact" });
-    expect(f.pii).toBe(true);
-    expect(f.lookupable).toBe(true);
-    expect(f.searchable).toBe(false);
-    expect(f).not.toHaveProperty("personal");
-    expect(f).not.toHaveProperty("find");
-  });
-
-  test('personal: "self", find: "fuzzy" → pii + lookupable + searchable', () => {
-    const f = createTextField({ personal: "self", find: "fuzzy" });
-    expect(f.pii).toBe(true);
-    expect(f.lookupable).toBe(true);
-    expect(f.searchable).toBe(true);
-  });
-
-  test('personal: "self", find: "none" → pii only, no lookup/search flags', () => {
-    const f = createTextField({ personal: "self", find: "none" });
-    expect(f.pii).toBe(true);
-    expect(f.lookupable).toBeUndefined();
-    expect(f.searchable).toBe(false);
-    expect(f.sensitive).toBeUndefined();
-  });
-
-  test('personal: "self", find: "secret" → pii + sensitive, no lookup/search', () => {
-    const f = createTextField({ personal: "self", find: "secret" });
-    expect(f.pii).toBe(true);
-    expect(f.sensitive).toBe(true);
-    expect(f.lookupable).toBeUndefined();
-    expect(f.searchable).toBe(false);
-  });
-
-  test('personal: "tenant", find: "exact" → tenantOwned + lookupable', () => {
-    const f = createTextField({ personal: "tenant", find: "exact" });
-    expect(f.tenantOwned).toBe(true);
-    expect(f.lookupable).toBe(true);
-    expect(f.pii).toBeUndefined();
-  });
-
-  test('personal: { of: "ownerId" }, find: "exact" → userOwned + lookupable', () => {
-    const f = createTextField({ personal: { of: "ownerId" }, find: "exact" });
-    expect(f.userOwned).toEqual({ ownerField: "ownerId" });
-    expect(f.lookupable).toBe(true);
-  });
-
-  test('personal: "ref" → subjectRef only, no find allowed on this variant', () => {
-    const f = createTextField({ personal: "ref" });
-    expect(f.subjectRef).toBe(true);
-    expect(f.pii).toBeUndefined();
-    expect(f.lookupable).toBeUndefined();
-  });
-
-  test("personal: false, reason given → allowPlaintext carries the reason", () => {
-    const f = createTextField({ personal: false, reason: "public display name, not identifying" });
-    expect(f.allowPlaintext).toBe("public display name, not identifying");
-    expect(f.pii).toBeUndefined();
-  });
-
-  test("anonymize survives resolution alongside a subject annotation", () => {
-    const anonymize = () => "[ANONYMIZED]";
-    const f = createTextField({ personal: "self", find: "none", anonymize });
-    expect(f.pii).toBe(true);
-    expect(f.anonymize).toBe(anonymize);
-  });
-
-  test("other overrides (e.g. maxLength) pass through unaffected", () => {
-    const f = createTextField({ personal: "self", find: "none", maxLength: 500 });
-    expect(f.maxLength).toBe(500);
-    expect(f.pii).toBe(true);
-  });
-});
-
-describe("createLongTextField — restricted find (PersonalAnnotationsLongText)", () => {
-  test('personal: "self", find: "none" → pii only, no lookup/search flags', () => {
-    const f = createLongTextField({ personal: "self", find: "none" });
-    expect(f.pii).toBe(true);
-    expect(f.lookupable).toBeUndefined();
-    expect(f).not.toHaveProperty("searchable");
-    expect(f.sensitive).toBeUndefined();
-  });
-
-  test('personal: "self", find: "secret" → pii + sensitive, no lookup/search', () => {
-    const f = createLongTextField({ personal: "self", find: "secret" });
-    expect(f.pii).toBe(true);
-    expect(f.sensitive).toBe(true);
-    expect(f.lookupable).toBeUndefined();
-    expect(f).not.toHaveProperty("searchable");
-  });
-
-  test('find: "exact" is a createTextField-only value — createLongTextField rejects it', () => {
-    expect(() =>
-      createLongTextField({
-        personal: "self",
-        // @ts-expect-error "exact"/"fuzzy" don't exist on LongTextFindability
-        find: "exact",
-      }),
-    ).toThrow(/must declare an explicit personal-data stance/);
-  });
-});
-
-describe("createTimestampField — personal without find (PersonalAnnotationsNoFind)", () => {
-  test("no annotation at all: plain field, no PII flags", () => {
-    const f = createTimestampField({ required: true });
-    expect(f).toEqual({ type: "timestamp", required: true });
-  });
-
-  test('personal: "self" alone (no find on non-text factories) → pii only', () => {
-    const f = createTimestampField({ personal: "self" });
-    expect(f.pii).toBe(true);
-    expect(f).not.toHaveProperty("personal");
-    expect(f).not.toHaveProperty("find");
-  });
-
-  test("personal: false, reason given → allowPlaintext", () => {
-    const f = createTimestampField({ personal: false, reason: "server-generated, not user data" });
-    expect(f.allowPlaintext).toBe("server-generated, not user data");
-  });
-
-  // kumiko-framework#2921 only tightens text/longText — NoFind factories
-  // keep `personal` optional and stay callable without an argument.
-  test("createTimestampField() without any argument still works", () => {
-    const f = createTimestampField();
-    expect(f).toEqual({ type: "timestamp", required: false });
-  });
-
-  test("createNumberField() without any argument still works", () => {
-    const f = createNumberField();
-    expect(f.type).toBe("number");
-    expect(f).not.toHaveProperty("personal");
-  });
-});

package/src/engine/__tests__/factories-time.test.ts

@@ -1,94 +0,0 @@
-// Unit-Tests für die neuen Time-Field-Factories
-// (createTimestampField, createTzField, createLocatedTimestampField).
-//
-// Test-Fokus: korrektes Field-Shape + locatedBy-Marker-Verdrahtung. Die
-// echte TZ-Konvertierung (Wall-Clock ↔ UTC) testen wir später beim
-// DB-Wrapper-Schritt.
-
-import { describe, expect, test } from "bun:test";
-import { createLocatedTimestampField, createTimestampField, createTzField } from "../factories";
-
-describe("createTimestampField", () => {
-  test("default-Form ist nicht-required UTC-Instant ohne locatedBy", () => {
-    expect(createTimestampField()).toEqual({
-      type: "timestamp",
-      required: false,
-    });
-  });
-
-  test("kann required gesetzt werden", () => {
-    expect(createTimestampField({ required: true })).toEqual({
-      type: "timestamp",
-      required: true,
-    });
-  });
-
-  test("kann mit locatedBy markiert werden (für ad-hoc Cases)", () => {
-    expect(createTimestampField({ locatedBy: "myTz" })).toEqual({
-      type: "timestamp",
-      required: false,
-      locatedBy: "myTz",
-    });
-  });
-
-  test("kann sensitive markiert sein (PII / Audit-Schutz)", () => {
-    const f = createTimestampField({ sensitive: true });
-    expect(f.sensitive).toBe(true);
-  });
-});
-
-describe("createTzField", () => {
-  test("default-Form ist nicht-required IANA-Zone-Slot", () => {
-    expect(createTzField()).toEqual({ type: "tz", required: false });
-  });
-
-  test("required + access-rules übernimmt Overrides", () => {
-    const f = createTzField({
-      required: true,
-      access: { read: ["Admin"] },
-    });
-    expect(f.required).toBe(true);
-    expect(f.access).toEqual({ read: ["Admin"] });
-  });
-});
-
-describe("createLocatedTimestampField (Phase A — atomarer Field-Type)", () => {
-  test("default-Form ist nicht-required mit type 'locatedTimestamp'", () => {
-    expect(createLocatedTimestampField()).toEqual({
-      type: "locatedTimestamp",
-      required: false,
-    });
-  });
-
-  test("required-Override propagiert", () => {
-    expect(createLocatedTimestampField({ required: true })).toEqual({
-      type: "locatedTimestamp",
-      required: true,
-    });
-  });
-
-  test("access-Override propagiert (Field-Level Read-Access)", () => {
-    const f = createLocatedTimestampField({ access: { read: ["Dispatcher"] } });
-    expect(f).toEqual({
-      type: "locatedTimestamp",
-      required: false,
-      access: { read: ["Dispatcher"] },
-    });
-  });
-
-  test("sensitive-Override propagiert (PII-Schutz)", () => {
-    const f = createLocatedTimestampField({ sensitive: true });
-    expect(f.sensitive).toBe(true);
-  });
-
-  test("ein einziges Field-Objekt — kein Pair wie der alte locatedTimestamp helper", () => {
-    // Die neue Form: r.entity({ pickup: createLocatedTimestampField() })
-    // erzeugt EIN Schema-Feld (nicht zwei). Die zwei DB-Spalten + drei
-    // API-Felder kommen aus dem Framework-Auto-Convert (Phase B–D).
-    const field = createLocatedTimestampField();
-    expect(field.type).toBe("locatedTimestamp");
-    // Keine `at`/`tz`/`utc` Sub-Felder im Schema-Object selbst.
-    expect("at" in field).toBe(false);
-    expect("tz" in field).toBe(false);
-  });
-});

package/src/engine/__tests__/feature-crud-shorthand.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { defineFeature } from "../define-feature";
-import { createEntity, createTextField } from "../factories";
-
-const taskEntity = createEntity({
-  table: "crud_shorthand_tasks",
-  fields: { title: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
-  softDelete: true,
-});
-
-describe("r.crud", () => {
-  test("registers the entity + full CRUD handler set, same as registerEntityCrud", () => {
-    const write = { access: { roles: ["Admin"] } } as const;
-    const read = {
-      access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
-    } as const;
-
-    const feature = defineFeature("via-crud", (r) => {
-      r.crud("task", taskEntity, { write, read });
-    });
-
-    expect(Object.keys(feature.entities ?? {})).toEqual(["task"]);
-    expect(Object.keys(feature.writeHandlers ?? {}).sort()).toEqual(
-      ["task:create", "task:delete", "task:restore", "task:update"].sort(),
-    );
-    expect(Object.keys(feature.queryHandlers ?? {}).sort()).toEqual(
-      ["task:detail", "task:list"].sort(),
-    );
-  });
-
-  test("without verbAccess, write handlers keep write.access (never fall back to the broader read.access)", () => {
-    const write = { access: { roles: ["Manager"] } } as const;
-    const read = {
-      access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
-    } as const;
-
-    const feature = defineFeature("via-crud-no-verb-access", (r) => {
-      r.crud("task", taskEntity, { write, read });
-    });
-
-    for (const verb of ["create", "update", "delete", "restore"] as const) {
-      expect(feature.writeHandlers?.[`task:${verb}`]?.access).toEqual(write.access);
-    }
-    for (const verb of ["list", "detail"] as const) {
-      expect(feature.queryHandlers?.[`task:${verb}`]?.access).toEqual(read.access);
-    }
-  });
-
-  test("verbAccess overrides access per verb, other verbs keep write/read.access", () => {
-    const write = { access: { roles: ["Manager"] } } as const;
-    const read = {
-      access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
-    } as const;
-    const deleteAccess = { roles: ["Operator"] } as const;
-    const restoreAccess = { roles: ["Operator"] } as const;
-    const listAccess = { roles: ["Auditor"] } as const;
-
-    const feature = defineFeature("via-crud-verb-access", (r) => {
-      r.crud("task", taskEntity, {
-        write,
-        read,
-        verbAccess: { delete: deleteAccess, restore: restoreAccess, list: listAccess },
-      });
-    });
-
-    expect(feature.writeHandlers?.["task:create"]?.access).toEqual(write.access);
-    expect(feature.writeHandlers?.["task:update"]?.access).toEqual(write.access);
-    expect(feature.writeHandlers?.["task:delete"]?.access).toEqual(deleteAccess);
-    expect(feature.writeHandlers?.["task:restore"]?.access).toEqual(restoreAccess);
-    expect(feature.queryHandlers?.["task:list"]?.access).toEqual(listAccess);
-    expect(feature.queryHandlers?.["task:detail"]?.access).toEqual(read.access);
-  });
-});

package/src/engine/__tests__/feature-crud-verb-access.integration.test.ts

@@ -1,83 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
-import { asRawClient } from "../../db/query";
-import { setupTestStack, type TestStack, TestUsers, unsafeCreateEntityTable } from "../../stack";
-import { defineFeature } from "../define-feature";
-import { createEntity, createTextField } from "../factories";
-
-const propertyEntity = createEntity({
-  table: "crud_verb_access_properties",
-  fields: { title: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
-  softDelete: true,
-});
-
-const propertyFeature = defineFeature("crud-verb-access", (r) => {
-  r.crud("property", propertyEntity, {
-    write: { access: { roles: ["User"] } },
-    read: { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
-    verbAccess: {
-      delete: { roles: ["Admin"] },
-      restore: { roles: ["Admin"] },
-    },
-  });
-});
-
-const CREATE = "crud-verb-access:write:property:create";
-const DELETE = "crud-verb-access:write:property:delete";
-const RESTORE = "crud-verb-access:write:property:restore";
-
-describe("r.crud verbAccess — real dispatcher path", () => {
-  let stack: TestStack;
-
-  beforeAll(async () => {
-    stack = await setupTestStack({ features: [propertyFeature] });
-    await unsafeCreateEntityTable(stack.db, propertyEntity);
-  });
-
-  afterAll(async () => {
-    await stack.cleanup();
-  });
-
-  beforeEach(async () => {
-    await asRawClient(stack.db).unsafe("DELETE FROM kumiko_events");
-    await asRawClient(stack.db).unsafe('DELETE FROM "crud_verb_access_properties"');
-  });
-
-  test("create stays gated by write.access — User role passes", async () => {
-    const res = await stack.http.write(CREATE, { title: "verbAccess create" }, TestUsers.user);
-    expect(res.status).toBe(200);
-  });
-
-  test("delete overridden by verbAccess — User role (write.access) is rejected", async () => {
-    const created = await stack.http.write(CREATE, { title: "to be deleted" }, TestUsers.user);
-    const { data } = (await created.json()) as { data: { id: string } };
-
-    const res = await stack.http.write(DELETE, { id: data.id }, TestUsers.user);
-    expect(res.status).toBe(403);
-    const body = (await res.json()) as { isSuccess: false; error: { code: string } };
-    expect(body.error.code).toBe("access_denied");
-  });
-
-  test("delete overridden by verbAccess — Admin role (verbAccess.delete) passes", async () => {
-    const created = await stack.http.write(
-      CREATE,
-      { title: "to be deleted by admin" },
-      TestUsers.user,
-    );
-    const { data } = (await created.json()) as { data: { id: string } };
-
-    const res = await stack.http.write(DELETE, { id: data.id }, TestUsers.admin);
-    expect(res.status).toBe(200);
-  });
-
-  test("restore overridden by verbAccess — Admin role passes, User role rejected", async () => {
-    const created = await stack.http.write(CREATE, { title: "to be restored" }, TestUsers.user);
-    const { data } = (await created.json()) as { data: { id: string } };
-    await stack.http.write(DELETE, { id: data.id }, TestUsers.admin);
-
-    const deniedRestore = await stack.http.write(RESTORE, { id: data.id }, TestUsers.user);
-    expect(deniedRestore.status).toBe(403);
-
-    const allowedRestore = await stack.http.write(RESTORE, { id: data.id }, TestUsers.admin);
-    expect(allowedRestore.status).toBe(200);
-  });
-});

package/src/engine/__tests__/feature-manifest.test.ts

@@ -1,137 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { ConfigScopes } from "../constants";
-import {
-  buildManifestFromRegistry,
-  createRegistry,
-  createSystemConfig,
-  defineFeature,
-} from "../index";
-
-const boolKey = {
-  type: "boolean",
-  scope: ConfigScopes.system,
-  access: { read: ["anonymous"], write: ["anonymous"] },
-} as const;
-
-describe("buildManifestFromRegistry — deterministic codepoint sort (#330)", () => {
-  // `bZeta` vs `balpha`: localeCompare orders these case-insensitively
-  // (balpha < bZeta), but a codepoint sort puts uppercase 'Z' (U+005A) ahead of
-  // lowercase 'a' (U+0061) — the two comparators DISAGREE. The manifest is
-  // serialized to byte-exact JSON and must not depend on the runner's ICU
-  // locale (macOS-dev vs Linux-CI). This assertion fails the instant anyone
-  // reverts buildManifestFromRegistry to localeCompare. (Feature names skip the
-  // kebab normalization that config/secret short-names go through, so they are
-  // the one place a case-based disagreement survives into the sorted output.)
-  test("features are ordered by codepoint name, not locale", () => {
-    const registry = createRegistry([
-      defineFeature("bZeta", () => {}),
-      defineFeature("balpha", () => {}),
-    ]);
-
-    const manifest = buildManifestFromRegistry(registry, { source: "test" });
-
-    expect(manifest.features.map((f) => f.name)).toEqual(["bZeta", "balpha"]);
-  });
-
-  test("config keys within a feature come out sorted by qualified name", () => {
-    const feature = defineFeature("demo", (r) => {
-      r.config({ keys: { "z-flag": boolKey, "a-flag": boolKey } });
-    });
-    const registry = createRegistry([feature]);
-
-    const manifest = buildManifestFromRegistry(registry, { source: "test" });
-    const demo = manifest.features.find((f) => f.name === "demo");
-
-    expect(demo?.configKeys.map((k) => k.qualifiedName)).toEqual([
-      "demo:config:a-flag",
-      "demo:config:z-flag",
-    ]);
-  });
-
-  test("featureNames filter — nur genannte Features im Manifest", () => {
-    const registry = createRegistry([
-      defineFeature("alpha", () => {}),
-      defineFeature("beta", () => {}),
-      defineFeature("gamma", () => {}),
-    ]);
-
-    const manifest = buildManifestFromRegistry(registry, {
-      source: "test",
-      featureNames: new Set(["alpha", "gamma"]),
-    });
-
-    expect(manifest.features.map((f) => f.name)).toEqual(["alpha", "gamma"]);
-    expect(manifest.featureCount).toBe(2);
-  });
-
-  test("tier-Tagging — per-Feature + top-level im Manifest", () => {
-    const registry = createRegistry([
-      defineFeature("pro", () => {}),
-      defineFeature("free", () => {}),
-    ]);
-
-    const manifest = buildManifestFromRegistry(registry, {
-      source: "test",
-      tier: "enterprise",
-    });
-
-    expect(manifest.tier).toBe("enterprise");
-    for (const feature of manifest.features) {
-      expect(feature.tier).toBe("enterprise");
-    }
-  });
-
-  test("tier: undefined — weder per-Feature noch top-level vorhanden", () => {
-    const registry = createRegistry([defineFeature("basic", () => {})]);
-
-    const manifest = buildManifestFromRegistry(registry, { source: "test" });
-
-    expect(manifest.tier).toBeUndefined();
-    expect(manifest.features[0]?.tier).toBeUndefined();
-  });
-
-  test("uiHints flow through to the manifest when set", () => {
-    const registry = createRegistry([
-      defineFeature("with-hints", (r) => {
-        r.uiHints({ displayLabel: "With Hints", category: "demo", recommended: true });
-      }),
-      defineFeature("no-hints", () => {}),
-    ]);
-
-    const manifest = buildManifestFromRegistry(registry, { source: "test" });
-    const withHints = manifest.features.find((f) => f.name === "with-hints");
-    const noHints = manifest.features.find((f) => f.name === "no-hints");
-
-    expect(withHints?.uiHints).toEqual({
-      displayLabel: "With Hints",
-      category: "demo",
-      recommended: true,
-    });
-    expect(noHints && "uiHints" in noHints).toBe(false);
-  });
-
-  // #1039: backing:"secrets" routes the value through the envelope-encrypted
-  // secrets store — the manifest must report encrypted:true even without an
-  // explicit `encrypted` flag, so generated docs don't mislabel Stripe-style
-  // secret-backed config keys as plaintext. (createConfigKey never emits an
-  // explicit `encrypted: false` — falsy opts.encrypted just omits the field —
-  // so there's no "explicit false wins" case to pin here.)
-  test("encrypted flag — backing:secrets implies encrypted:true without an explicit flag", () => {
-    const feature = defineFeature("demo", (r) => {
-      r.config({
-        keys: {
-          "api-key": createSystemConfig("text", { backing: "secrets" }),
-          "plain-flag": createSystemConfig("boolean", {}),
-        },
-      });
-    });
-    const registry = createRegistry([feature]);
-
-    const manifest = buildManifestFromRegistry(registry, { source: "test" });
-    const demo = manifest.features.find((f) => f.name === "demo");
-    const byKey = (key: string) => demo?.configKeys.find((k) => k.key === key);
-
-    expect(byKey("api-key")?.encrypted).toBe(true);
-    expect(byKey("plain-flag")?.encrypted).toBe(false);
-  });
-});