create-agent-rig 0.9.1 → 0.10.1

package/templates/skeleton/node-service/pnpm-workspace.yaml

@@ -1,13 +0,0 @@
-packages:
-  - packages/*
-  - services/*
-  - apps/*
-
-# esbuild arrives via tsx. Its postinstall is intentionally NOT approved:
-# skipping it keeps the JS launcher (which resolves the platform binary
-# itself); approving it swaps in a raw binary that pnpm's bin shim can't run.
-# sharp (via next) only matters for the image optimizer, which a static
-# export never runs — its native build stays off.
-allowBuilds:
-  esbuild: false
-  sharp: false

package/templates/skeleton/node-service/scripts/build-artifact.mjs

@@ -1,34 +0,0 @@
-// Builds the deployable artifact: a bundled server plus the web public dir,
-// into dist/. It produces a real, runnable thing — it does not ship it
-// anywhere. Run it: STATIC_DIR=dist/public node dist/server.mjs
-import { build } from 'esbuild';
-import { cp, mkdir, rm } from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const dist = path.join(root, 'dist');
-
-await rm(dist, { recursive: true, force: true });
-await mkdir(dist, { recursive: true });
-
-await build({
-  entryPoints: [path.join(root, 'services', 'api', 'src', 'main.ts')],
-  outfile: path.join(dist, 'server.mjs'),
-  bundle: true,
-  platform: 'node',
-  format: 'esm',
-  target: 'node22',
-  // ESM-on-node output may reference require() from a dependency — shim it.
-  banner: {
-    js: "import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);",
-  },
-});
-
-// The built web bundle, if present (pnpm build:web). Served via STATIC_DIR.
-await cp(path.join(root, 'apps', 'web', 'out'), path.join(dist, 'public'), {
-  recursive: true,
-}).catch(() => {});
-
-console.log('artifact built: dist/server.mjs (+ dist/public if the web was built).');
-console.log('run it: STATIC_DIR=dist/public node dist/server.mjs');

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

@@ -1,17 +0,0 @@
-{
-  "name": "@app/api",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "main": "src/main.ts",
-  "types": "src/main.ts",
-  "scripts": {
-    "start": "tsx src/main.ts"
-  },
-  "dependencies": {
-    "@app/core": "workspace:*",
-    "@app/db": "workspace:*",
-    "@app/shared": "workspace:*",
-    "zod": "^4.4.3"
-  }
-}

package/templates/skeleton/node-service/services/api/src/adapters/spool-publisher.ts

@@ -1,23 +0,0 @@
-// The queue between api and worker is a spool directory: one JSON file per
-// event. Same DLQ discipline as any queue — the worker moves poison files to
-// the DLQ directory after its retry budget.
-import { mkdir, rename, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import type { NoteCreatedEvent } from '@app/core';
-import type { EventPublisher } from '../usecases/create-note.js';
-
-export class SpoolEventPublisher implements EventPublisher {
-  constructor(
-    private readonly queueDir: string,
-    /** Unique, sortable message name — injected so tests stay deterministic. */
-    private readonly nextName: () => string,
-  ) {}
-
-  async publish(event: NoteCreatedEvent): Promise<void> {
-    await mkdir(this.queueDir, { recursive: true });
-    const file = path.join(this.queueDir, `${this.nextName()}.json`);
-    // Write-then-rename so the worker never picks up a half-written message.
-    await writeFile(`${file}.tmp`, JSON.stringify(event));
-    await rename(`${file}.tmp`, file);
-  }
-}

package/templates/skeleton/node-service/services/api/src/handlers/create-note.ts

