@dral/toml-tests 5.0.0

package/AGENTS.md

@@ -0,0 +1,58 @@
+# Agent Instructions
+
+## Project overview
+
+This is `@dral/toml-tests`, a small framework-agnostic TypeScript library that parses TOML files describing test suites and runs them against a user-provided function. The caller provides their own test framework bindings (`describe`, `it`, `equal`) via a `TestHarness` interface.
+
+## Repository layout
+
+```
+src/
+  index.ts          Main module — exports toml_test(), TomlTestFn, TomlValue, TestHarness
+  index.test.ts     Tests for the utility itself (uses node:test)
+  tsconfig.json     Source config — extends @dral/tsconfig, noEmit
+fixtures/
+  basic.toml        Named suites, options merging, nesting
+  nameless-suite.toml  Nameless suites for option grouping
+  non-toml-result.toml  Non-TOML type detection
+package.json        ESM package, "type": "module"
+pnpm-workspace.yaml Allows esbuild build scripts
+tsconfig.json       Root — references src and test configs
+tsconfig.test.json  Test config — includes node types, noEmit
+dist/               Build output (gitignored)
+```
+
+## Key concepts
+
+- **Framework-agnostic**: The library does not import `node:test` or `node:fs`. The caller passes in a `TestHarness` with `describe`, `it`, and `equal` from whatever framework they use.
+- **TOML test document**: A recursive `TestSuite` structure with optional `name`, `options`, `tests`, and `suites` fields. Parsed by `smol-toml`.
+- **Flexible input**: Test case `input` accepts any TOML-expressible value (`TomlValue`) — strings, numbers, booleans, dates, arrays, or objects. When `name` is omitted, `String(input)` is used as the test name.
+- **Options merging**: Shallow merge from outer to inner: `{ ...parentOptions, ...childOptions }`.
+- **Named vs nameless suites**: Named suites create `describe()` blocks. Nameless suites are transparent — their contents appear at the parent level.
+- **Assertion types**: Each test must have exactly one of `output` (deep-compare return value), `throws` (`true` for any error, or a regex-pattern string to match the error message), or `doesntThrow` (`true` to assert no error is thrown; return value is ignored).
+- **Non-TOML detection**: Before comparing results, the utility checks that the function's return value only contains TOML-expressible types. Non-TOML values cause an explicit failure with dot-path locations.
+- **Source line numbers**: A supplementary scanner maps `[[tests]]` headers to line numbers. On failure, errors include `source:line` or `line N` in the message. The `smol-toml` parse output remains the sole source of truth for test data.
+
+## Commands
+
+- `pnpm test` — Run tests with `node --test --experimental-strip-types`
+- `pnpm run typecheck` — Type-check source and tests
+- `pnpm run build` — Bundle with `@dral/bundle` into `dist/`
+
+## Conventions
+
+- **pnpm** as the package manager (not npm)
+- ESM throughout (`"type": "module"`, `import`/`export`)
+- TypeScript strict mode with `verbatimModuleSyntax`
+- Use `.ts` extensions in local imports (required by `--experimental-strip-types`)
+- Source code (`src/index.ts`) has zero Node.js dependencies — only `smol-toml` and `zod`
+- Tests use `node:test` and `node:assert` via the harness pattern
+- `smol-toml` for TOML parsing (lightweight, spec-compliant)
+- `@dral/bundle` for building — compiles TypeScript, generates declarations, rewrites package.json exports
+
+## When modifying
+
+- Keep the public API surface small: `toml_test`, `TomlTestFn`, `TomlValue`, `TestHarness`.
+- The TOML schema is the contract — changes to it affect all consumers.
+- Source tsconfig extends `@dral/tsconfig` — source must not depend on `@types/node`.
+- Run `pnpm run typecheck` and `pnpm test` to verify before committing.

package/README.md

