@noy-db/test-format-conformance 0.7.0-pre.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vLannaAi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,138 @@
+# @noy-db/test-format-conformance
+
+The `as-*` export gate, published as an executable suite.
+
+```ts
+import { runFormatConformanceTests } from '@noy-db/test-format-conformance'
+
+runFormatConformanceTests('as-myformat', {
+  format: 'myformat',
+  vault: () => seededExportCapableVault(),
+  exports: [
+    { name: 'toString', run: (v) => toString(v, opts) },
+    { name: 'download', run: (v) => download(v, opts) },
+    { name: 'write',    run: (v) => write(v, path, { ...opts, acknowledgeRisks: true }) },
+  ],
+  writeWithoutAcknowledgement: (v, path) => write(v, path, opts),
+})
+```
+
+## What it checks
+
+`as-*` is the one place plaintext leaves the vault. Every package calls
+`vault.assertCanExport('plaintext', <format>)`, and that call is the whole
+boundary. Nine packages had converged on the same shape by convention, and
+convention is what the next format author reads instead of a contract.
+
+For **every** entry point the fixture lists:
+
+- it **refuses** when `assertCanExport` denies, and
+- it refuses **before reading a single record**.
+
+Plus: the `write` path refuses without `acknowledgeRisks: true`.
+
+## Gated is not the property. Gated BEFORE decrypting is.
+
+A gate called after `exportStream` has run refuses the caller *and decrypts
+anyway*. That is the property a delegation refactor breaks silently — move the
+gate from `toObject` into `download` and every existing test still passes.
+
+Proven, not asserted: moving as-csv's gate inside its `exportStream` loop
+leaves both "REFUSES" cases green and fails all three "before reading" cases.
+
+## The two ways this suite could have been vacuous
+
+Both were real, and both were found by trying to break it rather than by
+reading it.
+
+**A refusal is only evidence when the same call would otherwise succeed.**
+The kit's first case runs an entry point on the *ungated* vault and requires it
+to resolve. On its first run it failed `as-zip` — whose export path opens a
+blob slot, so the fixture vault was refusing on *blob storage*, not on the
+export gate. **Six green cases in a file I had just declared passing were
+passing for the wrong reason.**
+
+**`rejects.toThrow()` is absorbed by whichever guard fires first.** The
+acknowledgement case originally used a vault with no `exportCapability` grant,
+so `write` refused at the export gate and never reached the flag — deleting the
+acknowledgement guard from as-csv left the suite green. Fixed twice over: the
+case now matches on `/acknowledgeRisks/`, and the fixture is required to supply
+an export-capable vault.
+
+## Why a Proxy and not a fake Vault
+
+A hand-written double would drift from `Vault`, and would only ever exercise
+the methods whoever wrote it thought of. The fixture supplies a **real** vault
+and the kit wraps it, so an entry point reaching for some other decrypting
+method is still observed.
+
+## Mutation-checked
+
+| mutation | result |
+|---|---|
+| as-csv: gate deleted | 6 fail |
+| as-csv: gate moved after the read | 3 fail — the "before reading" cases only |
+| as-csv: `acknowledgeRisks` guard deleted | 1 fails |
+| as-zip: gate deleted | 6 fail |
+
+## All nine formats bind it
+
+`as-blob` · `as-csv` · `as-json` · `as-ndjson` · `as-noydb` · `as-sql` ·
+`as-xlsx` · `as-xml` · `as-zip`.
+
+Wiring them found that the family is **two capability tiers**, not one:
+
+| tier | packages | gate |
+|---|---|---|
+| `plaintext` | eight | `assertCanExport('plaintext', <format>)` |
+| `bundle` | `as-noydb` | `assertCanExport('bundle')` — no format |
+
+`as-noydb` emits an **encrypted** pod, so it also has **no `acknowledgeRisks`
+gate**, and its source says so twice. Its fixture therefore declares no
+acknowledgement case — and the suite prints
+`write: SKIPPED — … UNVERIFIED here` rather than staying quiet, which is the
+difference between a documented absence and a hole.
+
+`as-aws-s3` is not in the list: it exports `asAwsS3(options)` and is a
+**destination, not a format**.
+
+## The vacuity guard earned its place twice
+
+It fired on `as-zip` (no `withBlobs()`) and on `as-blob` (no blob attached to
+the seeded record). In both cases six refusal assertions were green and
+meaningless. Neither would have been visible from reading the output.
+
+## This kit is for EGRESS, not only for `as-*`
+
+The family prefix is not the criterion. **Anything that puts plaintext where the
+vault no longer controls it is an export**, and belongs here — which includes
+bindings that are not `as-*` packages at all.
+
+| projection | egress? | gated |
+|---|---|---|
+| `as-csv`, `as-xlsx`, `as-sql`, … | writes a file | ✅ |
+| `as-aws-s3` | pushes to a bucket — a **destination**, not a format | ✅ |
+| a `ui-*` binding rendering to a screen | the user already unlocked the vault | ❌ not egress |
+| **a `ui-*` binding pushing into Google Sheets / Excel-web / Airtable / Retool** | **a third party persists and indexes it** | ✅ **use this kit** |
+
+> **A UI that exports is an export.** Rendering locally is covered by unlock and
+> the ACL. Handing plaintext to a service that keeps a copy is the same act
+> `as-csv` performs, and it calls the same gate:
+> `assertCanExport('plaintext', <your format id>)`.
+
+Since `ExportFormat` is an **open** union, your id does not need to be one hub
+ships — `{ plaintext: ['gsheet'] }` is a grantable capability. Before that
+change a third-party id could be *checked* and never *granted*, so the only way
+to authorise one was the `'*'` wildcard.
+
+### What this contract is, honestly
+
+`as-*` packages refuse because **hub's own export paths call the gate**. A
+binding written outside this repo can simply not call it, and nothing stops it.
+So this is a **convention plus an executable check**, not an enforcement
+boundary — the same footing `to-*` runs on. Saying otherwise would repeat the
+mistake this kit was built to correct: a security claim that reads as
+enforcement and enforces nothing.
+
+Passing this suite is what makes the claim checkable. See
+`docs/adr/0005-no-ui-port.md` in the `noy-db` repo for the reasoning.

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+import { Vault, ExportFormat } from '@noy-db/hub';
+
+/** One plaintext-producing entry point, named as a consumer would call it. */
+interface FormatEntryPoint {
+    /** Exported function name, e.g. `'toString'`. Used in the test title. */
+    readonly name: string;
+    /** Call it against the supplied vault. Arguments are the fixture's business. */
+    run(vault: Vault): Promise<unknown>;
+}
+/** Everything an `as-*` package must supply to be checked against the gate. */
+interface FormatFixture {
+    /**
+     * The TIER the package passes to `assertCanExport`. The `as-*` family is
+     * two capability classes, not one — discovered by wiring `as-noydb`, which
+     * calls `assertCanExport('bundle')` and never mentions plaintext because it
+     * emits an encrypted pod. A kit that assumed one tier would have made that
+     * fixture describe itself wrongly while still passing.
+     */
+    readonly tier: 'plaintext' | 'bundle';
+    /**
+     * The format tag, e.g. `'csv'`. REQUIRED for the plaintext tier and
+     * meaningless for `bundle` — hub itself throws when a plaintext check
+     * arrives without one, so the pairing is asserted rather than assumed.
+     */
+    readonly format?: ExportFormat;
+    /**
+     * A REAL vault with at least one record. Built fresh per case, so an entry
+     * point that mutates it cannot leak into the next assertion.
+     */
+    vault(): Promise<Vault>;
+    /**
+     * EVERY entry point that can produce plaintext — not a representative one.
+     * A format with four exports and one listed here reports a green suite for
+     * the three nobody checked.
+     */
+    readonly exports: ReadonlyArray<FormatEntryPoint>;
+    /**
+     * The on-disk write path, if the package has one. It must refuse without
+     * `acknowledgeRisks: true`; pass a call that OMITS the flag.
+     *
+     * The vault this receives is the fixture's own — NOT the denying proxy —
+     * and it must be export-CAPABLE. A vault that would refuse the export
+     * anyway makes the case unfalsifiable: the refusal arrives from the gate
+     * upstream and the acknowledgement is never reached. That is not
+     * hypothetical; it is what the first version of this kit did, and deleting
+     * the acknowledgement guard from as-csv left the suite green.
+     */
+    writeWithoutAcknowledgement?: (vault: Vault, path: string) => Promise<unknown>;
+}
+/** Thrown by the denying proxy so a refusal is attributable to the gate. */
+declare class ExportDeniedByConformanceKit extends Error {
+    constructor(tier: string, format?: string);
+}
+/**
+ * Run the shared `as-*` export-gate contract against one format.
+ *
+ * @param name - shown in the suite title, e.g. `'as-csv'`.
+ */
+declare function runFormatConformanceTests(name: string, fixture: FormatFixture): void;
+
+export { ExportDeniedByConformanceKit, type FormatEntryPoint, type FormatFixture, runFormatConformanceTests };