@@ -1,40 +0,0 @@
-// The handler translates transport ⇄ domain and nothing else: decode the
-// payload, call the usecase, map the result (or the typed error) to HTTP.
-import { InvalidNoteError } from '@app/core';
-import { AppError } from '@app/shared';
-import { createNoteUsecase, type CreateNoteDeps } from '../usecases/create-note.js';
-
-export interface HttpResponse {
-  statusCode: number;
-  body: string;
-}
-
-const json = (statusCode: number, body: unknown): HttpResponse => ({
-  statusCode,
-  body: JSON.stringify(body),
-});
-
-export function makeCreateNoteHandler(deps: CreateNoteDeps) {
-  return async (rawBody: string): Promise<HttpResponse> => {
-    let payload: unknown;
-    try {
-      payload = JSON.parse(rawBody);
-    } catch {
-      return json(400, { error: 'body must be valid JSON' });
-    }
-
-    try {
-      const note = await createNoteUsecase(payload, deps);
-      return json(201, { note });
-    } catch (error) {
-      if (error instanceof InvalidNoteError) {
-        return json(400, { error: 'invalid note', issues: error.issues });
-      }
-      if (error instanceof AppError) {
-        return json(error.statusCode, { error: error.message, code: error.code });
-      }
-      deps.log.error('unhandled error in create-note', { error: String(error) });
-      return json(500, { error: 'internal error' });
-    }
-  };
-}

package/templates/skeleton/node-service/services/api/src/handlers/list-notes.ts

@@ -1,23 +0,0 @@
-import { AppError } from '@app/shared';
-import type { Logger } from '@app/shared';
-import { listNotesUsecase, type ListNotesDeps } from '../usecases/list-notes.js';
-import type { HttpResponse } from './create-note.js';
-
-const json = (statusCode: number, body: unknown): HttpResponse => ({
-  statusCode,
-  body: JSON.stringify(body),
-});
-
-export function makeListNotesHandler(deps: ListNotesDeps & { log: Logger }) {
-  return async (): Promise<HttpResponse> => {
-    try {
-      return json(200, { notes: await listNotesUsecase(deps) });
-    } catch (error) {
-      if (error instanceof AppError) {
-        return json(error.statusCode, { error: error.message, code: error.code });
-      }
-      deps.log.error('unhandled error in list-notes', { error: String(error) });
-      return json(500, { error: 'internal error' });
-    }
-  };
-}

package/templates/skeleton/node-service/services/api/src/main.ts

@@ -1,40 +0,0 @@
-// Composition root — the ONLY file with real wiring. Tests target the
-// factories with stub deps and never import this module.
-import { randomUUID } from 'node:crypto';
-import path from 'node:path';
-import { z } from 'zod';
-import { JsonFileNoteStore } from '@app/db';
-import { createLogger, loadEnv } from '@app/shared';
-import { SpoolEventPublisher } from './adapters/spool-publisher.js';
-import { makeServer } from './server.js';
-import { defaultStaticDirFor } from './static-dir.js';
-
-// The built web bundle (pnpm build:web) lives here; served when present.
-const defaultStaticDir = defaultStaticDirFor(import.meta.url);
-
-const env = loadEnv(
-  z.object({
-    PORT: z.coerce.number().int().positive().default(3000),
-    DATA_DIR: z.string().min(1).default('var/data'),
-    QUEUE_DIR: z.string().min(1).default('var/queue'),
-    STATIC_DIR: z.string().min(1).default(defaultStaticDir),
-  }),
-  process.env,
-);
-
-const log = createLogger({ service: 'api' });
-
-const server = makeServer(
-  {
-    notes: new JsonFileNoteStore(path.join(env.DATA_DIR, 'notes.json')),
-    events: new SpoolEventPublisher(env.QUEUE_DIR, () => `${Date.now()}-${randomUUID()}`),
-    newId: () => randomUUID(),
-    now: () => new Date().toISOString(),
-    log,
-  },
-  { staticDir: env.STATIC_DIR },
-);
-
-server.listen(env.PORT, () => {
-  log.info('api listening', { port: env.PORT });
-});

package/templates/skeleton/node-service/services/api/src/server.ts