@@ -0,0 +1,294 @@
+# toml-test
+
+A framework-agnostic testing utility that parses TOML test suites and runs them against a function. Define test cases and expected outputs in TOML, pass in your test framework's `describe`/`it`/`equal`, and `toml_test` registers everything for you.
+
+## Install
+
+```bash
+npm install toml-test
+```
+
+## Usage
+
+```typescript
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+import { readFile } from "node:fs/promises";
+import { toml_test } from "toml-test";
+import type { TestHarness, TomlValue } from "toml-test";
+
+const harness: TestHarness = {
+  describe,
+  it,
+  equal: assert.deepStrictEqual,
+};
+
+const toml = await readFile("./tests/my-parser.toml", "utf-8");
+
+toml_test(
+  toml,
+  (input, options) => {
+    return myParser(input, options);
+  },
+  harness,
+  "my-parser.toml",
+);
+```
+
+Run with Node's test runner:
+
+```bash
+node --test src/**/*.test.ts
+```
+
+Works with any framework that provides `describe`, `it`, and a deep-equal assertion — node:test, vitest, jest, mocha, etc.
+
+## TOML test file format
+
+Test files use **TOML 1.1**, which allows multiline inline tables — handy for writing expected output that is a nested object. Parsed by [`smol-toml`](https://github.com/nicolo-ribaudo/smol-toml) which supports TOML 1.1.
+
+```toml
+[[tests]]
+name = "string input"
+input = "hello world"
+output = "HELLO WORLD"
+
+[[tests]]
+name = "numeric input"
+input = 42
+output = 84
+
+[[tests]]
+name = "boolean input"
+input = true
+output = false
+
+[[tests]]
+name = "object input"
+input = { x = 1, y = 2 }
+output = 3
+
+[[tests]]
+name = "array input"
+input = [10, 20, 30]
+output = 60
+
+
+[[suites]]
+name = "JSON parsing"
+
+[[suites.tests]]
+name = "One-key object"
+input = '{ "key": "value" }'
+output = { key = "value" }
+
+[[suites.tests]]
+name = "Complex"
+input = """
+{
+ 	"number": 10,
+ 	"object": {
+		"nested": {
+			"key": "}"
+		}
+	}
+}"""
+output = {
+	number = 10,
+	object = {
+		nested = {
+			key = "}"
+		}
+	}
+}
+```
+
+### Schema
+
+```typescript
+interface TestCase {
+  name?: string;
+  input: TomlValue;
+  options?: Record<string, TomlValue>;
+  // Exactly one of the following three:
+  output?: TomlValue;
+  throws?: true | string;
+  doesntThrow?: true;
+}
+
+interface TestSuite {
+  name?: string;
+  options?: Record<string, TomlValue>;
+  tests?: TestCase[];
+  suites?: TestSuite[];
+}
+```
+
+### Assertion types
+
+Each test case must have **exactly one** of `output`, `throws`, or `doesntThrow`.
+
+#### `output` — compare return value
+
+The function's return value is deep-compared against the expected value. Non-TOML-expressible values in the result cause an explicit failure (see [Non-TOML result detection](#non-toml-result-detection)).
+
+```toml
+[[tests]]
+name = "uppercases input"
+input = "hello"
+output = "HELLO"
+```
+
+#### `throws` — expect an error
+
+Set `throws = true` to assert that the function throws any error. Set `throws` to a string to assert that the error message matches a regular expression pattern.
+
+```toml
+[[tests]]
+name = "rejects bad input"
+input = "bad"
+throws = true
+
+[[tests]]
+name = "error message matches pattern"
+input = "bad"
+throws = "invalid.*format"
+```
+
+#### `doesntThrow` — expect no error
+
+Set `doesntThrow = true` to assert that the function completes without throwing. The return value is ignored — only the absence of an error is checked.
+
+```toml
+[[tests]]
+name = "handles edge case gracefully"
+input = ""
+doesntThrow = true
+```
+
+### Options merging
+
+Options are **shallowly merged** from outer to inner scope:
+
+```
+{ ...fileSuiteOptions, ...nestedSuiteOptions, ..., ...testOptions }
+```
+
+This lets you set defaults at the file level and override per-suite or per-test.
+
+### Named vs nameless suites
+
+- A suite **with a `name`** creates a `describe()` block in the test output.
+- A suite **without a `name`** does not create any grouping — its tests and sub-suites appear at the parent's nesting level. Use nameless suites to combine options or split tests across files without adding noise to the output.
+
+## Non-TOML result detection
+
+If the function under test returns a value containing types that cannot be expressed in TOML (`undefined`, `null`, `Symbol`, `Function`, `Set`, `Map`, `RegExp`, class instances, etc.), the test fails with a message listing the offending paths:
+
+```
+my-parser.toml:12: Result contains non-TOML-expressible values at: result.foo, result.items[2].bar
+```
+
+This catches accidental leakage of internal types into what should be a plain-data result.
+
+## Source line numbers
+
+When a test fails, the error message includes the line number in the TOML file where the test case was defined. If you pass a `source` label (typically the filename), errors use `source:line` format:
+
+```
+my-parser.toml:12: Expected values to be strictly deep-equal
+```
+
+Without a source label, errors use `line N` format:
+
+```
+line 12: Expected values to be strictly deep-equal
+```
+
+## API
+
+### `toml_test(toml, fn, harness, source?)`
+
+```typescript
+function toml_test(
+  toml: string,
+  fn: TomlTestFn,
+  harness: TestHarness,
+  source?: string,
+): void;
+```
+
+Parses a TOML test document and registers test suites/cases using the provided harness.
+
+- **toml** — TOML source string describing the test suite
+- **fn** — the function under test, called as `fn(input, mergedOptions)`
+- **harness** — test framework bindings (`describe`, `it`, `equal`)
+- **source** — optional label (e.g. filename) included in error messages
+
+### `TestHarness`
+
+```typescript
+interface TestHarness {
+  describe: (name: string, fn: () => void) => void;
+  it: (name: string, fn: () => void) => void;
+  equal: (actual: unknown, expected: unknown) => void;
+}
+```
+
+### `TomlTestFn`
+
+```typescript
+type TomlTestFn = (input: TomlValue, options: any) => any;
+```
+
+The `input` can be any TOML-expressible value — string, number, boolean, Date, array, or object. This allows test cases to pass structured data directly:
+
+```toml
+[[tests]]
+name = "string input"
+input = "hello"
+output = "HELLO"
+
+[[tests]]
+name = "numeric input"
+input = 42
+output = 84
+
+[[tests]]
+name = "object input"
+input = { x = 1, y = 2 }
+output = 3
+
+[[tests]]
+name = "array input"
+input = [1, 2, 3]
+output = 6
+```
+
+### `TomlValue`
+
+```typescript
+type TomlValue =
+  | string
+  | number
+  | bigint
+  | boolean
+  | Date
+  | TomlValue[]
+  | { [key: string]: TomlValue };
+```
+
+Represents any value expressible in TOML. Used for both `input` and `output` fields in test cases.
+
+## Development
+
+```bash
+npm install
+npm test                      # run tests
+npx tsc --noEmit -p tsconfig.src.json   # type-check source (no node types)
+npx tsc --noEmit -p tsconfig.test.json  # type-check tests
+```
+
+## License
+
+ISC

package/fixtures/basic.toml

@@ -0,0 +1,34 @@
+name = "String utilities"
+
+[options]
+trim = false
+
+[[tests]]
+name = "returns input as-is"
+input = "hello"
+output = "hello"
+
+[[tests]]
+name = "returns input with option override"
+input = "  hello  "
+output = "hello"
+[tests.options]
+trim = true
+
+[[suites]]
+name = "Uppercase suite"
+
+[suites.options]
+uppercase = true
+
+[[suites.tests]]
+name = "uppercases input"
+input = "hello"
+output = "HELLO"
+
+[[suites.tests]]
+name = "uppercases and trims"
+input = "  hello  "
+output = "HELLO"
+[suites.tests.options]
+trim = true

package/fixtures/nameless-suite.toml

@@ -0,0 +1,19 @@
+# Top-level suite has no name — tests should appear at root level
+
+[options]
+prefix = ">"
+
+[[tests]]
+name = "prepends prefix"
+input = "hello"
+output = ">hello"
+
+[[suites]]
+# This nested suite also has no name — just provides extra options
+[suites.options]
+suffix = "<"
+
+[[suites.tests]]
+name = "prepends prefix and appends suffix"
+input = "hello"
+output = ">hello<"

package/fixtures/non-toml-result.toml

@@ -0,0 +1,11 @@
+name = "Non-TOML detection"
+
+[[tests]]
+name = "should fail when result has undefined"
+input = "return-undefined"
+output = "should not match"
+
+[[tests]]
+name = "should fail when result has a function"
+input = "return-function"
+output = "should not match"

package/fixtures/throws.toml

@@ -0,0 +1,16 @@
+name = "Throws tests"
+
+[[tests]]
+name = "throws on bad input"
+input = "bad"
+throws = true
+
+[[tests]]
+name = "throws matching pattern"
+input = "bad"
+throws = "went wrong"
+
+[[tests]]
+name = "doesnt throw on good input"
+input = "good"
+doesntThrow = true

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@dral/toml-tests",
+  "version": "5.0.0",
+  "description": "Testing utility that loads TOML test suites and runs them against a function",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "smol-toml": "^1.6.0",
+    "zod": "^4.3.6"
+  },
+  "packageManager": "pnpm@12.0.0"
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,3 @@
+allowBuilds:
+  esbuild: true
+minimumReleaseAge: 0

package/src/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A value expressible in TOML: primitives, Dates, arrays, or string-keyed objects thereof.
+ */
+export type TomlValue = string | number | bigint | boolean | Date | TomlValue[] | {
+    [key: string]: TomlValue;
+};
+/**
+ * Type alias for the function under test.
+ * Generic over Input, Options, and Output so callers can narrow the types.
+ * Defaults preserve backward compatibility with untyped usage.
+ */
+export type TomlTestFn<Input extends TomlValue = TomlValue, Options extends Record<string, TomlValue> = Record<string, TomlValue>, Output extends TomlValue = TomlValue> = (input: Input, options: Options) => Output | Promise<Output>;
+/**
+ * Framework-agnostic test harness interface.
+ * The caller provides these functions from whatever test framework they use
+ * (node:test, vitest, jest, mocha, etc.).
+ */
+export interface TestHarness {
+    /** Register a test suite / group (like `describe` in most frameworks) */
+    describe: (name: string, fn: () => void) => void;
+    /** Register a single test case (like `it` or `test`) */
+    it: (name: string, fn: () => void | Promise<void>) => void;
+    /**
+     * Assert deep equality between actual and expected values.
+     * Should throw on mismatch.
+     */
+    equal: (actual: unknown, expected: unknown) => void;
+}
+/**
+ * Parses a TOML test document and registers test suites/cases using the
+ * provided test harness. Framework-agnostic — works with node:test, vitest,
+ * jest, mocha, or any framework that provides describe/it/equal.
+ *
+ * @param toml - TOML source string describing the test suite
+ * @param fn - The function under test
+ * @param harness - Test framework bindings (describe, it, equal)
+ * @param source - Optional source label (e.g. filename) for error messages
+ */
+export declare function toml_test<Input extends TomlValue = TomlValue, Options extends Record<string, TomlValue> = Record<string, TomlValue>, Output extends TomlValue = TomlValue>(toml: string, fn: TomlTestFn<Input, Options, Output>, harness: TestHarness, source?: string): void;

package/src/index.js

