create-agent-rig 0.9.1 → 0.10.0

package/templates/skeleton/node-service/gitignore

@@ -1,54 +0,0 @@
-node_modules/
-dist/
-coverage/
-*.tsbuildinfo
-.DS_Store
-var/
-.next/
-out/
-next-env.d.ts
-dist/
-.claude/worktrees/
-# per-checkout queue state: the tier the last close recorded. The queue CONFIG
-# is composed and tracked; this is runtime state and must never be committed.
-.claude/queue.state.json
-# per-checkout board selector (`queue/index.mjs board <name>`); the boards are in the config
-.claude/queue.board
-# gate rounds, one count per branch
-.claude/gate-rounds.json
-# per-run machine trace (.claude/scripts/run-journal.mjs): forensics that churn
-# on every gate and collide across concurrent sessions. Unlike a committed
-# evidence directory, this one is per-run and stays out of the repository.
-.claude/runs/
-
-# secrets — never commit these
-*.env
-.env
-.env.*
-!.env.example
-.envrc
-.npmrc
-.netrc
-.pgpass
-id_rsa
-id_ed25519
-*.pem
-*.key
-*.p12
-*.pfx
-*.keystore
-*.jks
-*.secret
-*.secrets
-*.token
-*.tokens
-*.password
-*.passwords
-*.credential
-*.credentials
-*.apikey
-*.apikeys
-*.passwd
-*.creds
-*.jwt
-*.bearer

package/templates/skeleton/node-service/package.json

@@ -1,30 +0,0 @@
-{
-  "name": "@app/root",
-  "version": "0.2.0",
-  "private": true,
-  "type": "module",
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "test": "vitest run",
-    "lint": "eslint .",
-    "typecheck": "tsc -p tsconfig.json && tsc -p apps/web/tsconfig.json",
-    "build:web": "pnpm --filter @app/web build",
-    "build:artifact": "pnpm build:web && node scripts/build-artifact.mjs",
-    "start:api": "pnpm --filter @app/api start",
-    "start:worker": "pnpm --filter @app/worker start",
-    "check": "pnpm lint && pnpm typecheck && pnpm build:artifact && pnpm test"
-  },
-  "devDependencies": {
-    "@eslint/js": "^10.0.1",
-    "@types/node": "^26.1.1",
-    "esbuild": "^0.28.1",
-    "eslint": "^10.7.0",
-    "globals": "^17.7.0",
-    "tsx": "^4.23.1",
-    "typescript": "^6.0.3",
-    "typescript-eslint": "^8.65.0",
-    "vitest": "^4.1.10"
-  }
-}

package/templates/skeleton/node-service/packages/core/package.json

@@ -1,11 +0,0 @@
-{
-  "name": "@app/core",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "zod": "^4.4.3"
-  }
-}

package/templates/skeleton/node-service/packages/core/src/events.ts

@@ -1,14 +0,0 @@
-// Domain event vocabulary. The schema is the contract between the API (producer)
-// and the worker (consumer) — both sides validate against it.
-import { z } from 'zod';
-import { NoteSchema, type Note } from './note.js';
-
-export const NoteCreatedEventSchema = z.object({
-  type: z.literal('note.created'),
-  note: NoteSchema,
-});
-export type NoteCreatedEvent = z.infer<typeof NoteCreatedEventSchema>;
-
-export function makeNoteCreatedEvent(note: Note): NoteCreatedEvent {
-  return { type: 'note.created', note };
-}

package/templates/skeleton/node-service/packages/core/src/index.ts

@@ -1,15 +0,0 @@
-export {
-  NewNoteSchema,
-  NoteSchema,
-  InvalidNoteError,
-  createNote,
-  slugify,
-  type NewNote,
-  type Note,
-  type NoteIdentity,
-} from './note.js';
-export {
-  NoteCreatedEventSchema,
-  makeNoteCreatedEvent,
-  type NoteCreatedEvent,
-} from './events.js';

package/templates/skeleton/node-service/packages/core/src/note.ts