@@ -1,172 +0,0 @@
-// Thin HTTP shell around the handlers: routing, body collection, and (when
-// configured) serving the built web bundle. No second runtime for the
-// frontend — the same process serves the static export.
-import { createReadStream } from 'node:fs';
-import { realpath, stat } from 'node:fs/promises';
-import { createServer, type Server } from 'node:http';
-import path from 'node:path';
-import type { CreateNoteDeps } from './usecases/create-note.js';
-import type { ListNotesDeps } from './usecases/list-notes.js';
-import { makeCreateNoteHandler } from './handlers/create-note.js';
-import { makeListNotesHandler } from './handlers/list-notes.js';
-import type { HttpResponse } from './handlers/create-note.js';
-
-export type ServerDeps = CreateNoteDeps & ListNotesDeps;
-
-export interface ServerOptions {
-  /** Directory of the built web bundle (apps/web/out). Unset = API only. */
-  staticDir?: string;
-}
-
-/**
- * Largest request body `POST /notes` will buffer — that route and no other:
- * the cap is applied where the body is read, so a second route that reads one
- * brings its own. A note is a title and some tags; anything past this is a
- * mistake or an attack, and either way the process must not hold it in memory.
- */
-const MAX_BODY_BYTES = 1024 * 1024;
-
-const CONTENT_TYPES: Record<string, string> = {
-  '.html': 'text/html; charset=utf-8',
-  '.css': 'text/css',
-  '.js': 'text/javascript',
-  '.json': 'application/json',
-  '.svg': 'image/svg+xml',
-  '.png': 'image/png',
-  '.ico': 'image/x-icon',
-  '.txt': 'text/plain; charset=utf-8',
-};
-
-export function makeServer(deps: ServerDeps, options: ServerOptions = {}): Server {
-  const createNote = makeCreateNoteHandler(deps);
-  const listNotes = makeListNotesHandler(deps);
-
-  return createServer((request, response) => {
-    const respond = (result: HttpResponse) => {
-      response.writeHead(result.statusCode, { 'content-type': 'application/json' });
-      response.end(result.body);
-    };
-    const notFound = () => respond({ statusCode: 404, body: JSON.stringify({ error: 'not found' }) });
-    const badRequest = () =>
-      respond({ statusCode: 400, body: JSON.stringify({ error: 'bad request' }) });
-
-    if (request.method === 'POST' && request.url === '/notes') {
-      const chunks: Buffer[] = [];
-      let size = 0;
-      let refused = false;
-      // A socket that dies mid-upload emits 'error'; unhandled, it takes the
-      // process with it.
-      request.on('error', () => {
-        refused = true;
-      });
-      request.on('data', (chunk: Buffer) => {
-        if (refused) return;
-        size += chunk.length;
-        if (size > MAX_BODY_BYTES) {
-          refused = true;
-          chunks.length = 0;
-          respond({ statusCode: 413, body: JSON.stringify({ error: 'payload too large' }) });
-          // Keep draining rather than destroying the socket: a client that is
-          // still uploading has to stay connected to read the refusal.
-          request.resume();
-          return;
-        }
-        chunks.push(chunk);
-      });
-      request.on('end', () => {
-        if (refused) return;
-        void createNote(Buffer.concat(chunks).toString('utf8')).then(respond);
-      });
-      return;
-    }
-
-    if (request.method === 'GET' && request.url === '/notes') {
-      void listNotes().then(respond);
-      return;
-    }
-
-    if (request.method === 'GET' && options.staticDir) {
-      // The rejection handler is the point: without it a throw in here is an
-      // unhandled rejection, which ends the process on one malformed request.
-      void serveStatic(options.staticDir, request.url ?? '/', response, notFound, badRequest).catch(
-        (error: unknown) => {
-          // Say nothing to the client beyond the code, but never swallow it —
-          // a static path that fails silently is a blind spot in every
-          // generated project.
-          deps.log.error('static serve failed', { url: request.url, error: String(error) });
-          if (response.headersSent) {
-            response.destroy();
-            return;
-          }
-          respond({ statusCode: 500, body: JSON.stringify({ error: 'internal error' }) });
-        },
-      );
-      return;
-    }
-
-    notFound();
-  });
-}
-
-async function serveStatic(
-  staticDir: string,
-  rawUrl: string,
-  response: import('node:http').ServerResponse,
-  notFound: () => void,
-  badRequest: () => void,
-): Promise<void> {
-  let pathname: string;
-  try {
-    pathname = decodeURIComponent(new URL(rawUrl, 'http://local').pathname);
-  } catch {
-    // A malformed escape (`GET /%`) is the client's error, not ours.
-    return badRequest();
-  }
-  const relative = pathname.endsWith('/') ? `${pathname}index.html` : pathname;
-  // Resolve the root first: a configured dir with a trailing separator would
-  // otherwise build a `//` prefix that no resolved path can start with, and
-  // every request would 404.
-  const root = path.resolve(staticDir);
-  const resolved = path.resolve(root, `.${path.sep}${relative}`);
-  // Path-traversal guard: whatever the URL said, we never leave staticDir.
-  // The string test is only half of it — it says where the path points, not
-  // what the filesystem will open, and stat/open both follow symlinks.
-  if (!within(root, resolved)) {
-    return notFound();
-  }
-  let file: string;
-  try {
-    // …so ask the filesystem too, and test the answer the same way. A missing
-    // file throws here, which is the 404 we would give it anyway.
-    file = await realpath(resolved);
-    if (!within(await realpath(root), file)) return notFound();
-    const stats = await stat(file);
-    if (!stats.isFile()) return notFound();
-  } catch {
-    return notFound();
-  }
-  // Open before the headers go out: a file that passes stat can still fail to
-  // open (EACCES, or it is gone by now), and after writeHead(200) there is no
-  // way left to say so — which is one GET away from an unhandled stream error.
-  const stream = createReadStream(file);
-  await new Promise<void>((resolve, reject) => {
-    stream.once('error', reject);
-    stream.once('open', () => {
-      stream.removeListener('error', reject);
-      response.writeHead(200, {
-        'content-type': CONTENT_TYPES[path.extname(file)] ?? 'application/octet-stream',
-      });
-      // Past the headers the only honest answer to a read failure is to cut
-      // the response short, so the client sees a truncated body rather than a
-      // complete one.
-      stream.once('error', () => response.destroy());
-      stream.pipe(response);
-      resolve();
-    });
-  });
-}
-
-/** Whether `candidate` is `root` itself or sits underneath it. */
-function within(root: string, candidate: string): boolean {
-  return candidate === root || candidate.startsWith(root + path.sep);
-}