@@ -0,0 +1,229 @@
+import { parse } from "smol-toml";
+import { z } from "zod";
+var TomlValueSchema = z.lazy(
+  () => z.union([
+    z.string(),
+    z.number(),
+    z.bigint(),
+    z.boolean(),
+    z.instanceof(Date),
+    z.array(TomlValueSchema),
+    z.record(z.string(), TomlValueSchema)
+  ])
+);
+var TestCaseSchema = z.object({
+  name: z.string().optional(),
+  input: TomlValueSchema,
+  output: TomlValueSchema.optional(),
+  throws: z.union([z.literal(true), z.string()]).optional(),
+  doesntThrow: z.literal(true).optional(),
+  options: z.record(z.string(), TomlValueSchema).optional()
+}).refine(
+  (t) => {
+    const count = [
+      t.output !== void 0,
+      t.throws !== void 0,
+      t.doesntThrow !== void 0
+    ].filter(Boolean).length;
+    return count === 1;
+  },
+  {
+    message: "Each test must have exactly one of: output, throws, or doesntThrow"
+  }
+);
+var TestSuiteSchema = z.lazy(
+  () => z.object({
+    name: z.string().optional(),
+    options: z.record(z.string(), TomlValueSchema).optional(),
+    tests: z.array(TestCaseSchema).optional(),
+    suites: z.array(TestSuiteSchema).optional()
+  })
+);
+function scanTestLines(toml) {
+  const lines = toml.split("\n");
+  const headerRegex = /^\s*\[\[(.+?)\]\]\s*$/;
+  const headers = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line) {
+      const match = line.match(headerRegex);
+      if (match && match[1]) {
+        headers.push({ path: match[1].trim(), line: i + 1 });
+      }
+    }
+  }
+  const root = { testLines: [], suiteLines: [] };
+  for (const { path, line } of headers) {
+    const segments = path.split(".");
+    let current = root;
+    for (let i = 0; i < segments.length - 1; i++) {
+      const seg = segments[i];
+      if (seg === "suites") {
+        if (current.suiteLines.length > 0) {
+          current = current.suiteLines[current.suiteLines.length - 1];
+        }
+      }
+    }
+    const lastSegment = segments[segments.length - 1];
+    if (lastSegment === "tests") {
+      current.testLines.push(line);
+    } else if (lastSegment === "suites") {
+      current.suiteLines.push({ testLines: [], suiteLines: [] });
+    }
+  }
+  return root;
+}
+function findNonTomlPaths(value, path = "result") {
+  const nonTomlPaths = [];
+  function isPlainObject(obj) {
+    if (obj === null || typeof obj !== "object") return false;
+    const proto = Object.getPrototypeOf(obj);
+    return proto === Object.prototype || proto === null;
+  }
+  function isTomlExpressible(val) {
+    const type = typeof val;
+    if (type === "string" || type === "number" || type === "bigint" || type === "boolean") {
+      return true;
+    }
+    if (val instanceof Date) {
+      return true;
+    }
+    if (val === null) {
+      return false;
+    }
+    if (Array.isArray(val)) {
+      return true;
+    }
+    if (isPlainObject(val)) {
+      return true;
+    }
+    return false;
+  }
+  function walk(val, currentPath) {
+    if (!isTomlExpressible(val)) {
+      nonTomlPaths.push(currentPath);
+      return;
+    }
+    if (Array.isArray(val)) {
+      for (let i = 0; i < val.length; i++) {
+        walk(val[i], `${currentPath}[${i}]`);
+      }
+      return;
+    }
+    if (val !== null && typeof val === "object" && isPlainObject(val)) {
+      for (const [key, value2] of Object.entries(
+        val
+      )) {
+        walk(value2, `${currentPath}.${key}`);
+      }
+      return;
+    }
+  }
+  walk(value, path);
+  return nonTomlPaths;
+}
+function processSuite(suite, parentOptions, fn, harness, lineInfo, source) {
+  const suiteOptions = suite.options ?? {};
+  const mergedOptions = { ...parentOptions, ...suiteOptions };
+  const runContents = () => {
+    const tests = suite.tests;
+    if (Array.isArray(tests)) {
+      for (let testIndex = 0; testIndex < tests.length; testIndex++) {
+        const test = tests[testIndex];
+        const t = test;
+        const testName = t.name ?? String(t.input);
+        harness.it(testName, async () => {
+          const testOptions = t.options ?? {};
+          const finalOptions = { ...mergedOptions, ...testOptions };
+          const line = lineInfo.testLines[testIndex];
+          const location = line ? source ? `${source}:${line}` : `line ${line}` : void 0;
+          try {
+            const actual = await fn(t.input, finalOptions);
+            const hasOutput = t.output !== void 0;
+            const hasThrows = t.throws !== void 0;
+            const hasDoesntThrow = t.doesntThrow !== void 0;
+            if (hasOutput) {
+              const nonTomlPaths = findNonTomlPaths(actual);
+              if (nonTomlPaths.length > 0) {
+                throw new Error(
+                  `Result contains non-TOML-expressible values at: ${nonTomlPaths.join(", ")}`
+                );
+              }
+              harness.equal(actual, t.output);
+            } else if (hasThrows) {
+              throw new Error("Expected function to throw");
+            } else if (hasDoesntThrow) {
+            }
+          } catch (err) {
+            const hasThrows = t.throws !== void 0;
+            if (hasThrows && err instanceof Error) {
+              const throwsValue = t.throws;
+              if (throwsValue === true) {
+                return;
+              } else if (typeof throwsValue === "string") {
+                const pattern = new RegExp(throwsValue);
+                if (pattern.test(err.message)) {
+                  return;
+                } else {
+                  const newErr = new Error(
+                    `Expected error message to match pattern "${throwsValue}", but got: "${err.message}"`
+                  );
+                  if (location) {
+                    newErr.message = `${location}: ${newErr.message}`;
+                  }
+                  throw newErr;
+                }
+              }
+            }
+            if (err instanceof Error && location) {
+              err.message = `${location}: ${err.message}`;
+            }
+            throw err;
+          }
+        });
+      }
+    }
+    const suites = suite.suites;
+    if (Array.isArray(suites)) {
+      for (let suiteIndex = 0; suiteIndex < suites.length; suiteIndex++) {
+        const nestedSuite = suites[suiteIndex];
+        const nestedLineInfo = lineInfo.suiteLines[suiteIndex] ?? {
+          testLines: [],
+          suiteLines: []
+        };
+        processSuite(
+          nestedSuite,
+          mergedOptions,
+          fn,
+          harness,
+          nestedLineInfo,
+          source
+        );
+      }
+    }
+  };
+  if (suite.name && typeof suite.name === "string") {
+    harness.describe(suite.name, runContents);
+  } else {
+    runContents();
+  }
+}
+function toml_test(toml, fn, harness, source) {
+  const suite = parse(toml);
+  const lineInfo = scanTestLines(toml);
+  const validationResult = TestSuiteSchema.safeParse(suite);
+  if (!validationResult.success) {
+    for (const issue of validationResult.error.issues) {
+      const path = issue.path.length > 0 ? issue.path.join(".") : "root";
+      const errorMessage = `Validation error at ${path}: ${issue.message}`;
+      harness.it(`Schema validation error: ${path}`, () => {
+        throw new Error(errorMessage);
+      });
+    }
+    return;
+  }
+  processSuite(suite, {}, fn, harness, lineInfo, source);
+}
+export {
+  toml_test
+};