@@ -1,69 +0,0 @@
-// The domain core is pure: no I/O, no clock, no randomness, no environment.
-// "Now" and "a new id" are decided by the caller (the usecase layer) and enter
-// as arguments. The guard-core-purity hook enforces this at the tool layer.
-import { z } from 'zod';
-
-export const NewNoteSchema = z.object({
-  title: z.string().trim().min(1, 'title must not be empty').max(200, 'title too long'),
-  tags: z.array(z.string().trim().min(1).max(40)).max(10).default([]),
-});
-export type NewNote = z.infer<typeof NewNoteSchema>;
-
-export const NoteSchema = z.object({
-  id: z.string().min(1),
-  title: z.string().min(1),
-  slug: z.string().min(1),
-  tags: z.array(z.string()),
-  createdAt: z.string().min(1),
-});
-export type Note = z.infer<typeof NoteSchema>;
-
-/** Thrown when input fails domain validation. The core owns its own error type. */
-export class InvalidNoteError extends Error {
-  readonly issues: readonly string[];
-
-  constructor(issues: readonly string[]) {
-    super(`invalid note: ${issues.join('; ')}`);
-    this.name = 'InvalidNoteError';
-    this.issues = issues;
-  }
-}
-
-export interface NoteIdentity {
-  /** Generated by the caller — the core never invents ids. */
-  id: string;
-  /** ISO-8601 timestamp decided by the caller — the core never reads the clock. */
-  createdAt: string;
-}
-
-/**
- * The one domain function: validate raw input and construct a Note.
- * Deterministic — identical arguments always yield an identical note.
- */
-export function createNote(input: unknown, identity: NoteIdentity): Note {
-  const parsed = NewNoteSchema.safeParse(input);
-  if (!parsed.success) {
-    throw new InvalidNoteError(
-      parsed.error.issues.map((issue) => `${issue.path.join('.') || 'input'}: ${issue.message}`),
-    );
-  }
-  const { title, tags } = parsed.data;
-  return {
-    id: identity.id,
-    title,
-    slug: slugify(title),
-    tags: [...new Set(tags)],
-    createdAt: identity.createdAt,
-  };
-}
-
-/** Lowercased, hyphen-separated, ascii-ish slug. Pure string work. */
-export function slugify(title: string): string {
-  const slug = title
-    .toLowerCase()
-    .normalize('NFKD')
-    .replace(/[\u0300-\u036f]/g, '') // strip combining marks left by NFKD
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-  return slug.length > 0 ? slug : 'note';
-}

package/templates/skeleton/node-service/packages/core/test/events.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { NoteCreatedEventSchema, makeNoteCreatedEvent } from '../src/events.js';
-import { createNote } from '../src/note.js';
-
-const note = createNote({ title: 'Hello' }, { id: 'n1', createdAt: '2024-01-01T00:00:00.000Z' });
-
-describe('note.created event', () => {
-  it('wraps a note and round-trips through its own schema', () => {
-    const event = makeNoteCreatedEvent(note);
-    expect(event.type).toBe('note.created');
-    expect(NoteCreatedEventSchema.parse(JSON.parse(JSON.stringify(event)))).toEqual(event);
-  });
-
-  it('rejects a payload with the wrong type tag', () => {
-    expect(NoteCreatedEventSchema.safeParse({ type: 'other', note }).success).toBe(false);
-  });
-
-  it('rejects a payload with a malformed note', () => {
-    expect(
-      NoteCreatedEventSchema.safeParse({ type: 'note.created', note: { id: '' } }).success,
-    ).toBe(false);
-  });
-});

package/templates/skeleton/node-service/packages/core/test/note.test.ts