package/templates/skeleton/node-service/services/api/src/static-dir.ts

@@ -1,20 +0,0 @@
-// Where the built web bundle lives, resolved relative to the composition root.
-// A pure function rather than an inline expression in main.ts: main.ts is wiring
-// that tests never import, and this resolution has a bug worth pinning —
-// `new URL(url).pathname` leaves percent-escapes in place (a checkout under
-// "/Users/a b/" resolves to "/Users/a%20b/") and prefixes a slash on Windows.
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-/** `apps/web/out`, three levels up from a module in `services/api/src`. */
-export function defaultStaticDirFor(moduleUrl: string): string {
-  return path.resolve(
-    path.dirname(fileURLToPath(moduleUrl)),
-    '..',
-    '..',
-    '..',
-    'apps',
-    'web',
-    'out',
-  );
-}

package/templates/skeleton/node-service/services/api/src/usecases/create-note.ts

@@ -1,30 +0,0 @@
-// The usecase layer is mandatory: every business operation lives here, and
-// handlers call nothing below it. Dependencies are consumer-owned interfaces —
-// the usecase says what it needs, adapters satisfy it.
-import { createNote, makeNoteCreatedEvent, type Note, type NoteCreatedEvent } from '@app/core';
-import type { Logger } from '@app/shared';
-
-export interface NoteStore {
-  put(note: Note): Promise<void>;
-}
-
-export interface EventPublisher {
-  publish(event: NoteCreatedEvent): Promise<void>;
-}
-
-export interface CreateNoteDeps {
-  notes: NoteStore;
-  events: EventPublisher;
-  /** Id generation and the clock are decided here, never inside the core. */
-  newId(): string;
-  now(): string;
-  log: Logger;
-}
-
-export async function createNoteUsecase(input: unknown, deps: CreateNoteDeps): Promise<Note> {
-  const note = createNote(input, { id: deps.newId(), createdAt: deps.now() });
-  await deps.notes.put(note);
-  await deps.events.publish(makeNoteCreatedEvent(note));
-  deps.log.info('note created', { noteId: note.id, slug: note.slug });
-  return note;
-}

package/templates/skeleton/node-service/services/api/src/usecases/list-notes.ts