package/src/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": ["import { parse } from \"smol-toml\";\nimport { z } from \"zod\";\n\n/**\n * A value expressible in TOML: primitives, Dates, arrays, or string-keyed objects thereof.\n */\nexport type TomlValue =\n  | string\n  | number\n  | bigint\n  | boolean\n  | Date\n  | TomlValue[]\n  | { [key: string]: TomlValue };\n\n/**\n * Type alias for the function under test.\n * Generic over Input, Options, and Output so callers can narrow the types.\n * Defaults preserve backward compatibility with untyped usage.\n */\nexport type TomlTestFn<\n  Input extends TomlValue = TomlValue,\n  Options extends Record<string, TomlValue> = Record<string, TomlValue>,\n  Output extends TomlValue = TomlValue,\n> = (input: Input, options: Options) => Output | Promise<Output>;\n\n/**\n * Recursive structure mirroring suite nesting, containing only line numbers.\n */\ninterface SuiteLineInfo {\n  testLines: number[]; // line number for each [[tests]] entry at this level\n  suiteLines: SuiteLineInfo[]; // line info for each [[suites]] entry\n}\n\n/**\n * Zod schemas for validating the TOML test document structure.\n */\n\n// A TOML value: string, number, bigint, boolean, Date, or recursively arrays/objects of TOML values\nconst TomlValueSchema: z.ZodType<unknown> = z.lazy(() =>\n  z.union([\n    z.string(),\n    z.number(),\n    z.bigint(),\n    z.boolean(),\n    z.instanceof(Date),\n    z.array(TomlValueSchema),\n    z.record(z.string(), TomlValueSchema),\n  ]),\n);\n\n// A single test case \u2014 name is optional (falls back to stringified input)\n// Exactly one of: output, throws, doesntThrow must be present\nconst TestCaseSchema = z\n  .object({\n    name: z.string().optional(),\n    input: TomlValueSchema,\n    output: TomlValueSchema.optional(),\n    throws: z.union([z.literal(true), z.string()]).optional(),\n    doesntThrow: z.literal(true).optional(),\n    options: z.record(z.string(), TomlValueSchema).optional(),\n  })\n  .refine(\n    (t) => {\n      const count = [\n        t.output !== undefined,\n        t.throws !== undefined,\n        t.doesntThrow !== undefined,\n      ].filter(Boolean).length;\n      return count === 1;\n    },\n    {\n      message:\n        \"Each test must have exactly one of: output, throws, or doesntThrow\",\n    },\n  );\n\n// Recursive suite schema\nconst TestSuiteSchema: z.ZodType<any> = z.lazy(() =>\n  z.object({\n    name: z.string().optional(),\n    options: z.record(z.string(), TomlValueSchema).optional(),\n    tests: z.array(TestCaseSchema).optional(),\n    suites: z.array(TestSuiteSchema).optional(),\n  }),\n);\n\n/**\n * Framework-agnostic test harness interface.\n * The caller provides these functions from whatever test framework they use\n * (node:test, vitest, jest, mocha, etc.).\n */\nexport interface TestHarness {\n  /** Register a test suite / group (like `describe` in most frameworks) */\n  describe: (name: string, fn: () => void) => void;\n  /** Register a single test case (like `it` or `test`) */\n  it: (name: string, fn: () => void | Promise<void>) => void;\n  /**\n   * Assert deep equality between actual and expected values.\n   * Should throw on mismatch.\n   */\n  equal: (actual: unknown, expected: unknown) => void;\n}\n\n/**\n * Scans TOML source for array-of-tables headers and builds a tree of line numbers\n * mirroring the suite nesting structure.\n */\nfunction scanTestLines(toml: string): SuiteLineInfo {\n  const lines = toml.split(\"\\n\");\n  const headerRegex = /^\\s*\\[\\[(.+?)\\]\\]\\s*$/;\n\n  // Collect all array-of-tables headers with their line numbers\n  const headers: Array<{ path: string; line: number }> = [];\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i];\n    if (line) {\n      const match = line.match(headerRegex);\n      if (match && match[1]) {\n        headers.push({ path: match[1].trim(), line: i + 1 }); // 1-indexed\n      }\n    }\n  }\n\n  // Build the tree from the flat list of headers\n  const root: SuiteLineInfo = { testLines: [], suiteLines: [] };\n\n  for (const { path, line } of headers) {\n    // Split path into segments: \"suites.suites.tests\" -> [\"suites\", \"suites\", \"tests\"]\n    const segments = path.split(\".\");\n\n    // Navigate to the right suite\n    let current: SuiteLineInfo = root;\n    for (let i = 0; i < segments.length - 1; i++) {\n      const seg = segments[i];\n      if (seg === \"suites\") {\n        // Navigate into the last suite at this level\n        if (current.suiteLines.length > 0) {\n          current = current.suiteLines[current.suiteLines.length - 1]!;\n        }\n      }\n      // Skip other segments \u2014 they're not suite navigation\n    }\n\n    const lastSegment = segments[segments.length - 1];\n    if (lastSegment === \"tests\") {\n      current.testLines.push(line);\n    } else if (lastSegment === \"suites\") {\n      current.suiteLines.push({ testLines: [], suiteLines: [] });\n    }\n    // Ignore other paths like \"tests.options\", \"suites.options\" etc.\n  }\n\n  return root;\n}\n\n/**\n * Recursively finds all paths in a value that contain non-TOML-expressible types.\n * TOML-expressible types are: string, number, bigint, boolean, Date, plain objects, and arrays.\n * Returns an array of dot-path strings where non-TOML values are found.\n */\nfunction findNonTomlPaths(value: unknown, path: string = \"result\"): string[] {\n  const nonTomlPaths: string[] = [];\n\n  function isPlainObject(obj: unknown): boolean {\n    if (obj === null || typeof obj !== \"object\") return false;\n    const proto = Object.getPrototypeOf(obj) as unknown;\n    return proto === Object.prototype || proto === null;\n  }\n\n  function isTomlExpressible(val: unknown): boolean {\n    const type = typeof val;\n\n    // Primitive TOML types\n    if (\n      type === \"string\"\n      || type === \"number\"\n      || type === \"bigint\"\n      || type === \"boolean\"\n    ) {\n      return true;\n    }\n\n    // Date instances (including smol-toml's TomlDate)\n    if (val instanceof Date) {\n      return true;\n    }\n\n    // null is NOT TOML-expressible\n    if (val === null) {\n      return false;\n    }\n\n    // Arrays: check elements recursively\n    if (Array.isArray(val)) {\n      return true;\n    }\n\n    // Plain objects: check values recursively\n    if (isPlainObject(val)) {\n      return true;\n    }\n\n    // Everything else (undefined, Symbol, Function, Set, Map, RegExp, class instances, etc.)\n    return false;\n  }\n\n  function walk(val: unknown, currentPath: string): void {\n    if (!isTomlExpressible(val)) {\n      nonTomlPaths.push(currentPath);\n      return;\n    }\n\n    if (Array.isArray(val)) {\n      for (let i = 0; i < val.length; i++) {\n        walk(val[i], `${currentPath}[${i}]`);\n      }\n      return;\n    }\n\n    if (val !== null && typeof val === \"object\" && isPlainObject(val)) {\n      for (const [key, value] of Object.entries(\n        val as Record<string, unknown>,\n      )) {\n        walk(value, `${currentPath}.${key}`);\n      }\n      return;\n    }\n  }\n\n  walk(value, path);\n  return nonTomlPaths;\n}\n\n/**\n * Processes a test suite recursively, creating describe/it blocks as needed.\n * Handles options merging from parent to child scope.\n */\nfunction processSuite<\n  Input extends TomlValue,\n  Options extends Record<string, TomlValue>,\n  Output extends TomlValue,\n>(\n  suite: Record<string, unknown>,\n  parentOptions: Record<string, unknown>,\n  fn: TomlTestFn<Input, Options, Output>,\n  harness: TestHarness,\n  lineInfo: SuiteLineInfo,\n  source?: string,\n): void {\n  // Merge options: parent options + suite options\n  const suiteOptions = (suite.options ?? {}) as Record<string, unknown>;\n  const mergedOptions = { ...parentOptions, ...suiteOptions };\n\n  const runContents = () => {\n    // Process test cases\n    const tests = suite.tests;\n    if (Array.isArray(tests)) {\n      for (let testIndex = 0; testIndex < tests.length; testIndex++) {\n        const test = tests[testIndex];\n        const t = test as Record<string, unknown>;\n\n        // Use name if provided, otherwise fall back to stringified input\n        const testName = (t.name as string | undefined) ?? String(t.input);\n\n        harness.it(testName, async () => {\n          // Merge test-level options on top of suite options\n          const testOptions = (t.options ?? {}) as Record<string, unknown>;\n          const finalOptions = { ...mergedOptions, ...testOptions };\n\n          // Get line number for this test\n          const line = lineInfo.testLines[testIndex];\n          const location =\n            line ?\n              source ? `${source}:${line}`\n              : `line ${line}`\n            : undefined;\n\n          try {\n            // Call the test function (await in case it's async)\n            const actual = await fn(t.input as Input, finalOptions as Options);\n\n            // Determine which assertion type is being used\n            const hasOutput = t.output !== undefined;\n            const hasThrows = t.throws !== undefined;\n            const hasDoesntThrow = t.doesntThrow !== undefined;\n\n            if (hasOutput) {\n              // output assertion: validate non-TOML types, then compare\n              const nonTomlPaths = findNonTomlPaths(actual);\n              if (nonTomlPaths.length > 0) {\n                throw new Error(\n                  `Result contains non-TOML-expressible values at: ${nonTomlPaths.join(\", \")}`,\n                );\n              }\n              harness.equal(actual, t.output);\n            } else if (hasThrows) {\n              // throws assertion: should have thrown, but didn't\n              throw new Error(\"Expected function to throw\");\n            } else if (hasDoesntThrow) {\n              // doesntThrow assertion: just verify it didn't throw (already passed)\n              // No additional checks needed\n            }\n          } catch (err) {\n            // Check if this is a \"throws\" test that actually threw\n            const hasThrows = t.throws !== undefined;\n            if (hasThrows && err instanceof Error) {\n              const throwsValue = t.throws;\n              if (throwsValue === true) {\n                // Any error is fine, test passes\n                return;\n              } else if (typeof throwsValue === \"string\") {\n                // Check if error message matches the pattern\n                const pattern = new RegExp(throwsValue);\n                if (pattern.test(err.message)) {\n                  // Pattern matches, test passes\n                  return;\n                } else {\n                  // Pattern doesn't match, fail with descriptive message\n                  const newErr = new Error(\n                    `Expected error message to match pattern \"${throwsValue}\", but got: \"${err.message}\"`,\n                  );\n                  if (location) {\n                    newErr.message = `${location}: ${newErr.message}`;\n                  }\n                  throw newErr;\n                }\n              }\n            }\n\n            // For non-throws tests or other errors, add location and re-throw\n            if (err instanceof Error && location) {\n              err.message = `${location}: ${err.message}`;\n            }\n            throw err;\n          }\n        });\n      }\n    }\n\n    // Process nested suites\n    const suites = suite.suites;\n    if (Array.isArray(suites)) {\n      for (let suiteIndex = 0; suiteIndex < suites.length; suiteIndex++) {\n        const nestedSuite = suites[suiteIndex];\n        const nestedLineInfo = lineInfo.suiteLines[suiteIndex] ?? {\n          testLines: [],\n          suiteLines: [],\n        };\n        processSuite(\n          nestedSuite as Record<string, unknown>,\n          mergedOptions,\n          fn,\n          harness,\n          nestedLineInfo,\n          source,\n        );\n      }\n    }\n  };\n\n  // If the suite has a name, wrap in describe block\n  if (suite.name && typeof suite.name === \"string\") {\n    harness.describe(suite.name, runContents);\n  } else {\n    // Nameless suites run contents directly at the current nesting level\n    runContents();\n  }\n}\n\n/**\n * Parses a TOML test document and registers test suites/cases using the\n * provided test harness. Framework-agnostic \u2014 works with node:test, vitest,\n * jest, mocha, or any framework that provides describe/it/equal.\n *\n * @param toml - TOML source string describing the test suite\n * @param fn - The function under test\n * @param harness - Test framework bindings (describe, it, equal)\n * @param source - Optional source label (e.g. filename) for error messages\n */\nexport function toml_test<\n  Input extends TomlValue = TomlValue,\n  Options extends Record<string, TomlValue> = Record<string, TomlValue>,\n  Output extends TomlValue = TomlValue,\n>(\n  toml: string,\n  fn: TomlTestFn<Input, Options, Output>,\n  harness: TestHarness,\n  source?: string,\n): void {\n  const suite = parse(toml);\n  const lineInfo = scanTestLines(toml);\n\n  // Validate the parsed suite against the schema\n  const validationResult = TestSuiteSchema.safeParse(suite);\n\n  if (!validationResult.success) {\n    // Register failing tests for each validation error\n    for (const issue of validationResult.error.issues) {\n      const path = issue.path.length > 0 ? issue.path.join(\".\") : \"root\";\n      const errorMessage = `Validation error at ${path}: ${issue.message}`;\n      harness.it(`Schema validation error: ${path}`, () => {\n        throw new Error(errorMessage);\n      });\n    }\n    return;\n  }\n\n  processSuite(suite, {}, fn, harness, lineInfo, source);\n}\n"],
+  "mappings": "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",
+  "names": ["value"]
+}