@@ -1,101 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { InvalidNoteError, createNote, slugify } from '../src/note.js';
-
-const identity = { id: 'note-1', createdAt: '2024-01-01T00:00:00.000Z' };
-
-describe('createNote', () => {
-  it('builds a note from valid input', () => {
-    const note = createNote({ title: 'Hello World', tags: ['a', 'b'] }, identity);
-    expect(note).toEqual({
-      id: 'note-1',
-      title: 'Hello World',
-      slug: 'hello-world',
-      tags: ['a', 'b'],
-      createdAt: '2024-01-01T00:00:00.000Z',
-    });
-  });
-
-  it('is deterministic: identical arguments yield an identical note', () => {
-    const a = createNote({ title: 'Same' }, identity);
-    const b = createNote({ title: 'Same' }, identity);
-    expect(a).toEqual(b);
-  });
-
-  it('defaults tags to an empty array', () => {
-    expect(createNote({ title: 'No tags' }, identity).tags).toEqual([]);
-  });
-
-  it('trims the title', () => {
-    expect(createNote({ title: '  padded  ' }, identity).title).toBe('padded');
-  });
-
-  it('deduplicates tags', () => {
-    expect(createNote({ title: 'T', tags: ['x', 'x', 'y'] }, identity).tags).toEqual(['x', 'y']);
-  });
-
-  it('refuses an empty or whitespace-only title', () => {
-    expect(() => createNote({ title: '' }, identity)).toThrow(InvalidNoteError);
-    expect(() => createNote({ title: '   ' }, identity)).toThrow(InvalidNoteError);
-  });
-
-  it('refuses a title over 200 characters', () => {
-    expect(() => createNote({ title: 'x'.repeat(201) }, identity)).toThrow(InvalidNoteError);
-    expect(() => createNote({ title: 'x'.repeat(200) }, identity)).not.toThrow();
-  });
-
-  it('refuses more than 10 tags', () => {
-    const tags = Array.from({ length: 11 }, (_, i) => `t${i}`);
-    expect(() => createNote({ title: 'T', tags }, identity)).toThrow(InvalidNoteError);
-  });
-
-  it('refuses empty or oversized tags', () => {
-    expect(() => createNote({ title: 'T', tags: [''] }, identity)).toThrow(InvalidNoteError);
-    expect(() => createNote({ title: 'T', tags: ['x'.repeat(41)] }, identity)).toThrow(
-      InvalidNoteError,
-    );
-  });
-
-  it('refuses non-object input', () => {
-    for (const bad of [null, undefined, 42, 'title', []]) {
-      expect(() => createNote(bad, identity)).toThrow(InvalidNoteError);
-    }
-  });
-
-  it('refuses wrongly-typed fields', () => {
-    expect(() => createNote({ title: 42 }, identity)).toThrow(InvalidNoteError);
-    expect(() => createNote({ title: 'T', tags: 'not-an-array' }, identity)).toThrow(
-      InvalidNoteError,
-    );
-  });
-
-  it('reports every issue with its path', () => {
-    try {
-      createNote({ title: '', tags: [''] }, identity);
-      expect.unreachable('should have thrown');
-    } catch (error) {
-      const invalid = error as InvalidNoteError;
-      expect(invalid.issues.length).toBeGreaterThanOrEqual(2);
-      expect(invalid.issues.join('\n')).toMatch(/title/);
-      expect(invalid.issues.join('\n')).toMatch(/tags/);
-    }
-  });
-});
-
-describe('slugify', () => {
-  it('lowercases and hyphenates', () => {
-    expect(slugify('Hello World')).toBe('hello-world');
-  });
-
-  it('collapses runs of non-alphanumerics and trims hyphens', () => {
-    expect(slugify('  a -- b!! c  ')).toBe('a-b-c');
-  });
-
-  it('strips diacritics', () => {
-    expect(slugify('Crème Brûlée')).toBe('creme-brulee');
-  });
-
-  it('falls back to "note" when nothing survives', () => {
-    expect(slugify('!!!')).toBe('note');
-    expect(slugify('日本語')).toBe('note');
-  });
-});

package/templates/skeleton/node-service/packages/db/package.json

@@ -1,12 +0,0 @@
-{
-  "name": "@app/db",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "@app/core": "workspace:*",
-    "@app/shared": "workspace:*"
-  }
-}

package/templates/skeleton/node-service/packages/db/src/index.ts

@@ -1 +0,0 @@
-export { JsonFileNoteStore } from './note-store.js';

package/templates/skeleton/node-service/packages/db/src/note-store.ts