package/dist/index.js

@@ -0,0 +1,83 @@
+// src/index.ts
+import { describe, it, expect } from "vitest";
+var ExportDeniedByConformanceKit = class extends Error {
+  constructor(tier, format) {
+    super(`conformance: assertCanExport denied '${tier}'${format ? ` / '${format}'` : ""}`);
+    this.name = "ExportDeniedByConformanceKit";
+  }
+};
+function denyingVault(real, tier, format, seen) {
+  return new Proxy(real, {
+    get(target, prop, receiver) {
+      if (prop === "assertCanExport") {
+        return () => {
+          throw new ExportDeniedByConformanceKit(tier, format);
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function" && typeof prop === "string") {
+        return (...args) => {
+          if (prop === "exportStream" || prop === "export" || prop === "snapshot") {
+            seen.decryptCalls.push(prop);
+          }
+          return value.apply(target, args);
+        };
+      }
+      return value;
+    }
+  });
+}
+function runFormatConformanceTests(name, fixture) {
+  describe(`${name} \u2014 as-* export gate conformance`, () => {
+    it("declares a tier, and a format iff the tier needs one", () => {
+      if (fixture.tier === "plaintext") {
+        expect(fixture.format, "the plaintext tier requires a format").toBeTruthy();
+      } else {
+        expect(fixture.format, `the '${fixture.tier}' tier takes no format`).toBeUndefined();
+      }
+    });
+    it("declares at least one export entry point", () => {
+      expect(fixture.exports.length).toBeGreaterThan(0);
+    });
+    it("the fixture vault CAN export \u2014 otherwise every refusal below is free", async () => {
+      const vault = await fixture.vault();
+      await expect(
+        fixture.exports[0].run(vault),
+        `${fixture.exports[0].name} failed on an ungated vault \u2014 check the \`format\` tag and the exportCapability grant`
+      ).resolves.toBeDefined();
+    });
+    for (const entry of fixture.exports) {
+      it(`${entry.name}: REFUSES when assertCanExport denies`, async () => {
+        const seen = { decryptCalls: [] };
+        const vault = denyingVault(await fixture.vault(), fixture.tier, fixture.format, seen);
+        await expect(entry.run(vault)).rejects.toThrow();
+      });
+      it(`${entry.name}: refuses BEFORE reading any record`, async () => {
+        const seen = { decryptCalls: [] };
+        const vault = denyingVault(await fixture.vault(), fixture.tier, fixture.format, seen);
+        await expect(entry.run(vault)).rejects.toThrow();
+        expect(
+          seen.decryptCalls,
+          `${entry.name} read records before the export gate refused`
+        ).toEqual([]);
+      });
+    }
+    const writeTitle = fixture.writeWithoutAcknowledgement ? "write: REFUSES without acknowledgeRisks" : "write: SKIPPED \u2014 fixture declares no acknowledgement case, so the plaintext-on-disk gate is UNVERIFIED here";
+    it(writeTitle, async () => {
+      const write = fixture.writeWithoutAcknowledgement;
+      if (!write) {
+        expect(write).toBeUndefined();
+        return;
+      }
+      const vault = await fixture.vault();
+      await expect(write(vault, "/tmp/conformance-should-not-exist")).rejects.toThrow(
+        /acknowledgeRisks/i
+      );
+    });
+  });
+}
+export {
+  ExportDeniedByConformanceKit,
+  runFormatConformanceTests
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * **@noy-db/test-format-conformance** — the `as-*` export gate, published as\n * an executable suite.\n *\n * The `as-*` family is the one place plaintext leaves the vault. Each package\n * calls `vault.assertCanExport('plaintext', <format>)` before producing\n * anything, and that call is the whole security boundary: a projection that\n * skips it hands out decrypted records to a caller the vault would have\n * refused.\n *\n * Nothing enforced it. Nine packages had converged on the same shape by\n * convention — `toString`/`toBytes`, `download`, `write` — and convention is\n * what the next format author reads instead of a contract.\n *\n * ## Gated is not the property. Gated BEFORE decrypting is.\n *\n * A gate called after `exportStream` has already run is a gate that refuses\n * the caller and decrypts anyway. So the suite asserts BOTH:\n *\n *   - every export entry point REJECTS when `assertCanExport` throws, and\n *   - it rejects having read NOTHING — `exportStream` is never called.\n *\n * The second is the one a delegation refactor breaks silently: move the gate\n * from `toObject` into `download` and every existing test still passes.\n *\n * ## Why a Proxy and not a fake Vault\n *\n * `Vault` is large, and a hand-written double would drift from it — and worse,\n * would only ever exercise the methods whoever wrote the double thought of.\n * The fixture supplies a REAL vault; the kit wraps it, so an entry point that\n * reaches for some other decrypting method is still observed.\n *\n * @packageDocumentation\n */\nimport { describe, it, expect } from 'vitest'\nimport type { Vault, ExportFormat } from '@noy-db/hub'\n\n/** One plaintext-producing entry point, named as a consumer would call it. */\nexport interface FormatEntryPoint {\n  /** Exported function name, e.g. `'toString'`. Used in the test title. */\n  readonly name: string\n  /** Call it against the supplied vault. Arguments are the fixture's business. */\n  run(vault: Vault): Promise<unknown>\n}\n\n/** Everything an `as-*` package must supply to be checked against the gate. */\nexport interface FormatFixture {\n  /**\n   * The TIER the package passes to `assertCanExport`. The `as-*` family is\n   * two capability classes, not one — discovered by wiring `as-noydb`, which\n   * calls `assertCanExport('bundle')` and never mentions plaintext because it\n   * emits an encrypted pod. A kit that assumed one tier would have made that\n   * fixture describe itself wrongly while still passing.\n   */\n  readonly tier: 'plaintext' | 'bundle'\n  /**\n   * The format tag, e.g. `'csv'`. REQUIRED for the plaintext tier and\n   * meaningless for `bundle` — hub itself throws when a plaintext check\n   * arrives without one, so the pairing is asserted rather than assumed.\n   */\n  readonly format?: ExportFormat\n  /**\n   * A REAL vault with at least one record. Built fresh per case, so an entry\n   * point that mutates it cannot leak into the next assertion.\n   */\n  vault(): Promise<Vault>\n  /**\n   * EVERY entry point that can produce plaintext — not a representative one.\n   * A format with four exports and one listed here reports a green suite for\n   * the three nobody checked.\n   */\n  readonly exports: ReadonlyArray<FormatEntryPoint>\n  /**\n   * The on-disk write path, if the package has one. It must refuse without\n   * `acknowledgeRisks: true`; pass a call that OMITS the flag.\n   *\n   * The vault this receives is the fixture's own — NOT the denying proxy —\n   * and it must be export-CAPABLE. A vault that would refuse the export\n   * anyway makes the case unfalsifiable: the refusal arrives from the gate\n   * upstream and the acknowledgement is never reached. That is not\n   * hypothetical; it is what the first version of this kit did, and deleting\n   * the acknowledgement guard from as-csv left the suite green.\n   */\n  writeWithoutAcknowledgement?: (vault: Vault, path: string) => Promise<unknown>\n}\n\n/** Thrown by the denying proxy so a refusal is attributable to the gate. */\nexport class ExportDeniedByConformanceKit extends Error {\n  constructor(tier: string, format?: string) {\n    super(`conformance: assertCanExport denied '${tier}'${format ? ` / '${format}'` : ''}`)\n    this.name = 'ExportDeniedByConformanceKit'\n  }\n}\n\ninterface Observation {\n  decryptCalls: string[]\n}\n\n/**\n * Wrap a real vault so `assertCanExport` denies, and every method that could\n * yield plaintext records is recorded.\n *\n * `exportStream` is named explicitly because it is the shared read path; the\n * catch-all records any other function property that gets invoked, so an entry\n * point taking a different route is still visible rather than silently\n * unobserved.\n */\nfunction denyingVault(real: Vault, tier: string, format: string | undefined, seen: Observation): Vault {\n  return new Proxy(real, {\n    get(target, prop, receiver) {\n      if (prop === 'assertCanExport') {\n        return () => {\n          throw new ExportDeniedByConformanceKit(tier, format)\n        }\n      }\n      const value = Reflect.get(target, prop, receiver) as unknown\n      if (typeof value === 'function' && typeof prop === 'string') {\n        return (...args: unknown[]) => {\n          if (prop === 'exportStream' || prop === 'export' || prop === 'snapshot') {\n            seen.decryptCalls.push(prop)\n          }\n          return (value as (...a: unknown[]) => unknown).apply(target, args)\n        }\n      }\n      return value\n    },\n  }) as Vault\n}\n\n/**\n * Run the shared `as-*` export-gate contract against one format.\n *\n * @param name - shown in the suite title, e.g. `'as-csv'`.\n */\nexport function runFormatConformanceTests(name: string, fixture: FormatFixture): void {\n  describe(`${name} — as-* export gate conformance`, () => {\n    it('declares a tier, and a format iff the tier needs one', () => {\n      // Hub throws on `assertCanExport('plaintext')` with no format, so a\n      // fixture in that state describes a call the package cannot be making.\n      if (fixture.tier === 'plaintext') {\n        expect(fixture.format, 'the plaintext tier requires a format').toBeTruthy()\n      } else {\n        expect(fixture.format, `the '${fixture.tier}' tier takes no format`).toBeUndefined()\n      }\n    })\n\n    it('declares at least one export entry point', () => {\n      // A fixture with an empty list would pass every case below without\n      // running anything — a live suite iterating an empty array.\n      expect(fixture.exports.length).toBeGreaterThan(0)\n    })\n\n    it('the fixture vault CAN export — otherwise every refusal below is free', async () => {\n      // The whole suite tests refusals, and a refusal is only evidence when\n      // the same call would otherwise SUCCEED. A fixture whose `format` tag\n      // does not match what the package passes to `assertCanExport` — or\n      // which forgets the `exportCapability` grant — makes every case below\n      // pass by refusing for the wrong reason, and nothing in the output\n      // distinguishes that from a working gate.\n      const vault = await fixture.vault()\n      await expect(\n        fixture.exports[0]!.run(vault),\n        `${fixture.exports[0]!.name} failed on an ungated vault — check the \\`format\\` tag and the exportCapability grant`,\n      ).resolves.toBeDefined()\n    })\n\n    for (const entry of fixture.exports) {\n      it(`${entry.name}: REFUSES when assertCanExport denies`, async () => {\n        const seen: Observation = { decryptCalls: [] }\n        const vault = denyingVault(await fixture.vault(), fixture.tier, fixture.format, seen)\n        await expect(entry.run(vault)).rejects.toThrow()\n      })\n\n      it(`${entry.name}: refuses BEFORE reading any record`, async () => {\n        const seen: Observation = { decryptCalls: [] }\n        const vault = denyingVault(await fixture.vault(), fixture.tier, fixture.format, seen)\n        await expect(entry.run(vault)).rejects.toThrow()\n        // The property that a delegation refactor breaks silently: a gate\n        // moved downstream still refuses the caller, having already decrypted.\n        expect(\n          seen.decryptCalls,\n          `${entry.name} read records before the export gate refused`,\n        ).toEqual([])\n      })\n    }\n\n    const writeTitle = fixture.writeWithoutAcknowledgement\n      ? 'write: REFUSES without acknowledgeRisks'\n      : 'write: SKIPPED — fixture declares no acknowledgement case, so the plaintext-on-disk gate is UNVERIFIED here'\n\n    it(writeTitle, async () => {\n      const write = fixture.writeWithoutAcknowledgement\n      if (!write) {\n        // Passes loudly. Omitting the case would make an unchecked security\n        // gate indistinguishable from a checked one in the output.\n        expect(write).toBeUndefined()\n        return\n      }\n      const vault = await fixture.vault()\n      // Matched on the MESSAGE, not merely on \"it threw\". `rejects.toThrow()`\n      // alone passes when the export gate refuses first — which is exactly\n      // what happened here before this line existed, and it made the case\n      // unable to fail. The flag name is the one string every such message\n      // contains by construction.\n      await expect(write(vault, '/tmp/conformance-should-not-exist')).rejects.toThrow(\n        /acknowledgeRisks/i,\n      )\n    })\n  })\n}\n"],"mappings":";AAkCA,SAAS,UAAU,IAAI,cAAc;AAqD9B,IAAM,+BAAN,cAA2C,MAAM;AAAA,EACtD,YAAY,MAAc,QAAiB;AACzC,UAAM,wCAAwC,IAAI,IAAI,SAAS,OAAO,MAAM,MAAM,EAAE,EAAE;AACtF,SAAK,OAAO;AAAA,EACd;AACF;AAeA,SAAS,aAAa,MAAa,MAAc,QAA4B,MAA0B;AACrG,SAAO,IAAI,MAAM,MAAM;AAAA,IACrB,IAAI,QAAQ,MAAM,UAAU;AAC1B,UAAI,SAAS,mBAAmB;AAC9B,eAAO,MAAM;AACX,gBAAM,IAAI,6BAA6B,MAAM,MAAM;AAAA,QACrD;AAAA,MACF;AACA,YAAM,QAAQ,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AAChD,UAAI,OAAO,UAAU,cAAc,OAAO,SAAS,UAAU;AAC3D,eAAO,IAAI,SAAoB;AAC7B,cAAI,SAAS,kBAAkB,SAAS,YAAY,SAAS,YAAY;AACvE,iBAAK,aAAa,KAAK,IAAI;AAAA,UAC7B;AACA,iBAAQ,MAAuC,MAAM,QAAQ,IAAI;AAAA,QACnE;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAAA,EACF,CAAC;AACH;AAOO,SAAS,0BAA0B,MAAc,SAA8B;AACpF,WAAS,GAAG,IAAI,wCAAmC,MAAM;AACvD,OAAG,wDAAwD,MAAM;AAG/D,UAAI,QAAQ,SAAS,aAAa;AAChC,eAAO,QAAQ,QAAQ,sCAAsC,EAAE,WAAW;AAAA,MAC5E,OAAO;AACL,eAAO,QAAQ,QAAQ,QAAQ,QAAQ,IAAI,wBAAwB,EAAE,cAAc;AAAA,MACrF;AAAA,IACF,CAAC;AAED,OAAG,4CAA4C,MAAM;AAGnD,aAAO,QAAQ,QAAQ,MAAM,EAAE,gBAAgB,CAAC;AAAA,IAClD,CAAC;AAED,OAAG,6EAAwE,YAAY;AAOrF,YAAM,QAAQ,MAAM,QAAQ,MAAM;AAClC,YAAM;AAAA,QACJ,QAAQ,QAAQ,CAAC,EAAG,IAAI,KAAK;AAAA,QAC7B,GAAG,QAAQ,QAAQ,CAAC,EAAG,IAAI;AAAA,MAC7B,EAAE,SAAS,YAAY;AAAA,IACzB,CAAC;AAED,eAAW,SAAS,QAAQ,SAAS;AACnC,SAAG,GAAG,MAAM,IAAI,yCAAyC,YAAY;AACnE,cAAM,OAAoB,EAAE,cAAc,CAAC,EAAE;AAC7C,cAAM,QAAQ,aAAa,MAAM,QAAQ,MAAM,GAAG,QAAQ,MAAM,QAAQ,QAAQ,IAAI;AACpF,cAAM,OAAO,MAAM,IAAI,KAAK,CAAC,EAAE,QAAQ,QAAQ;AAAA,MACjD,CAAC;AAED,SAAG,GAAG,MAAM,IAAI,uCAAuC,YAAY;AACjE,cAAM,OAAoB,EAAE,cAAc,CAAC,EAAE;AAC7C,cAAM,QAAQ,aAAa,MAAM,QAAQ,MAAM,GAAG,QAAQ,MAAM,QAAQ,QAAQ,IAAI;AACpF,cAAM,OAAO,MAAM,IAAI,KAAK,CAAC,EAAE,QAAQ,QAAQ;AAG/C;AAAA,UACE,KAAK;AAAA,UACL,GAAG,MAAM,IAAI;AAAA,QACf,EAAE,QAAQ,CAAC,CAAC;AAAA,MACd,CAAC;AAAA,IACH;AAEA,UAAM,aAAa,QAAQ,8BACvB,4CACA;AAEJ,OAAG,YAAY,YAAY;AACzB,YAAM,QAAQ,QAAQ;AACtB,UAAI,CAAC,OAAO;AAGV,eAAO,KAAK,EAAE,cAAc;AAC5B;AAAA,MACF;AACA,YAAM,QAAQ,MAAM,QAAQ,MAAM;AAMlC,YAAM,OAAO,MAAM,OAAO,mCAAmC,CAAC,EAAE,QAAQ;AAAA,QACtE;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH;","names":[]}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@noy-db/test-format-conformance",
+  "version": "0.7.0-pre.0",
+  "description": "Parameterized contract tests for noy-db as-* formats — the export-gate suite every plaintext projection must pass",
+  "license": "MIT",
+  "author": "vLannaAi <vicio@lanna.ai>",
+  "homepage": "https://github.com/vLannaAi/noy-db/tree/main/packages/test-format-conformance#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vLannaAi/noy-db.git",
+    "directory": "packages/test-format-conformance"
+  },
+  "bugs": {
+    "url": "https://github.com/vLannaAi/noy-db/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "peerDependencies": {
+    "vitest": "^3.0.0",
+    "@noy-db/hub": "0.7.0-pre.0"
+  },
+  "devDependencies": {
+    "vitest": "^3.0.0",
+    "@noy-db/hub": "0.7.0-pre.0"
+  },
+  "keywords": [
+    "noy-db",
+    "conformance",
+    "export",
+    "plaintext",
+    "testing"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit"
+  }
+}