package/src/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/index.test.js

@@ -0,0 +1,372 @@
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { toml_test } from "./index.js";
+var harness = {
+  describe,
+  it,
+  equal: assert.deepStrictEqual
+};
+function fixture(name) {
+  return readFileSync(
+    path.resolve(import.meta.dirname, "../fixtures", name),
+    "utf-8"
+  );
+}
+describe("Test 1: Basic suite with options merging", () => {
+  function stringUtil(input, options) {
+    let result = input;
+    if (options.trim) result = result.trim();
+    if (options.uppercase) result = result.toUpperCase();
+    return result;
+  }
+  toml_test(fixture("basic.toml"), stringUtil, harness);
+});
+describe("Test 2: Nameless suites", () => {
+  function prefixSuffix(input, options) {
+    let result = input;
+    if (options.prefix) result = options.prefix + result;
+    if (options.suffix) result = result + options.suffix;
+    return result;
+  }
+  toml_test(fixture("nameless-suite.toml"), prefixSuffix, harness);
+});
+describe("Test 3: Non-TOML result detection", () => {
+  function nonTomlReturner(input, _options) {
+    if (input === "return-undefined") return { value: void 0 };
+    if (input === "return-function") return { fn: () => {
+    } };
+    return input;
+  }
+  const expectThrowsHarness = {
+    describe,
+    it: (name, fn) => it(name, async () => {
+      await assert.rejects(
+        async () => {
+          const result = fn();
+          if (result instanceof Promise) {
+            await result;
+          }
+        },
+        (err) => {
+          assert.match(err.message, /non-toml-result\.toml:\d+:/);
+          assert.match(err.message, /non-TOML-expressible/);
+          return true;
+        }
+      );
+    }),
+    equal: assert.deepStrictEqual
+  };
+  toml_test(
+    fixture("non-toml-result.toml"),
+    nonTomlReturner,
+    expectThrowsHarness,
+    "non-toml-result.toml"
+  );
+});
+describe("Test 4: Source line numbers in error messages", () => {
+  function alwaysFails(input, _options) {
+    throw new Error("intentional failure");
+  }
+  const sourceLineHarness = {
+    describe,
+    it: (name, fn) => it(name, async () => {
+      await assert.rejects(
+        async () => {
+          const result = fn();
+          if (result instanceof Promise) {
+            await result;
+          }
+        },
+        (err) => {
+          assert.match(err.message, /test\.toml:\d+:/);
+          return true;
+        }
+      );
+    }),
+    equal: assert.deepStrictEqual
+  };
+  const minimalToml = `
+[[tests]]
+name = "test 1"
+input = "hello"
+output = "hello"
+`;
+  toml_test(minimalToml, alwaysFails, sourceLineHarness, "test.toml");
+});
+describe("Test: TomlDate is TOML-expressible", () => {
+  function dateReturner(_input, _options) {
+    const date = /* @__PURE__ */ new Date("2024-01-01T00:00:00Z");
+    return { timestamp: date };
+  }
+  const dateHarness = {
+    describe,
+    it,
+    equal: (actual, expected) => {
+      if (actual !== null && typeof actual === "object" && expected !== null && typeof expected === "object" && "timestamp" in actual && "timestamp" in expected) {
+        const actualDate = actual.timestamp;
+        const expectedDate = expected.timestamp;
+        if (actualDate instanceof Date && expectedDate instanceof Date) {
+          assert.strictEqual(actualDate.getTime(), expectedDate.getTime());
+          return;
+        }
+      }
+      assert.deepStrictEqual(actual, expected);
+    }
+  };
+  const toml = `
+[[tests]]
+name = "date values are TOML-expressible"
+input = "anything"
+output = { timestamp = 2024-01-01T00:00:00Z }
+`;
+  toml_test(toml, dateReturner, dateHarness);
+});
+describe("Test: Error without source shows line number only", () => {
+  function alwaysFails(_input, _options) {
+    throw new Error("intentional failure");
+  }
+  const noSourceHarness = {
+    describe,
+    it: (name, fn) => it(name, async () => {
+      await assert.rejects(
+        async () => {
+          const result = fn();
+          if (result instanceof Promise) {
+            await result;
+          }
+        },
+        (err) => {
+          assert.match(err.message, /^line \d+:/);
+          assert.doesNotMatch(err.message, /\.toml/);
+          return true;
+        }
+      );
+    }),
+    equal: assert.deepStrictEqual
+  };
+  const toml = `
+[[tests]]
+name = "will fail"
+input = "hello"
+output = "hello"
+`;
+  toml_test(toml, alwaysFails, noSourceHarness);
+});
+describe("Test: Empty test array", () => {
+  const toml = `
+name = "Empty suite"
+tests = []
+`;
+  let testCount = 0;
+  const countingHarness = {
+    describe: (_name, fn) => fn(),
+    it: (_name, _fn) => {
+      testCount++;
+    },
+    equal: assert.deepStrictEqual
+  };
+  toml_test(toml, () => "unused", countingHarness);
+  it("registers no tests for empty array", () => {
+    assert.strictEqual(testCount, 0);
+  });
+});
+describe("Test: Root-level options", () => {
+  function multiply(input, options) {
+    return parseInt(input) * options.factor;
+  }
+  const toml = `
+[options]
+factor = 3
+
+[[tests]]
+name = "multiplies by factor"
+input = "5"
+output = 15
+
+[[tests]]
+name = "override factor"
+input = "5"
+output = 25
+[tests.options]
+factor = 5
+`;
+  toml_test(toml, multiply, harness);
+});
+describe("Test: Object output", () => {
+  function parseKeyValue(input, _options) {
+    const parts = input.split("=");
+    const key = parts[0] ?? "";
+    const value = parts[1] ?? "";
+    return { key: key.trim(), value: value.trim() };
+  }
+  const toml = `
+[[tests]]
+name = "parses key-value pair"
+input = "color = blue"
+output = { key = "color", value = "blue" }
+`;
+  toml_test(toml, parseKeyValue, harness);
+});
+describe("Test: throws assertion", () => {
+  function mayThrow(input, _options) {
+    if (input === "bad") throw new Error("something went wrong");
+    return input;
+  }
+  const toml = `
+[[tests]]
+name = "throws on bad input"
+input = "bad"
+throws = true
+
+[[tests]]
+name = "throws matching pattern"
+input = "bad"
+throws = "went wrong"
+`;
+  toml_test(toml, mayThrow, harness);
+});
+describe("Test: doesntThrow assertion", () => {
+  function safeFunction(input, _options) {
+    return input.toUpperCase();
+  }
+  const toml = `
+[[tests]]
+name = "runs without throwing"
+input = "hello"
+doesntThrow = true
+`;
+  toml_test(toml, safeFunction, harness);
+});
+describe("Test: Name falls back to input", () => {
+  let registeredName = "";
+  const nameCapturingHarness = {
+    describe: (_name, fn) => fn(),
+    it: (name, fn) => {
+      registeredName = name;
+    },
+    equal: assert.deepStrictEqual
+  };
+  const toml = `
+[[tests]]
+input = "hello world"
+output = "hello world"
+`;
+  toml_test(toml, (input) => input, nameCapturingHarness);
+  it("uses input as test name when name is omitted", () => {
+    assert.strictEqual(registeredName, "hello world");
+  });
+});
+describe("Test: Schema validation errors", () => {
+  const invalidToml = `
+[[tests]]
+name = "missing assertion"
+input = "hello"
+`;
+  let registeredTests = [];
+  const capturingHarness = {
+    describe: (_name, fn) => fn(),
+    it: (name, fn) => {
+      registeredTests.push({ name, fn });
+    },
+    equal: assert.deepStrictEqual
+  };
+  toml_test(invalidToml, (input) => input, capturingHarness);
+  it("registers a failing test for schema errors", () => {
+    assert.ok(registeredTests.length > 0);
+    const firstTest = registeredTests[0];
+    assert.ok(firstTest);
+    assert.throws(() => firstTest.fn(), /output.*throws.*doesntThrow/i);
+  });
+});
+describe("Test: Async test function", () => {
+  async function asyncUppercase(input, _options) {
+    return input.toUpperCase();
+  }
+  const toml = `
+[[tests]]
+name = "async uppercase"
+input = "hello"
+output = "HELLO"
+`;
+  toml_test(toml, asyncUppercase, harness);
+});
+describe("Test: Numeric input", () => {
+  function doubleIt(input, _options) {
+    return input * 2;
+  }
+  const toml = `
+[[tests]]
+name = "doubles an integer"
+input = 21
+output = 42
+
+[[tests]]
+name = "doubles a float"
+input = 1.5
+output = 3.0
+`;
+  toml_test(toml, doubleIt, harness);
+});
+describe("Test: Boolean input", () => {
+  function negate(input, _options) {
+    return !input;
+  }
+  const toml = `
+[[tests]]
+name = "negates true"
+input = true
+output = false
+
+[[tests]]
+name = "negates false"
+input = false
+output = true
+`;
+  toml_test(toml, negate, harness);
+});
+describe("Test: Object input", () => {
+  function greet(input, _options) {
+    const obj = input;
+    return `${obj.greeting}, ${obj.name}!`;
+  }
+  const toml = `
+[[tests]]
+name = "greets from object input"
+input = { name = "Alice", greeting = "Hello" }
+output = "Hello, Alice!"
+`;
+  toml_test(toml, greet, harness);
+});
+describe("Test: Array input", () => {
+  function sum(input, _options) {
+    return input.reduce((a, b) => a + b, 0);
+  }
+  const toml = `
+[[tests]]
+name = "sums an array of numbers"
+input = [1, 2, 3, 4]
+output = 10
+`;
+  toml_test(toml, sum, harness);
+});
+describe("Test: Name fallback with non-string input", () => {
+  let registeredName = "";
+  const nameCapturingHarness = {
+    describe: (_name, fn) => fn(),
+    it: (name, _fn) => {
+      registeredName = name;
+    },
+    equal: assert.deepStrictEqual
+  };
+  const toml = `
+[[tests]]
+input = 42
+output = 42
+`;
+  toml_test(toml, (input) => input, nameCapturingHarness);
+  it("uses String(input) as test name for non-string input", () => {
+    assert.strictEqual(registeredName, "42");
+  });
+});