@@ -1,100 +0,0 @@
-// The model boundary, same contract as any other target — only the medium
-// differs: one JSON file. This is the ONLY module that knows how notes are
-// persisted; nothing else composes a path into the data file.
-import { randomUUID } from 'node:crypto';
-import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { NoteSchema, type Note } from '@app/core';
-import { AppError, NotFoundError } from '@app/shared';
-
-type NoteTable = Record<string, unknown>;
-
-export class JsonFileNoteStore {
-  /**
-   * Writes run one at a time — **per instance, which is the whole extent of
-   * it**. A write is load → mutate → save, and that is not atomic: two
-   * concurrent `put()`s would both read the same table and the second save
-   * would drop the first note. This chain serialises the ones going through
-   * *this* object. Two `JsonFileNoteStore`s over the same file lose notes to
-   * each other exactly as before — in one process as readily as in two — so
-   * share the instance, and reach for a real lock before sharing the file.
-   */
-  private writes: Promise<unknown> = Promise.resolve();
-
-  constructor(private readonly file: string) {}
-
-  async put(note: Note): Promise<void> {
-    return this.serialised(async () => {
-      const table = await this.load();
-      if (note.id in table) {
-        throw new AppError(`note ${note.id} already exists`, { code: 'CONFLICT', statusCode: 409 });
-      }
-      table[note.id] = note;
-      await this.save(table);
-    });
-  }
-
-  async get(id: string): Promise<Note> {
-    const table = await this.load();
-    const raw = table[id];
-    if (raw === undefined) {
-      throw new NotFoundError(`note ${id} not found`);
-    }
-    // Validate on the way out: the file is an external system.
-    return NoteSchema.parse(raw);
-  }
-
-  async list(): Promise<Note[]> {
-    const table = await this.load();
-    // Validate every entry — silently skipping corruption would hide data loss.
-    return Object.values(table)
-      .map((raw) => NoteSchema.parse(raw))
-      .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-  }
-
-  /** Queues `work` behind the writes already in flight on this instance. */
-  private serialised<T>(work: () => Promise<T>): Promise<T> {
-    const result = this.writes.then(work);
-    // The caller gets the rejection; the chain gets a settled promise. Without
-    // this line one failed write (a 409, say) would reject every write queued
-    // behind it, and this store object would stay broken for as long as it is
-    // held — the chain is per instance, so a fresh store would still work.
-    this.writes = result.then(
-      () => undefined,
-      () => undefined,
-    );
-    return result;
-  }
-
-  private async load(): Promise<NoteTable> {
-    let content: string;
-    try {
-      content = await readFile(this.file, 'utf8');
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return {};
-      throw error;
-    }
-    try {
-      return JSON.parse(content) as NoteTable;
-    } catch (cause) {
-      throw new AppError(`data file ${this.file} is corrupt`, { code: 'DATA_CORRUPT', cause });
-    }
-  }
-
-  private async save(table: NoteTable): Promise<void> {
-    await mkdir(path.dirname(this.file), { recursive: true });
-    // Write-then-rename keeps readers from ever seeing a half-written file.
-    // The temp name is unique per write: a shared one lets two writers scribble
-    // over each other's file and lose a rename to ENOENT.
-    const tmp = `${this.file}.${process.pid}.${randomUUID()}.tmp`;
-    try {
-      await writeFile(tmp, JSON.stringify(table, null, 2));
-      await rename(tmp, this.file);
-    } catch (error) {
-      // Best-effort tidy-up: a failure to remove the temp file must not
-      // replace the failure that actually matters.
-      await rm(tmp, { force: true }).catch(() => undefined);
-      throw error;
-    }
-  }
-}

package/templates/skeleton/node-service/packages/db/test/note-store.test.ts