@@ -1,14 +0,0 @@
-// Even a trivial read goes through a usecase — the uniformity is the rule.
-import type { Note } from '@app/core';
-
-export interface NoteLister {
-  list(): Promise<Note[]>;
-}
-
-export interface ListNotesDeps {
-  notes: NoteLister;
-}
-
-export async function listNotesUsecase(deps: ListNotesDeps): Promise<Note[]> {
-  return deps.notes.list();
-}

package/templates/skeleton/node-service/services/api/test/artifact.test.ts

@@ -1,92 +0,0 @@
-// CD brief §2: node-service's deployable artifact must actually build and run.
-// This bundles the server, boots the bundle over a real socket, and closes the
-// path — proving the artifact is genuine, not a stub.
-import { spawn } from 'node:child_process';
-import { mkdtemp, readFile, rm, stat } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import type { AddressInfo } from 'node:net';
-import { createServer } from 'node:net';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { runPackageManager } from './package-manager.js';
-
-const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
-const dist = path.join(projectRoot, 'dist');
-
-function freePort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const srv = createServer();
-    srv.listen(0, () => {
-      const { port } = srv.address() as AddressInfo;
-      srv.close(() => resolve(port));
-    });
-    srv.on('error', reject);
-  });
-}
-
-describe('deployable artifact (dist/)', () => {
-  let child: ReturnType<typeof spawn> | undefined;
-  let work: string;
-
-  beforeAll(async () => {
-    work = await mkdtemp(path.join(tmpdir(), 'artifact-'));
-    // `pnpm check` builds the artifact before tests; build it here only if a
-    // bare `pnpm test` run left no dist to boot.
-    const built = await stat(path.join(dist, 'server.mjs')).then(
-      () => true,
-      () => false,
-    );
-    if (!built) await runPackageManager(['build:artifact'], { cwd: projectRoot });
-  }, 180_000);
-
-  afterAll(async () => {
-    child?.kill();
-    await rm(work, { recursive: true, force: true });
-  });
-
-  it('produces a bundled server and the web public dir', async () => {
-    expect((await stat(path.join(dist, 'server.mjs'))).size).toBeGreaterThan(1000);
-    await expect(readFile(path.join(dist, 'public', 'index.html'), 'utf8')).resolves.toContain(
-      '<',
-    );
-  });
-
-  it('the bundle boots and serves the full request path', async () => {
-    const port = await freePort();
-    child = spawn(process.execPath, [path.join(dist, 'server.mjs')], {
-      env: {
-        ...process.env,
-        PORT: String(port),
-        DATA_DIR: path.join(work, 'data'),
-        QUEUE_DIR: path.join(work, 'queue'),
-        STATIC_DIR: path.join(dist, 'public'),
-      },
-      stdio: 'ignore',
-    });
-
-    const base = `http://127.0.0.1:${port}`;
-    // wait for readiness
-    for (let i = 0; i < 50; i++) {
-      try {
-        await fetch(base + '/notes');
-        break;
-      } catch {
-        await new Promise((r) => setTimeout(r, 100));
-      }
-    }
-
-    const created = await fetch(base + '/notes', {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ title: 'artifact proof' }),
-    });
-    expect(created.status).toBe(201);
-    const listed = (await (await fetch(base + '/notes')).json()) as { notes: unknown[] };
-    expect(listed.notes).toHaveLength(1);
-    // the bundle also serves the web shell
-    const root = await fetch(base + '/');
-    expect(root.status).toBe(200);
-    expect(root.headers.get('content-type')).toContain('text/html');
-  }, 30_000);
-});

package/templates/skeleton/node-service/services/api/test/create-note.handler.test.ts