package/src/index.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.test.ts"],
+  "sourcesContent": ["import { describe, it } from \"node:test\";\nimport { strict as assert } from \"node:assert\";\nimport { readFileSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { toml_test } from \"./index.ts\";\nimport type { TestHarness, TomlValue } from \"./index.ts\";\n\n/** Wire up node:test as the harness */\nconst harness: TestHarness = {\n  describe,\n  it,\n  equal: assert.deepStrictEqual,\n};\n\n/** Helper to load a fixture as a TOML string */\nfunction fixture(name: string): string {\n  return readFileSync(\n    path.resolve(import.meta.dirname, \"../fixtures\", name),\n    \"utf-8\",\n  );\n}\n\n/**\n * Test 1: Basic suite with options merging\n * Tests a string utility function that can trim and uppercase input based on options.\n */\ndescribe(\"Test 1: Basic suite with options merging\", () => {\n  function stringUtil(input: TomlValue, options: any): string {\n    let result = input as string;\n    if (options.trim) result = result.trim();\n    if (options.uppercase) result = result.toUpperCase();\n    return result;\n  }\n\n  toml_test(fixture(\"basic.toml\"), stringUtil, harness);\n});\n\n/**\n * Test 2: Nameless suites\n * Tests a function that can prepend prefix and append suffix based on options.\n * Demonstrates that suites without names work correctly.\n */\ndescribe(\"Test 2: Nameless suites\", () => {\n  function prefixSuffix(input: TomlValue, options: any): string {\n    let result = input as string;\n    if (options.prefix) result = options.prefix + result;\n    if (options.suffix) result = result + options.suffix;\n    return result;\n  }\n\n  toml_test(fixture(\"nameless-suite.toml\"), prefixSuffix, harness);\n});\n\n/**\n * Test 3: Non-TOML result detection\n * Wraps each registered test in an assert.throws to verify the non-TOML error.\n */\ndescribe(\"Test 3: Non-TOML result detection\", () => {\n  function nonTomlReturner(input: TomlValue, _options: any): any {\n    if ((input as string) === \"return-undefined\") return { value: undefined };\n    if ((input as string) === \"return-function\") return { fn: () => {} };\n    return input;\n  }\n\n  const expectThrowsHarness: TestHarness = {\n    describe,\n    it: (name, fn) =>\n      it(name, async () => {\n        await assert.rejects(\n          async () => {\n            const result = fn();\n            if (result instanceof Promise) {\n              await result;\n            }\n          },\n          (err: Error) => {\n            assert.match(err.message, /non-toml-result\\.toml:\\d+:/);\n            assert.match(err.message, /non-TOML-expressible/);\n            return true;\n          },\n        );\n      }),\n    equal: assert.deepStrictEqual,\n  };\n\n  toml_test(\n    fixture(\"non-toml-result.toml\"),\n    nonTomlReturner,\n    expectThrowsHarness,\n    \"non-toml-result.toml\",\n  );\n});\n\n/**\n * Test 4: Source line numbers in error messages\n * Verifies that when a source parameter is provided, error messages include the source:line format.\n */\ndescribe(\"Test 4: Source line numbers in error messages\", () => {\n  function alwaysFails(input: TomlValue, _options: any): any {\n    throw new Error(\"intentional failure\");\n  }\n\n  const sourceLineHarness: TestHarness = {\n    describe,\n    it: (name, fn) =>\n      it(name, async () => {\n        await assert.rejects(\n          async () => {\n            const result = fn();\n            if (result instanceof Promise) {\n              await result;\n            }\n          },\n          (err: Error) => {\n            // When source is provided, error should include \"test.toml:N:\" format\n            assert.match(err.message, /test\\.toml:\\d+:/);\n            return true;\n          },\n        );\n      }),\n    equal: assert.deepStrictEqual,\n  };\n\n  // Create a minimal TOML with a test\n  const minimalToml = `\n[[tests]]\nname = \"test 1\"\ninput = \"hello\"\noutput = \"hello\"\n`;\n\n  toml_test(minimalToml, alwaysFails, sourceLineHarness, \"test.toml\");\n});\n\n/**\n * Test: TomlDate is TOML-expressible\n * Verifies that Date objects (including smol-toml's TomlDate) pass the non-TOML check.\n */\ndescribe(\"Test: TomlDate is TOML-expressible\", () => {\n  function dateReturner(_input: TomlValue, _options: any): any {\n    // Return a Date object that matches what smol-toml parses\n    const date = new Date(\"2024-01-01T00:00:00Z\");\n    return { timestamp: date };\n  }\n\n  // Use a custom harness that compares dates by value, not by type\n  const dateHarness: TestHarness = {\n    describe,\n    it,\n    equal: (actual: unknown, expected: unknown) => {\n      // Custom equality that treats Date and TomlDate as equivalent if they have the same time\n      if (\n        actual !== null\n        && typeof actual === \"object\"\n        && expected !== null\n        && typeof expected === \"object\"\n        && \"timestamp\" in actual\n        && \"timestamp\" in expected\n      ) {\n        const actualDate = (actual as any).timestamp;\n        const expectedDate = (expected as any).timestamp;\n        if (actualDate instanceof Date && expectedDate instanceof Date) {\n          assert.strictEqual(actualDate.getTime(), expectedDate.getTime());\n          return;\n        }\n      }\n      assert.deepStrictEqual(actual, expected);\n    },\n  };\n\n  const toml = `\n[[tests]]\nname = \"date values are TOML-expressible\"\ninput = \"anything\"\noutput = { timestamp = 2024-01-01T00:00:00Z }\n`;\n  toml_test(toml, dateReturner, dateHarness);\n});\n\n/**\n * Test: Error without source shows line number only\n * Verifies that when no source parameter is provided, errors show \"line N:\" format.\n */\ndescribe(\"Test: Error without source shows line number only\", () => {\n  function alwaysFails(_input: TomlValue, _options: any): any {\n    throw new Error(\"intentional failure\");\n  }\n\n  const noSourceHarness: TestHarness = {\n    describe,\n    it: (name, fn) =>\n      it(name, async () => {\n        await assert.rejects(\n          async () => {\n            const result = fn();\n            if (result instanceof Promise) {\n              await result;\n            }\n          },\n          (err: Error) => {\n            assert.match(err.message, /^line \\d+:/);\n            assert.doesNotMatch(err.message, /\\.toml/);\n            return true;\n          },\n        );\n      }),\n    equal: assert.deepStrictEqual,\n  };\n\n  const toml = `\n[[tests]]\nname = \"will fail\"\ninput = \"hello\"\noutput = \"hello\"\n`;\n  toml_test(toml, alwaysFails, noSourceHarness);\n});\n\n/**\n * Test: Empty test array is a no-op\n * Verifies that an empty tests array doesn't register any tests.\n */\ndescribe(\"Test: Empty test array\", () => {\n  const toml = `\nname = \"Empty suite\"\ntests = []\n`;\n  // Should not crash, should not register any tests\n  let testCount = 0;\n  const countingHarness: TestHarness = {\n    describe: (_name, fn) => fn(),\n    it: (_name, _fn) => {\n      testCount++;\n    },\n    equal: assert.deepStrictEqual,\n  };\n  toml_test(toml, () => \"unused\", countingHarness);\n  // Wrap in an it() to assert\n  it(\"registers no tests for empty array\", () => {\n    assert.strictEqual(testCount, 0);\n  });\n});\n\n/**\n * Test: Root-level options\n * Verifies that root-level options are applied to all tests.\n */\ndescribe(\"Test: Root-level options\", () => {\n  function multiply(input: TomlValue, options: any): number {\n    return parseInt(input as string) * options.factor;\n  }\n\n  const toml = `\n[options]\nfactor = 3\n\n[[tests]]\nname = \"multiplies by factor\"\ninput = \"5\"\noutput = 15\n\n[[tests]]\nname = \"override factor\"\ninput = \"5\"\noutput = 25\n[tests.options]\nfactor = 5\n`;\n  toml_test(toml, multiply, harness);\n});\n\n/**\n * Test: Object output (deep equality)\n * Verifies that object outputs are compared with deep equality.\n */\ndescribe(\"Test: Object output\", () => {\n  function parseKeyValue(input: TomlValue, _options: any): any {\n    const parts = (input as string).split(\"=\");\n    const key = parts[0] ?? \"\";\n    const value = parts[1] ?? \"\";\n    return { key: key.trim(), value: value.trim() };\n  }\n\n  const toml = `\n[[tests]]\nname = \"parses key-value pair\"\ninput = \"color = blue\"\noutput = { key = \"color\", value = \"blue\" }\n`;\n  toml_test(toml, parseKeyValue, harness);\n});\n\n/**\n * Test: throws assertion\n * Verifies that throws assertions work with both true and pattern matching.\n */\ndescribe(\"Test: throws assertion\", () => {\n  function mayThrow(input: TomlValue, _options: any): any {\n    if ((input as string) === \"bad\") throw new Error(\"something went wrong\");\n    return input;\n  }\n\n  const toml = `\n[[tests]]\nname = \"throws on bad input\"\ninput = \"bad\"\nthrows = true\n\n[[tests]]\nname = \"throws matching pattern\"\ninput = \"bad\"\nthrows = \"went wrong\"\n`;\n  toml_test(toml, mayThrow, harness);\n});\n\n/**\n * Test: doesntThrow assertion\n * Verifies that doesntThrow assertions work correctly.\n */\ndescribe(\"Test: doesntThrow assertion\", () => {\n  function safeFunction(input: TomlValue, _options: any): any {\n    return (input as string).toUpperCase();\n  }\n\n  const toml = `\n[[tests]]\nname = \"runs without throwing\"\ninput = \"hello\"\ndoesntThrow = true\n`;\n  toml_test(toml, safeFunction, harness);\n});\n\n/**\n * Test: Name falls back to input\n * Verifies that when name is omitted, the test name is set to the input value.\n */\ndescribe(\"Test: Name falls back to input\", () => {\n  let registeredName = \"\";\n  const nameCapturingHarness: TestHarness = {\n    describe: (_name, fn) => fn(),\n    it: (name, fn) => {\n      registeredName = name;\n      // Don't actually run fn, just capture the name\n    },\n    equal: assert.deepStrictEqual,\n  };\n\n  const toml = `\n[[tests]]\ninput = \"hello world\"\noutput = \"hello world\"\n`;\n  toml_test(toml, (input) => input, nameCapturingHarness);\n  it(\"uses input as test name when name is omitted\", () => {\n    assert.strictEqual(registeredName, \"hello world\");\n  });\n});\n\n/**\n * Test: Schema validation errors\n * Verifies that schema validation errors are registered as failing tests.\n */\ndescribe(\"Test: Schema validation errors\", () => {\n  // A test with neither output, throws, nor doesntThrow\n  const invalidToml = `\n[[tests]]\nname = \"missing assertion\"\ninput = \"hello\"\n`;\n\n  let registeredTests: Array<{ name: string; fn: () => void | Promise<void> }> =\n    [];\n  const capturingHarness: TestHarness = {\n    describe: (_name, fn) => fn(),\n    it: (name, fn) => {\n      registeredTests.push({ name, fn });\n    },\n    equal: assert.deepStrictEqual,\n  };\n\n  toml_test(invalidToml, (input) => input, capturingHarness);\n\n  it(\"registers a failing test for schema errors\", () => {\n    assert.ok(registeredTests.length > 0);\n    const firstTest = registeredTests[0];\n    assert.ok(firstTest);\n    assert.throws(() => firstTest.fn(), /output.*throws.*doesntThrow/i);\n  });\n});\n\n/**\n * Test: Async test function\n * Verifies that async test functions work correctly.\n */\ndescribe(\"Test: Async test function\", () => {\n  async function asyncUppercase(\n    input: TomlValue,\n    _options: any,\n  ): Promise<string> {\n    return (input as string).toUpperCase();\n  }\n\n  const toml = `\n[[tests]]\nname = \"async uppercase\"\ninput = \"hello\"\noutput = \"HELLO\"\n`;\n  toml_test(toml, asyncUppercase, harness);\n});\n\n/**\n * Test: Numeric input\n * Verifies that numeric inputs are passed through correctly.\n */\ndescribe(\"Test: Numeric input\", () => {\n  function doubleIt(input: TomlValue, _options: any): number {\n    return (input as number) * 2;\n  }\n\n  const toml = `\n[[tests]]\nname = \"doubles an integer\"\ninput = 21\noutput = 42\n\n[[tests]]\nname = \"doubles a float\"\ninput = 1.5\noutput = 3.0\n`;\n  toml_test(toml, doubleIt, harness);\n});\n\n/**\n * Test: Boolean input\n * Verifies that boolean inputs are passed through correctly.\n */\ndescribe(\"Test: Boolean input\", () => {\n  function negate(input: TomlValue, _options: any): boolean {\n    return !(input as boolean);\n  }\n\n  const toml = `\n[[tests]]\nname = \"negates true\"\ninput = true\noutput = false\n\n[[tests]]\nname = \"negates false\"\ninput = false\noutput = true\n`;\n  toml_test(toml, negate, harness);\n});\n\n/**\n * Test: Object input\n * Verifies that inline table inputs are passed through correctly.\n */\ndescribe(\"Test: Object input\", () => {\n  function greet(input: TomlValue, _options: any): string {\n    const obj = input as { name: string; greeting: string };\n    return `${obj.greeting}, ${obj.name}!`;\n  }\n\n  const toml = `\n[[tests]]\nname = \"greets from object input\"\ninput = { name = \"Alice\", greeting = \"Hello\" }\noutput = \"Hello, Alice!\"\n`;\n  toml_test(toml, greet, harness);\n});\n\n/**\n * Test: Array input\n * Verifies that array inputs are passed through correctly.\n */\ndescribe(\"Test: Array input\", () => {\n  function sum(input: TomlValue, _options: any): number {\n    return (input as number[]).reduce((a, b) => a + b, 0);\n  }\n\n  const toml = `\n[[tests]]\nname = \"sums an array of numbers\"\ninput = [1, 2, 3, 4]\noutput = 10\n`;\n  toml_test(toml, sum, harness);\n});\n\n/**\n * Test: Name fallback with non-string input\n * Verifies that when name is omitted and input is not a string, String(input) is used.\n */\ndescribe(\"Test: Name fallback with non-string input\", () => {\n  let registeredName = \"\";\n  const nameCapturingHarness: TestHarness = {\n    describe: (_name, fn) => fn(),\n    it: (name, _fn) => {\n      registeredName = name;\n    },\n    equal: assert.deepStrictEqual,\n  };\n\n  const toml = `\n[[tests]]\ninput = 42\noutput = 42\n`;\n  toml_test(toml, (input) => input, nameCapturingHarness);\n  it(\"uses String(input) as test name for non-string input\", () => {\n    assert.strictEqual(registeredName, \"42\");\n  });\n});\n"],
+  "mappings": "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",
+  "names": []
+}

package/src/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": ["@dral/tsconfig/modern", "@dral/tsconfig/reasonable"],
+  "compilerOptions": {
+    "noEmit": true,
+    "module": "nodenext"
+  },
+  "exclude": ["./**/*.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "references": [{ "path": "./src" }, { "path": "./tsconfig.test.json" }],
+  "files": []
+}

package/tsconfig.test.json

@@ -0,0 +1,11 @@
+{
+  "extends": [
+    "@dral/tsconfig/modern",
+    "@dral/tsconfig/reasonable",
+    "@tsconfig/node24/tsconfig.json"
+  ],
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src"]
+}