@@ -1,100 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { AppError, NotFoundError } from '@app/shared';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { JsonFileNoteStore } from '../src/note-store.js';
-
-const note = {
-  id: 'n1',
-  title: 'Hello',
-  slug: 'hello',
-  tags: ['x'],
-  createdAt: '2024-01-01T00:00:00.000Z',
-};
-
-let dir: string;
-let file: string;
-
-beforeEach(async () => {
-  dir = await mkdtemp(path.join(tmpdir(), 'note-store-'));
-  file = path.join(dir, 'data', 'notes.json');
-});
-
-afterEach(async () => {
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('JsonFileNoteStore', () => {
-  it('round-trips a note (creating the data dir on first write)', async () => {
-    const store = new JsonFileNoteStore(file);
-    await store.put(note);
-    expect(await store.get('n1')).toEqual(note);
-    expect(JSON.parse(await readFile(file, 'utf8'))).toEqual({ n1: note });
-  });
-
-  it('refuses to overwrite an existing id', async () => {
-    const store = new JsonFileNoteStore(file);
-    await store.put(note);
-    await expect(store.put(note)).rejects.toThrow(AppError);
-    await expect(store.put(note)).rejects.toMatchObject({ statusCode: 409 });
-  });
-
-  it('a rejected write does not block the writes queued behind it', async () => {
-    // The 409 above cannot see this: a poisoned write chain rejects the next
-    // put() with the very same AppError the duplicate would have raised.
-    const store = new JsonFileNoteStore(file);
-    await store.put(note);
-    await expect(store.put(note)).rejects.toThrow(AppError);
-
-    await expect(store.put({ ...note, id: 'n2' })).resolves.toBeUndefined();
-    expect((await store.list()).map((n) => n.id).sort()).toEqual(['n1', 'n2']);
-  });
-
-  it('throws NotFoundError on a miss', async () => {
-    await expect(new JsonFileNoteStore(file).get('nope')).rejects.toThrow(NotFoundError);
-  });
-
-  it('refuses corrupt stored entries instead of returning them', async () => {
-    const store = new JsonFileNoteStore(file);
-    await store.put(note);
-    const table = JSON.parse(await readFile(file, 'utf8'));
-    table.n1 = { id: 'n1' };
-    await writeFile(file, JSON.stringify(table));
-    await expect(store.get('n1')).rejects.toThrow();
-  });
-
-  it('reports a corrupt data file clearly', async () => {
-    const store = new JsonFileNoteStore(file);
-    await store.put(note);
-    await writeFile(file, '{not json');
-    await expect(store.get('n1')).rejects.toMatchObject({ code: 'DATA_CORRUPT' });
-  });
-
-  it('lists notes newest-first, and an empty store as []', async () => {
-    const store = new JsonFileNoteStore(file);
-    expect(await store.list()).toEqual([]);
-    await store.put({ ...note, id: 'a', createdAt: '2024-01-01T00:00:00.000Z' });
-    await store.put({ ...note, id: 'b', createdAt: '2024-02-01T00:00:00.000Z' });
-    const listed = await store.list();
-    expect(listed.map((n) => n.id)).toEqual(['b', 'a']);
-  });
-
-  it('keeps every concurrently written note (no lost update)', async () => {
-    const store = new JsonFileNoteStore(file);
-    const ids = Array.from({ length: 20 }, (_, i) => `n${i}`);
-    await Promise.all(ids.map((id) => store.put({ ...note, id })));
-
-    expect((await store.list()).map((n) => n.id).sort()).toEqual([...ids].sort());
-    expect(Object.keys(JSON.parse(await readFile(file, 'utf8'))).sort()).toEqual([...ids].sort());
-  });
-
-  it('refuses to list corrupt entries instead of skipping them silently', async () => {
-    const store = new JsonFileNoteStore(file);
-    await store.put(note);
-    const table = JSON.parse(await readFile(file, 'utf8'));
-    table.bad = { id: 'bad' };
-    await writeFile(file, JSON.stringify(table));
-    await expect(store.list()).rejects.toThrow();
-  });
-});

package/templates/skeleton/node-service/packages/shared/package.json

@@ -1,11 +0,0 @@
-{
-  "name": "@app/shared",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "zod": "^4.4.3"
-  }
-}

package/templates/skeleton/node-service/packages/shared/src/env.ts

@@ -1,17 +0,0 @@
-import type { ZodType } from 'zod';
-import { AppError } from './errors.js';
-
-/**
- * Parse the environment through a zod schema, once, at startup. Configuration
- * is invalid → the process fails loudly at boot, not deep inside a request.
- */
-export function loadEnv<T>(schema: ZodType<T>, source: Record<string, string | undefined>): T {
-  const parsed = schema.safeParse(source);
-  if (!parsed.success) {
-    const details = parsed.error.issues
-      .map((issue) => `${issue.path.join('.') || '(root)'}: ${issue.message}`)
-      .join('; ');
-    throw new AppError(`invalid environment: ${details}`, { code: 'ENV_INVALID' });
-  }
-  return parsed.data;
-}

package/templates/skeleton/node-service/packages/shared/src/errors.ts

@@ -1,33 +0,0 @@
-/**
- * Typed errors. Every error that crosses a layer boundary is one of these —
- * handlers map them to transport codes without inspecting messages.
- */
-export class AppError extends Error {
-  readonly code: string;
-  readonly statusCode: number;
-
-  constructor(
-    message: string,
-    options: { code?: string; statusCode?: number; cause?: unknown } = {},
-  ) {
-    super(message, options.cause !== undefined ? { cause: options.cause } : undefined);
-    this.name = new.target.name;
-    this.code = options.code ?? 'INTERNAL';
-    this.statusCode = options.statusCode ?? 500;
-  }
-}
-
-export class ValidationError extends AppError {
-  readonly issues: readonly string[];
-
-  constructor(message: string, issues: readonly string[] = []) {
-    super(message, { code: 'VALIDATION', statusCode: 400 });
-    this.issues = issues;
-  }
-}
-
-export class NotFoundError extends AppError {
-  constructor(message: string) {
-    super(message, { code: 'NOT_FOUND', statusCode: 404 });
-  }
-}

package/templates/skeleton/node-service/packages/shared/src/index.ts

@@ -1,3 +0,0 @@
-export { AppError, NotFoundError, ValidationError } from './errors.js';
-export { createLogger, type Logger } from './logger.js';
-export { loadEnv } from './env.js';

package/templates/skeleton/node-service/packages/shared/src/logger.ts

@@ -1,20 +0,0 @@
-/** Minimal structured logger: one JSON object per line on stdout. */
-export interface Logger {
-  info(message: string, fields?: Record<string, unknown>): void;
-  warn(message: string, fields?: Record<string, unknown>): void;
-  error(message: string, fields?: Record<string, unknown>): void;
-}
-
-export function createLogger(
-  base: Record<string, unknown> = {},
-  write: (line: string) => void = (line) => process.stdout.write(line + '\n'),
-): Logger {
-  const emit = (level: string, message: string, fields?: Record<string, unknown>) => {
-    write(JSON.stringify({ level, message, ...base, ...fields }));
-  };
-  return {
-    info: (message, fields) => emit('info', message, fields),
-    warn: (message, fields) => emit('warn', message, fields),
-    error: (message, fields) => emit('error', message, fields),
-  };
-}

package/templates/skeleton/node-service/packages/shared/test/env.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod';
-import { AppError } from '../src/errors.js';
-import { loadEnv } from '../src/env.js';
-
-const schema = z.object({
-  TABLE_NAME: z.string().min(1),
-  QUEUE_URL: z.string().min(1),
-});
-
-describe('loadEnv', () => {
-  it('returns the typed subset of the environment', () => {
-    const env = loadEnv(schema, { TABLE_NAME: 't', QUEUE_URL: 'q', UNRELATED: 'x' });
-    expect(env).toEqual({ TABLE_NAME: 't', QUEUE_URL: 'q' });
-  });
-
-  it('fails loudly, naming every missing key', () => {
-    expect(() => loadEnv(schema, {})).toThrow(AppError);
-    expect(() => loadEnv(schema, {})).toThrow(/TABLE_NAME/);
-    expect(() => loadEnv(schema, {})).toThrow(/QUEUE_URL/);
-  });
-
-  it('rejects empty values', () => {
-    expect(() => loadEnv(schema, { TABLE_NAME: '', QUEUE_URL: 'q' })).toThrow(/TABLE_NAME/);
-  });
-});