@satorio/machinery 0.2.1

package/dist/testing/blob-store.js

@@ -0,0 +1,45 @@
+import { BlobStore, BlobStoreUnavailableError, } from '@satorio/machinery/ports';
+import { Effect, Layer, Option, Ref } from 'effect';
+const NOT_MOUNTED = 'object store unavailable (test)';
+/**
+ * An in-memory blob store over a `Ref` you keep, so a test can seed it
+ * before the run and read it after.
+ */
+export const makeInMemoryBlobStoreWith = (blobs) => ({
+    put: (key, blob) => Ref.update(blobs, (current) => new Map(current).set(key, blob)),
+    get: (key) => Ref.get(blobs).pipe(Effect.map((current) => Option.fromNullable(current.get(key)))),
+    exists: (key) => Ref.get(blobs).pipe(Effect.map((current) => current.has(key))),
+    delete: (key) => Ref.update(blobs, (current) => {
+        const next = new Map(current);
+        next.delete(key);
+        return next;
+    }),
+});
+/**
+ * An in-memory blob store over a `Ref` of its own, empty at the start.
+ */
+export const makeInMemoryBlobStore = Effect.gen(function* () {
+    const blobs = yield* Ref.make(new Map());
+    return makeInMemoryBlobStoreWith(blobs);
+});
+/**
+ * The in-memory blob store, mounted.
+ */
+export const InMemoryBlobStoreLive = Layer.effect(BlobStore, makeInMemoryBlobStore);
+/**
+ * A blob store that answers nothing: every operation fails with
+ * `BlobStoreUnavailableError`. Mount it to walk the branch a working
+ * stand-in never reaches.
+ */
+export const BlobStoreUnavailableLive = Layer.succeed(BlobStore, {
+    put: () => new BlobStoreUnavailableError({ operation: 'put', cause: NOT_MOUNTED }),
+    get: () => new BlobStoreUnavailableError({ operation: 'get', cause: NOT_MOUNTED }),
+    exists: () => new BlobStoreUnavailableError({
+        operation: 'exists',
+        cause: NOT_MOUNTED,
+    }),
+    delete: () => new BlobStoreUnavailableError({
+        operation: 'delete',
+        cause: NOT_MOUNTED,
+    }),
+});

package/dist/testing/clock.d.ts