@@ -1,64 +0,0 @@
-import { AppError, createLogger } from '@app/shared';
-import { describe, expect, it } from 'vitest';
-import { makeCreateNoteHandler } from '../src/handlers/create-note.js';
-import type { CreateNoteDeps } from '../src/usecases/create-note.js';
-
-function stubDeps(overrides: Partial<CreateNoteDeps> = {}) {
-  const deps: CreateNoteDeps = {
-    notes: { put: async () => {} },
-    events: { publish: async () => {} },
-    newId: () => 'fixed-id',
-    now: () => '2024-01-01T00:00:00.000Z',
-    log: createLogger({}, () => {}),
-    ...overrides,
-  };
-  return deps;
-}
-
-describe('POST /notes handler', () => {
-  it('returns 201 with the created note', async () => {
-    const handler = makeCreateNoteHandler(stubDeps());
-    const result = await handler(JSON.stringify({ title: 'Hello' }));
-    expect(result.statusCode).toBe(201);
-    expect(JSON.parse(result.body)).toMatchObject({
-      note: { id: 'fixed-id', slug: 'hello', createdAt: '2024-01-01T00:00:00.000Z' },
-    });
-  });
-
-  it('returns 400 for malformed JSON', async () => {
-    const result = await makeCreateNoteHandler(stubDeps())('{not json');
-    expect(result.statusCode).toBe(400);
-  });
-
-  it('returns 400 with issues for invalid input', async () => {
-    const result = await makeCreateNoteHandler(stubDeps())(JSON.stringify({ title: '' }));
-    expect(result.statusCode).toBe(400);
-    expect(JSON.parse(result.body).issues.join(' ')).toMatch(/title/);
-  });
-
-  it('maps typed errors to their status code', async () => {
-    const handler = makeCreateNoteHandler(
-      stubDeps({
-        notes: {
-          put: () => Promise.reject(new AppError('conflict', { statusCode: 409, code: 'DUP' })),
-        },
-      }),
-    );
-    const result = await handler(JSON.stringify({ title: 'T' }));
-    expect(result.statusCode).toBe(409);
-  });
-
-  it('hides unknown errors behind a 500 and logs them', async () => {
-    const logs: string[] = [];
-    const handler = makeCreateNoteHandler(
-      stubDeps({
-        notes: { put: () => Promise.reject(new Error('secret detail')) },
-        log: createLogger({}, (line) => logs.push(line)),
-      }),
-    );
-    const result = await handler(JSON.stringify({ title: 'T' }));
-    expect(result.statusCode).toBe(500);
-    expect(result.body).not.toContain('secret detail');
-    expect(logs.join('\n')).toContain('secret detail');
-  });
-});

package/templates/skeleton/node-service/services/api/test/create-note.usecase.test.ts

@@ -1,43 +0,0 @@
-import { InvalidNoteError, type Note, type NoteCreatedEvent } from '@app/core';
-import { createLogger } from '@app/shared';
-import { describe, expect, it } from 'vitest';
-import { createNoteUsecase, type CreateNoteDeps } from '../src/usecases/create-note.js';
-
-function stubDeps() {
-  const stored: Note[] = [];
-  const published: NoteCreatedEvent[] = [];
-  const logs: string[] = [];
-  const deps: CreateNoteDeps = {
-    notes: { put: async (note) => void stored.push(note) },
-    events: { publish: async (event) => void published.push(event) },
-    newId: () => 'fixed-id',
-    now: () => '2024-01-01T00:00:00.000Z',
-    log: createLogger({}, (line) => logs.push(line)),
-  };
-  return { deps, stored, published, logs };
-}
-
-describe('createNoteUsecase', () => {
-  it('creates, stores, publishes, and logs', async () => {
-    const { deps, stored, published, logs } = stubDeps();
-    const note = await createNoteUsecase({ title: 'Hello World' }, deps);
-    expect(note).toMatchObject({ id: 'fixed-id', slug: 'hello-world' });
-    expect(stored).toEqual([note]);
-    expect(published).toEqual([{ type: 'note.created', note }]);
-    expect(logs.join('\n')).toContain('fixed-id');
-  });
-
-  it('rejects invalid input before any side effect', async () => {
-    const { deps, stored, published } = stubDeps();
-    await expect(createNoteUsecase({ title: '' }, deps)).rejects.toThrow(InvalidNoteError);
-    expect(stored).toEqual([]);
-    expect(published).toEqual([]);
-  });
-
-  it('propagates store failures and does not publish', async () => {
-    const { deps, published } = stubDeps();
-    deps.notes = { put: () => Promise.reject(new Error('disk full')) };
-    await expect(createNoteUsecase({ title: 'T' }, deps)).rejects.toThrow('disk full');
-    expect(published).toEqual([]);
-  });
-});