@@ -0,0 +1,29 @@
+import { Clock, DateTime, type Duration, Effect } from 'effect';
+/**
+ * Sets the controlled test clock to the given ISO moment. Tests read
+ * time through Effect, so this is the only clock code ever sees.
+ */
+export declare const setNowTo: (isoTimestamp: string) => Effect.Effect<void>;
+/**
+ * Moves the controlled test clock on by the span handed in, so a test reaches
+ * a later moment without waiting for it.
+ */
+export declare const advanceBy: (duration: Duration.DurationInput) => Effect.Effect<void>;
+/**
+ * The moment the clock reads now, as a moment on the world's clock.
+ */
+export declare const nowAsDateTime: Effect.Effect<DateTime.Utc>;
+/**
+ * The moment the clock reads now, written the way it travels the wire.
+ */
+export declare const nowAsIsoString: Effect.Effect<string>;
+/**
+ * Builds a Clock pinned to one moment: every time read inside returns
+ * that moment, while `sleep` still waits on the real clock.
+ */
+export declare const clockPinnedAt: (at: DateTime.Utc) => Clock.Clock;
+/**
+ * Runs the given work "at" the given moment: every clock read inside
+ * it sees `isoTimestamp`.
+ */
+export declare const atTheMoment: (isoTimestamp: string) => <A, E, R>(work: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;

package/dist/testing/clock.js

@@ -0,0 +1,41 @@
+import { Clock, DateTime, Effect, TestClock } from 'effect';
+/**
+ * Sets the controlled test clock to the given ISO moment. Tests read
+ * time through Effect, so this is the only clock code ever sees.
+ */
+export const setNowTo = (isoTimestamp) => TestClock.setTime(DateTime.toEpochMillis(DateTime.unsafeMake(isoTimestamp)));
+/**
+ * Moves the controlled test clock on by the span handed in, so a test reaches
+ * a later moment without waiting for it.
+ */
+export const advanceBy = (duration) => TestClock.adjust(duration);
+/**
+ * The moment the clock reads now, as a moment on the world's clock.
+ */
+export const nowAsDateTime = DateTime.now;
+/**
+ * The moment the clock reads now, written the way it travels the wire.
+ */
+export const nowAsIsoString = DateTime.now.pipe(Effect.map(DateTime.formatIso));
+/**
+ * Builds a Clock pinned to one moment: every time read inside returns
+ * that moment, while `sleep` still waits on the real clock.
+ */
+export const clockPinnedAt = (at) => {
+    const millis = DateTime.toEpochMillis(at);
+    const nanos = BigInt(millis) * 1000000n;
+    const live = Clock.make();
+    return {
+        [Clock.ClockTypeId]: Clock.ClockTypeId,
+        unsafeCurrentTimeMillis: () => millis,
+        currentTimeMillis: Effect.succeed(millis),
+        unsafeCurrentTimeNanos: () => nanos,
+        currentTimeNanos: Effect.succeed(nanos),
+        sleep: (duration) => live.sleep(duration),
+    };
+};
+/**
+ * Runs the given work "at" the given moment: every clock read inside
+ * it sees `isoTimestamp`.
+ */
+export const atTheMoment = (isoTimestamp) => (work) => Effect.withClock(work, clockPinnedAt(DateTime.unsafeMake(isoTimestamp)));

package/dist/testing/dna-perturbator/attention.d.ts

@@ -0,0 +1,55 @@
+import type { ChainRange } from './chains.js';
+/**
+ * How much attention one chain receives, counted in mutants.
+ *
+ * @internal
+ */
+export interface ChainAttention {
+    readonly chain: string;
+    readonly mutants: number;
+    readonly caughtByStaticAnalysis: number;
+    readonly killedByTests: number;
+    readonly killingTestRuns: number;
+    readonly survived: number;
+}
+/**
+ * @internal
+ */
+export interface ReportMutant {
+    readonly status: string;
+    readonly location: {
+        readonly start: {
+            readonly line: number;
+        };
+    };
+    readonly killedBy?: readonly string[];
+    readonly testsCompleted?: number;
+}
+/**
+ * One mutation-testing report, in the shape every mutation runner
+ * writes: files by path, each with the mutants it produced.
+ *
+ * @internal
+ */
+export interface MutationReport {
+    readonly files: Readonly<Record<string, {
+        readonly mutants: readonly ReportMutant[];
+    }>>;
+}
+/**
+ * The attention map: for every chain of one dna file, how many mutants
+ * the mutation run produced, how many static analysis refused before a
+ * single test ran, how many the tests killed and with how many test
+ * runs, and how many survived. A chain with survivors is a chain nobody
+ * is really watching, whatever the coverage percentage says.
+ *
+ * @internal
+ */
+export declare const attentionMapOf: (report: MutationReport, dnaPath: string, ranges: readonly ChainRange[]) => readonly ChainAttention[];
+/**
+ * The attention map as the lines a person reads, one chain per line,
+ * with the chains nobody watches named last.
+ *
+ * @internal
+ */
+export declare const attentionLinesOf: (implant: string, map: readonly ChainAttention[]) => readonly string[];

package/dist/testing/dna-perturbator/attention.js

@@ -0,0 +1,49 @@
+const isKilled = (status) => status === 'Killed' || status === 'Timeout';
+const isCompileError = (status) => status === 'CompileError';
+/**
+ * The attention map: for every chain of one dna file, how many mutants
+ * the mutation run produced, how many static analysis refused before a
+ * single test ran, how many the tests killed and with how many test
+ * runs, and how many survived. A chain with survivors is a chain nobody
+ * is really watching, whatever the coverage percentage says.
+ *
+ * @internal
+ */
+export const attentionMapOf = (report, dnaPath, ranges) => {
+    const mutants = report.files[dnaPath]?.mutants ?? [];
+    return ranges.map((range) => {
+        const own = mutants.filter((mutant) => mutant.location.start.line >= range.startLine &&
+            mutant.location.start.line <= range.endLine);
+        const killed = own.filter((mutant) => isKilled(mutant.status));
+        return {
+            chain: range.chain,
+            mutants: own.length,
+            caughtByStaticAnalysis: own.filter((mutant) => isCompileError(mutant.status)).length,
+            killedByTests: killed.length,
+            killingTestRuns: killed.reduce((total, mutant) => total + (mutant.killedBy?.length ?? mutant.testsCompleted ?? 0), 0),
+            survived: own.filter((mutant) => !isKilled(mutant.status) && !isCompileError(mutant.status)).length,
+        };
+    });
+};
+/**
+ * The attention map as the lines a person reads, one chain per line,
+ * with the chains nobody watches named last.
+ *
+ * @internal
+ */
+export const attentionLinesOf = (implant, map) => {
+    const rows = map.map((entry) => `${implant}/${entry.chain} — ${entry.mutants} mutants: ` +
+        `${entry.caughtByStaticAnalysis} caught by static analysis before a ` +
+        `test ran, ${entry.killedByTests} killed by tests ` +
+        `(${entry.killingTestRuns} test runs did the killing), ` +
+        `${entry.survived} survived`);
+    const unwatched = map.filter((entry) => entry.survived > 0);
+    return [
+        ...rows,
+        unwatched.length === 0
+            ? 'every chain of this implant has a test that notices when it changes.'
+            : `chains with survivors, watch these first: ${unwatched
+                .map((entry) => entry.chain)
+                .join(', ')}`,
+    ];
+};

package/dist/testing/dna-perturbator/chains.d.ts

@@ -0,0 +1,31 @@
+/**
+ * One chain of a dna file and the lines it occupies, counted from one.
+ *
+ * @internal
+ */
+export interface ChainRange {
+    readonly chain: string;
+    readonly startLine: number;
+    readonly endLine: number;
+}
+/**
+ * Every chain of a dna file with the lines it owns: a chain runs from
+ * its own `export` line to the line before the next one.
+ *
+ * @internal
+ */
+export declare const chainRangesOf: (text: string) => readonly ChainRange[];
+/**
+ * The dna file with one chain removed outright. A removal is the break
+ * the demonstration wants: nothing subtle, nothing that only a linter
+ * would notice — the business chain is simply gone.
+ *
+ * @internal
+ */
+export declare const withChainRemoved: (text: string, chain: string) => string | null;
+/**
+ * The dna file with one line commented out, counted from one.
+ *
+ * @internal
+ */
+export declare const withLineCommented: (text: string, line: number) => string | null;

package/dist/testing/dna-perturbator/chains.js

@@ -0,0 +1,53 @@
+const EXPORTED_VALUE = /^export\s+(?:const|function)\s+([A-Za-z_$][\w$]*)/;
+/**
+ * Every chain of a dna file with the lines it owns: a chain runs from
+ * its own `export` line to the line before the next one.
+ *
+ * @internal
+ */
+export const chainRangesOf = (text) => {
+    const lines = text.split('\n');
+    const starts = [];
+    lines.forEach((line, index) => {
+        const match = EXPORTED_VALUE.exec(line);
+        if (match?.[1] !== undefined) {
+            starts.push({ chain: match[1], startLine: index + 1 });
+        }
+    });
+    return starts.map((start, index) => ({
+        chain: start.chain,
+        startLine: start.startLine,
+        endLine: (starts[index + 1]?.startLine ?? lines.length + 1) - 1,
+    }));
+};
+/**
+ * The dna file with one chain removed outright. A removal is the break
+ * the demonstration wants: nothing subtle, nothing that only a linter
+ * would notice — the business chain is simply gone.
+ *
+ * @internal
+ */
+export const withChainRemoved = (text, chain) => {
+    const range = chainRangesOf(text).find((entry) => entry.chain === chain);
+    if (range === undefined)
+        return null;
+    const lines = text.split('\n');
+    return [
+        ...lines.slice(0, range.startLine - 1),
+        ...lines.slice(range.endLine),
+    ].join('\n');
+};
+/**
+ * The dna file with one line commented out, counted from one.
+ *
+ * @internal
+ */
+export const withLineCommented = (text, line) => {
+    const lines = text.split('\n');
+    const target = lines[line - 1];
+    if (target === undefined)
+        return null;
+    return lines
+        .map((entry, index) => (index === line - 1 ? `// ${target}` : entry))
+        .join('\n');
+};

package/dist/testing/dna-perturbator/report.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The path of the json report a mutation run has just written, read out
+ * of that run's own output. Stryker names the file itself, once per
+ * reporter, so the tool never has to guess a location or trust a report
+ * an earlier run left behind: no line, no attention map. The html
+ * reporter prints the same sentence about its own file, so the line is
+ * matched by the reporter that wrote the json one, and the colour codes
+ * a terminal run wraps the line in are cut off the path.
+ *
+ * @internal
+ */
+export declare const jsonReportPathIn: (output: string) => string | null;

package/dist/testing/dna-perturbator/report.js

@@ -0,0 +1,22 @@
+const REPORTED_AT = /JsonReporter[^\n]*?Your report can be found at:\s*(\S+)/;
+const ESCAPE = String.fromCharCode(27);
+const FILE_URL = 'file://';
+/**
+ * The path of the json report a mutation run has just written, read out
+ * of that run's own output. Stryker names the file itself, once per
+ * reporter, so the tool never has to guess a location or trust a report
+ * an earlier run left behind: no line, no attention map. The html
+ * reporter prints the same sentence about its own file, so the line is
+ * matched by the reporter that wrote the json one, and the colour codes
+ * a terminal run wraps the line in are cut off the path.
+ *
+ * @internal
+ */
+export const jsonReportPathIn = (output) => {
+    const named = REPORTED_AT.exec(output)?.[1]?.split(ESCAPE)[0];
+    if (named === undefined || named === '')
+        return null;
+    return named.startsWith(FILE_URL)
+        ? decodeURIComponent(named.slice(FILE_URL.length))
+        : named;
+};

package/dist/testing/dna-perturbator/verdict.d.ts

@@ -0,0 +1,26 @@
+/**
+ * What one deliberate break did: how many tests turned red, and whether
+ * static analysis refused the file before a single test ran.
+ *
+ * @internal
+ */
+export interface BreakOutcome {
+    readonly what: string;
+    readonly caughtByStaticAnalysis: boolean;
+    readonly testsRed: number;
+}
+/**
+ * The one honest line a deliberate break earns. A break that leaves the
+ * suite green is printed as a finding, not as a pass: it means the
+ * chain that was removed is a chain nothing was holding.
+ *
+ * @internal
+ */
+export declare const verdictLineOf: (outcome: BreakOutcome) => string;
+/**
+ * How many tests a test-runner output says went red. Zero when the
+ * output never says.
+ *
+ * @internal
+ */
+export declare const redTestCountIn: (output: string) => number;

package/dist/testing/dna-perturbator/verdict.js

@@ -0,0 +1,28 @@
+/**
+ * The one honest line a deliberate break earns. A break that leaves the
+ * suite green is printed as a finding, not as a pass: it means the
+ * chain that was removed is a chain nothing was holding.
+ *
+ * @internal
+ */
+export const verdictLineOf = (outcome) => {
+    if (outcome.caughtByStaticAnalysis) {
+        return (`${outcome.what}: static analysis refused it before a single test ` +
+            `ran, and ${outcome.testsRed} test(s) went red after that.`);
+    }
+    if (outcome.testsRed === 0) {
+        return (`${outcome.what}: FINDING — nothing went red. Static analysis let it ` +
+            'through and every test still passed, so nothing was holding this ' +
+            'chain.');
+    }
+    return (`${outcome.what}: static analysis let it through, and ${outcome.testsRed} ` +
+        'test(s) went red.');
+};
+const FAILED_TESTS = /Tests\s+(\d+)\s+failed/;
+/**
+ * How many tests a test-runner output says went red. Zero when the
+ * output never says.
+ *
+ * @internal
+ */
+export const redTestCountIn = (output) => Number(FAILED_TESTS.exec(output)?.[1] ?? 0);

package/dist/testing/dna-perturbator.d.ts

@@ -0,0 +1,48 @@
+import { type MutationReport } from './dna-perturbator/attention.js';
+/**
+ * What one command did.
+ *
+ * @internal
+ */
+export interface CommandRun {
+    readonly code: number;
+    readonly output: string;
+}
+/**
+ * Everything the perturbator touches outside itself, handed in so a test
+ * can drive the whole tool without starting a mutation run.
+ *
+ * @internal
+ */
+export interface PerturbatorTools {
+    readonly run: (command: string, args: readonly string[]) => CommandRun;
+    readonly print: (line: string) => void;
+    readonly readFile: (path: string) => string;
+    readonly writeFile: (path: string, text: string) => void;
+    readonly readReport: (path: string) => MutationReport | null;
+}
+/**
+ * The dna file of one implant.
+ *
+ * @internal
+ */
+export declare const dnaPathOf: (implant: string) => string;
+/**
+ * The mutation run this tool asks for: every mutant of one implant's dna
+ * file, reported as json. Stryker takes the file name of that report from
+ * its own configuration and never from the command line, so the tool asks
+ * for the reporter and then reads back the path the run itself names.
+ *
+ * @internal
+ */
+export declare const mutationCommandOf: (implant: string) => readonly string[];
+/**
+ * The whole tool. With one argument it runs mutation testing over that
+ * implant's dna file and prints the attention map. With a second one — a
+ * chain name or a line number — it removes that chain or comments that
+ * line, runs static analysis and then the implant's tests, prints one
+ * honest line, and puts the file back whatever happens.
+ *
+ * @internal
+ */
+export declare const runDnaPerturbator: (argv: readonly string[], tools: PerturbatorTools) => number;

package/dist/testing/dna-perturbator.js

@@ -0,0 +1,145 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { attentionLinesOf, attentionMapOf, } from './dna-perturbator/attention.js';
+import { chainRangesOf, withChainRemoved, withLineCommented, } from './dna-perturbator/chains.js';
+import { jsonReportPathIn } from './dna-perturbator/report.js';
+import { redTestCountIn, verdictLineOf } from './dna-perturbator/verdict.js';
+/**
+ * The dna file of one implant.
+ *
+ * @internal
+ */
+export const dnaPathOf = (implant) => `business/${implant}/domain/dna.ts`;
+/**
+ * The mutation run this tool asks for: every mutant of one implant's dna
+ * file, reported as json. Stryker takes the file name of that report from
+ * its own configuration and never from the command line, so the tool asks
+ * for the reporter and then reads back the path the run itself names.
+ *
+ * @internal
+ */
+export const mutationCommandOf = (implant) => [
+    'stryker',
+    'run',
+    '--mutate',
+    dnaPathOf(implant),
+    '--reporters',
+    'json',
+];
+const mutationRun = (implant, tools) => {
+    const dnaPath = dnaPathOf(implant);
+    const started = tools.run('bunx', [...mutationCommandOf(implant)]);
+    const reportPath = jsonReportPathIn(started.output);
+    if (reportPath === null) {
+        tools.print('dna:perturbator: the mutation run named no json report ' +
+            `(it exited ${started.code}), so there is nothing honest to say ` +
+            'about attention here. Switch the json reporter on in this ' +
+            "repository's stryker configuration and run it again.");
+        return 1;
+    }
+    const report = tools.readReport(reportPath);
+    if (report === null) {
+        tools.print(`dna:perturbator: the mutation run named ${reportPath} and nothing ` +
+            `readable is there (it exited ${started.code}), so there is ` +
+            'nothing honest to say about attention here.');
+        return 1;
+    }
+    const ranges = chainRangesOf(tools.readFile(dnaPath));
+    for (const line of attentionLinesOf(implant, attentionMapOf(report, dnaPath, ranges))) {
+        tools.print(line);
+    }
+    return 0;
+};
+const perturbedTextOf = (text, target) => {
+    const asLine = Number(target);
+    if (Number.isInteger(asLine) && asLine > 0) {
+        const commented = withLineCommented(text, asLine);
+        return commented === null
+            ? null
+            : { text: commented, what: `commenting out line ${asLine}` };
+    }
+    const removed = withChainRemoved(text, target);
+    return removed === null
+        ? null
+        : { text: removed, what: `removing the chain ${target}` };
+};
+const breakRun = (implant, target, tools) => {
+    const dnaPath = dnaPathOf(implant);
+    const before = tools.readFile(dnaPath);
+    const perturbed = perturbedTextOf(before, target);
+    if (perturbed === null) {
+        tools.print(`dna:perturbator: ${dnaPath} holds no chain or line named ${target}.`);
+        return 1;
+    }
+    try {
+        tools.writeFile(dnaPath, perturbed.text);
+        const typecheck = tools.run('bun', ['run', 'typecheck']);
+        const tests = tools.run('bunx', ['vitest', 'run', `business/${implant}`]);
+        const testsRed = redTestCountIn(tests.output);
+        if (testsRed === 0 && tests.code !== 0) {
+            tools.print(`${perturbed.what}: the test run itself never reported a count ` +
+                `(it exited ${tests.code}), so this run proves nothing. Read its ` +
+                'output before trusting either colour.');
+            return 1;
+        }
+        const line = verdictLineOf({
+            what: perturbed.what,
+            caughtByStaticAnalysis: typecheck.code !== 0,
+            testsRed,
+        });
+        tools.print(line);
+        return line.includes('FINDING') ? 1 : 0;
+    }
+    finally {
+        tools.writeFile(dnaPath, before);
+    }
+};
+/**
+ * The whole tool. With one argument it runs mutation testing over that
+ * implant's dna file and prints the attention map. With a second one — a
+ * chain name or a line number — it removes that chain or comments that
+ * line, runs static analysis and then the implant's tests, prints one
+ * honest line, and puts the file back whatever happens.
+ *
+ * @internal
+ */
+export const runDnaPerturbator = (argv, tools) => {
+    const implant = argv[0];
+    if (implant === undefined || implant === '') {
+        tools.print('dna:perturbator: name the implant. With one argument it measures ' +
+            'attention across every chain; with a second one — a chain name or ' +
+            'a line number — it breaks exactly that and tells you who noticed.');
+        return 1;
+    }
+    const target = argv[1];
+    return target === undefined || target === ''
+        ? mutationRun(implant, tools)
+        : breakRun(implant, target, tools);
+};
+const spawnTools = {
+    run: (command, args) => {
+        const finished = spawnSync(command, [...args], { encoding: 'utf8' });
+        return {
+            code: finished.status ?? 1,
+            output: `${finished.stdout ?? ''}${finished.stderr ?? ''}`,
+        };
+    },
+    print: (line) => {
+        console.log(line);
+    },
+    readFile: (path) => readFileSync(path, 'utf8'),
+    writeFile: (path, text) => {
+        writeFileSync(path, text);
+    },
+    readReport: (path) => {
+        try {
+            return JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    },
+};
+if (import.meta.main) {
+    process.exitCode = runDnaPerturbator(process.argv.slice(2), spawnTools);
+}

package/dist/testing/document-number-counter.d.ts

@@ -0,0 +1,29 @@
+import { DocumentNumberCounter, type DocumentNumberCounterShape } from '@satorio/machinery/ports';
+import { Effect, Layer, Ref } from 'effect';
+/**
+ * What an in-memory counter holds: how many documents each client has
+ * been sent in each reporting month, keyed by the two together. A
+ * scenario seeds this map to start a month part way through.
+ */
+export type DocumentCountsByClientAndMonth = ReadonlyMap<string, number>;
+/**
+ * An in-memory counter over a reference you keep, so a test can seed it and
+ * read it back.
+ *
+ * An in-memory counter over a `Ref` you keep, so a test can seed how far a
+ * month has already run and read back where it ended.
+ */
+export declare const makeInMemoryDocumentNumberCounterWith: (counts: Ref.Ref<DocumentCountsByClientAndMonth>) => DocumentNumberCounterShape;
+/**
+ * An in-memory counter over a `Ref` of its own, with every month at zero.
+ */
+export declare const makeInMemoryDocumentNumberCounter: Effect.Effect<DocumentNumberCounterShape, never, never>;
+/**
+ * The in-memory counter, mounted.
+ */
+export declare const InMemoryDocumentNumberCounterLive: Layer.Layer<DocumentNumberCounter, never, never>;
+/**
+ * A counter that counts nothing: every request comes back as a refusal.
+ * Mount it to walk the branch a working stand-in never reaches.
+ */
+export declare const DocumentNumberCounterUnavailableLive: Layer.Layer<DocumentNumberCounter>;

package/dist/testing/document-number-counter.js

@@ -0,0 +1,39 @@
+import { DocumentNumberCounter, DocumentNumberCounterUnavailableError, } from '@satorio/machinery/ports';
+import { Effect, Layer, Ref } from 'effect';
+const NOT_MOUNTED = 'document number counter unavailable (test)';
+const keyOf = (clientCode, reportingMonth) => `${clientCode}/${reportingMonth}`;
+/**
+ * An in-memory counter over a reference you keep, so a test can seed it and
+ * read it back.
+ *
+ * An in-memory counter over a `Ref` you keep, so a test can seed how far a
+ * month has already run and read back where it ended.
+ */
+export const makeInMemoryDocumentNumberCounterWith = (counts) => ({
+    nextCount: (input) => Ref.modify(counts, (current) => {
+        const key = keyOf(input.clientCode, input.reportingMonth);
+        const next = (current.get(key) ?? 0) + 1;
+        return [next, new Map(current).set(key, next)];
+    }),
+});
+/**
+ * An in-memory counter over a `Ref` of its own, with every month at zero.
+ */
+export const makeInMemoryDocumentNumberCounter = Effect.gen(function* () {
+    const counts = yield* Ref.make(new Map());
+    return makeInMemoryDocumentNumberCounterWith(counts);
+});
+/**
+ * The in-memory counter, mounted.
+ */
+export const InMemoryDocumentNumberCounterLive = Layer.effect(DocumentNumberCounter, makeInMemoryDocumentNumberCounter);
+/**
+ * A counter that counts nothing: every request comes back as a refusal.
+ * Mount it to walk the branch a working stand-in never reaches.
+ */
+export const DocumentNumberCounterUnavailableLive = Layer.succeed(DocumentNumberCounter, {
+    nextCount: () => new DocumentNumberCounterUnavailableError({
+        operation: 'nextCount',
+        cause: NOT_MOUNTED,
+    }),
+});