@satorio/machinery 0.2.1

package/dist/time/calendar-day.js

@@ -0,0 +1,112 @@
+import { refusalText } from '@satorio/machinery/core';
+import { DateTime, Either, Order, ParseResult, Schema } from 'effect';
+import { NotACalendarDayError } from './failures.js';
+const HUMAN_FORM = /^(\d{2})\.(\d{2})\.(\d{4})$/;
+const ISO_FORM = /^(\d{4})-(\d{2})-(\d{2})$/;
+const MILLISECONDS_IN_A_DAY = 86_400_000;
+const FIRST_MONTH = 1;
+const LAST_MONTH = 12;
+const padded = (value, width) => String(value).padStart(width, '0');
+const isoTextOf = (year, month, day) => `${padded(year, 4)}-${padded(month, 2)}-${padded(day, 2)}`;
+const momentOf = (day) => DateTime.unsafeMake(`${day}T00:00:00.000Z`);
+const dayOfMomentUtc = (moment) => {
+    const parts = DateTime.toPartsUtc(moment);
+    return dayOfDateParts(parts.year, parts.month, parts.day);
+};
+/**
+ * The day named by parts a real moment already produced. This is the one
+ * place a calendar day is built, so a value of that type never comes
+ * from anywhere else.
+ *
+ * @internal
+ */
+export const dayOfDateParts = (year, month, day) => isoTextOf(year, month, day);
+const refuse = (text, reason) => Either.left(new NotACalendarDayError({ text, reason }));
+const dayFromNumbers = (text, year, month, day) => {
+    if (month < FIRST_MONTH || month > LAST_MONTH) {
+        return refuse(text, 'month out of range');
+    }
+    const built = DateTime.unsafeMake({ year, month, day });
+    const parts = DateTime.toPartsUtc(built);
+    const same = parts.year === year && parts.month === month && parts.day === day;
+    return same
+        ? Either.right(dayOfMomentUtc(built))
+        : refuse(text, 'day out of range for that month');
+};
+const dayFromMatch = (text, matched, order) => {
+    if (matched === null)
+        return refuse(text, 'not the calendar-day form');
+    const [yearAt, monthAt, dayAt] = order;
+    return dayFromNumbers(text, Number(matched[yearAt]), Number(matched[monthAt]), Number(matched[dayAt]));
+};
+/**
+ * Reads the form a person writes a day in: `19.03.2026`. A text of any
+ * other shape, a month outside the twelve, or a day the month does not
+ * have all come back as a refusal that names which rule was broken.
+ */
+export const calendarDayFromHumanForm = (text) => dayFromMatch(text, HUMAN_FORM.exec(text), [3, 2, 1]);
+/**
+ * Reads the form a machine writes a day in: `2026-03-19`. It refuses
+ * exactly what the human reader refuses, for exactly the same reasons.
+ */
+export const calendarDayFromIsoForm = (text) => dayFromMatch(text, ISO_FORM.exec(text), [1, 2, 3]);
+/**
+ * Writes a day the way a person reads it: `19.03.2026`.
+ */
+export const dayInHumanForm = (day) => `${day.slice(8, 10)}.${day.slice(5, 7)}.${day.slice(0, 4)}`;
+/**
+ * Writes a day the way a machine reads it: `2026-03-19`. This is the
+ * one seam between a day and its text, so a change of how a day is held
+ * inside touches this function and nothing a consumer wrote.
+ */
+export const dayInIsoForm = (day) => day;
+/**
+ * Puts two days in calendar order, earliest first.
+ */
+export const CalendarDayOrder = Order.string;
+/**
+ * Counts whole days from the first day to the second. The count runs
+ * negative when the second day stands earlier.
+ */
+export const daysBetween = (earlier, later) => DateTime.distance(momentOf(earlier), momentOf(later)) / MILLISECONDS_IN_A_DAY;
+/**
+ * Moves a day by whole days. A negative count moves it back.
+ */
+export const addDays = (day, days) => dayOfMomentUtc(DateTime.add(momentOf(day), { days }));
+/**
+ * Moves a day by whole months, landing on the last day of a month too short to
+ * hold it.
+ *
+ * Moves a day by whole months, and lands on the last day of the month it
+ * arrives in when that month is too short to hold the same number.
+ */
+export const addMonths = (day, months) => dayOfMomentUtc(DateTime.add(momentOf(day), { months }));
+/**
+ * The last day of the month the given day falls in. Ask the calendar
+ * rather than a table of month lengths: February in a leap year answers
+ * correctly here because the runtime's own calendar answers correctly.
+ */
+export const lastDayOfTheMonthOf = (day) => dayOfMomentUtc(DateTime.endOf(momentOf(day), 'month'));
+/**
+ * The first day of the month the given day falls in. Every month starts
+ * on its first, so this one needs no calendar; it stays here beside its
+ * twin, and `monthOf` is the name a consumer reaches for.
+ *
+ * @internal
+ */
+export const firstDayOfTheMonthOf = (day) => dayOfMomentUtc(DateTime.startOf(momentOf(day), 'month'));
+const isCalendarDay = (value) => typeof value === 'string' && Either.isRight(calendarDayFromIsoForm(value));
+const CalendarDayValue = Schema.declare(isCalendarDay, {
+    identifier: 'CalendarDay',
+});
+/**
+ * Reads a day off the wire from the form a person writes, and writes it
+ * back in that same form. A text this schema refuses carries the whole
+ * three-part refusal into the parse error, so the reader of a failed
+ * command sees what to do next rather than a bare type name.
+ */
+export const CalendarDayFromHumanString = Schema.transformOrFail(Schema.String, CalendarDayValue, {
+    strict: true,
+    decode: (text, _options, ast) => Either.mapLeft(calendarDayFromHumanForm(text), (failure) => new ParseResult.Type(ast, text, refusalText(failure.refusal))),
+    encode: (day) => ParseResult.succeed(dayInHumanForm(day)),
+});

package/dist/time/failures.d.ts

@@ -0,0 +1,51 @@
+import type { Refusal } from '@satorio/machinery/core';
+/**
+ * Why a written day is not a calendar day. The reason is a code a caller
+ * matches on; the failure's own `refusal` is the sentence a person
+ * reads. Both come from the same failure, so the two never drift.
+ */
+export type CalendarDayRefusalReason = 'not the calendar-day form' | 'month out of range' | 'day out of range for that month';
+declare const NotACalendarDayError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NotACalendarDayError";
+} & Readonly<A>;
+/**
+ * The text a reader was handed does not name a day any calendar holds.
+ * `reason` names which rule it broke, and `refusal` says the same thing
+ * in the three parts a person needs.
+ */
+export declare class NotACalendarDayError extends NotACalendarDayError_base<{
+    readonly text: string;
+    readonly reason: CalendarDayRefusalReason;
+}> {
+    get refusal(): Refusal;
+}
+declare const UnknownTimeZoneError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UnknownTimeZoneError";
+} & Readonly<A>;
+/**
+ * The runtime has no zone under that name. Every zone this mechanism
+ * takes is an IANA name, and the runtime's own zone table answers.
+ */
+export declare class UnknownTimeZoneError extends UnknownTimeZoneError_base<{
+    readonly zoneId: string;
+}> {
+    get refusal(): Refusal;
+}
+declare const PeriodEndsBeforeItStartsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PeriodEndsBeforeItStartsError";
+} & Readonly<A>;
+/**
+ * The two days handed in run backwards. Both fields carry the days as a
+ * person writes them, so the refusal quotes what the reader typed.
+ */
+export declare class PeriodEndsBeforeItStartsError extends PeriodEndsBeforeItStartsError_base<{
+    readonly from: string;
+    readonly to: string;
+}> {
+    get refusal(): Refusal;
+}
+/**
+ * Every way this mechanism refuses a value.
+ */
+export type TimeFailure = NotACalendarDayError | UnknownTimeZoneError | PeriodEndsBeforeItStartsError;
+export {};

package/dist/time/failures.js

@@ -0,0 +1,56 @@
+import { Data } from 'effect';
+const dayRefusals = {
+    'not the calendar-day form': (text) => ({
+        what: `${JSON.stringify(text)} is not written as a calendar day.`,
+        why: 'This mechanism reads a day written as dd.mm.yyyy or as ' +
+            'yyyy-mm-dd, and reads nothing else.',
+        whatToDo: 'Write the day as 19.03.2026 or as 2026-03-19, then hand it back.',
+    }),
+    'month out of range': (text) => ({
+        what: `${JSON.stringify(text)} names a month outside the twelve a year has.`,
+        why: 'No calendar holds that day, so this mechanism cannot place it.',
+        whatToDo: 'Correct the month to a number from 1 to 12, then hand the day back.',
+    }),
+    'day out of range for that month': (text) => ({
+        what: `${JSON.stringify(text)} names a day that month does not have.`,
+        why: 'The month it names is shorter than that, so the day never came.',
+        whatToDo: "Check that month's own length, correct the day, then hand it back.",
+    }),
+};
+/**
+ * The text a reader was handed does not name a day any calendar holds.
+ * `reason` names which rule it broke, and `refusal` says the same thing
+ * in the three parts a person needs.
+ */
+export class NotACalendarDayError extends Data.TaggedError('NotACalendarDayError') {
+    get refusal() {
+        return dayRefusals[this.reason](this.text);
+    }
+}
+/**
+ * The runtime has no zone under that name. Every zone this mechanism
+ * takes is an IANA name, and the runtime's own zone table answers.
+ */
+export class UnknownTimeZoneError extends Data.TaggedError('UnknownTimeZoneError') {
+    get refusal() {
+        return {
+            what: `${JSON.stringify(this.zoneId)} is not a time zone this runtime knows.`,
+            why: 'Without a zone this mechanism cannot say which calendar day an ' +
+                'instant falls on.',
+            whatToDo: 'Name an IANA zone such as Europe/Kyiv, then hand it back.',
+        };
+    }
+}
+/**
+ * The two days handed in run backwards. Both fields carry the days as a
+ * person writes them, so the refusal quotes what the reader typed.
+ */
+export class PeriodEndsBeforeItStartsError extends Data.TaggedError('PeriodEndsBeforeItStartsError') {
+    get refusal() {
+        return {
+            what: `This period runs from ${this.from} to ${this.to}.`,
+            why: 'Its end stands before its start, so no day belongs to it.',
+            whatToDo: 'Swap the two days, or correct the one that is wrong.',
+        };
+    }
+}

package/dist/time/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Public entry to the time mechanism: a day a person reads and writes, a
+ * period of days, and a moment on the clock. It gives you a calendar day a
+ * person can read and write, a period of such days with both bounds named, a
+ * moment on the world's clock, and the named zone that decides which day a
+ * moment belongs to.
+ */
+export { addDays, addMonths, type CalendarDay, CalendarDayFromHumanString, CalendarDayOrder, calendarDayFromHumanForm, calendarDayFromIsoForm, dayInHumanForm, dayInIsoForm, daysBetween, lastDayOfTheMonthOf, } from './calendar-day.js';
+export { type CalendarDayRefusalReason, NotACalendarDayError, PeriodEndsBeforeItStartsError, type TimeFailure, UnknownTimeZoneError, } from './failures.js';
+export { dateTimeOfInstant, dayOfInstant, type Instant, instantInHumanForm, instantOfDateTime, startOfDay, type TimeZone, todayIn, zoneIdOf, zoneNamed, } from './instant.js';
+export { lengthInDays, monthOf, monthsOf, type Period, periodContains, periodOf, periodsOverlap, } from './period.js';

package/dist/time/index.js

@@ -0,0 +1,11 @@
+/**
+ * Public entry to the time mechanism: a day a person reads and writes, a
+ * period of days, and a moment on the clock. It gives you a calendar day a
+ * person can read and write, a period of such days with both bounds named, a
+ * moment on the world's clock, and the named zone that decides which day a
+ * moment belongs to.
+ */
+export { addDays, addMonths, CalendarDayFromHumanString, CalendarDayOrder, calendarDayFromHumanForm, calendarDayFromIsoForm, dayInHumanForm, dayInIsoForm, daysBetween, lastDayOfTheMonthOf, } from './calendar-day.js';
+export { NotACalendarDayError, PeriodEndsBeforeItStartsError, UnknownTimeZoneError, } from './failures.js';
+export { dateTimeOfInstant, dayOfInstant, instantInHumanForm, instantOfDateTime, startOfDay, todayIn, zoneIdOf, zoneNamed, } from './instant.js';
+export { lengthInDays, monthOf, monthsOf, periodContains, periodOf, periodsOverlap, } from './period.js';

package/dist/time/instant.d.ts

@@ -0,0 +1,64 @@
+import { DateTime, Effect, Either } from 'effect';
+import { type CalendarDay } from './calendar-day.js';
+import { UnknownTimeZoneError } from './failures.js';
+declare const timeZoneBrand: unique symbol;
+/**
+ * One named time zone, as the runtime's own zone table knows it. The
+ * value carries a brand, so a name nobody checked never passes for a
+ * zone.
+ */
+export type TimeZone = string & {
+    readonly [timeZoneBrand]: 'TimeZone';
+};
+/**
+ * One moment on the world's clock, held as whole milliseconds since the
+ * start of 1970. A moment has no zone: a zone only decides which
+ * calendar day, and which wall time, a person in that place reads off it.
+ */
+export interface Instant {
+    readonly epochMilliseconds: number;
+}
+/**
+ * Takes an IANA zone name, and refuses a name the runtime does not know.
+ */
+export declare const zoneNamed: (zoneId: string) => Either.Either<TimeZone, UnknownTimeZoneError>;
+/**
+ * Reads the IANA name back out of a zone, for a log line or a row.
+ */
+export declare const zoneIdOf: (zone: TimeZone) => string;
+/**
+ * Takes a moment the machinery already holds as Effect's own UTC value.
+ * The queue envelope's `occurredAt` arrives that way, and this is where
+ * it becomes an instant.
+ */
+export declare const instantOfDateTime: (moment: DateTime.Utc) => Instant;
+/**
+ * Hands a moment back as Effect's own UTC value, for a row, an envelope,
+ * or any code that already speaks that type.
+ */
+export declare const dateTimeOfInstant: (instant: Instant) => DateTime.Utc;
+/**
+ * The calendar day a moment falls on for a person standing in that zone.
+ * The same moment is a different day in two different places, and this
+ * is the function that says which.
+ */
+export declare const dayOfInstant: (instant: Instant, zone: TimeZone) => CalendarDay;
+/**
+ * The moment a calendar day begins in that zone. On the night a country
+ * moves its clocks, that moment is not the same distance from midnight
+ * in Greenwich as it was the day before.
+ */
+export declare const startOfDay: (day: CalendarDay, zone: TimeZone) => Instant;
+/**
+ * Writes a moment the way a person in that zone reads it:
+ * `19.03.2026 14:05 +02:00`. The offset stands in the text on purpose,
+ * so the same line never means two things in two halves of a year.
+ */
+export declare const instantInHumanForm: (instant: Instant, zone: TimeZone) => string;
+/**
+ * Today, as the calendar of that zone counts it, read from the clock the
+ * service already shares. A service that asked for today in Greenwich
+ * instead would close a customer's last day of the month two hours early.
+ */
+export declare const todayIn: (zone: TimeZone) => Effect.Effect<CalendarDay>;
+export {};

package/dist/time/instant.js

@@ -0,0 +1,67 @@
+import { DateTime, Effect, Either, Option } from 'effect';
+import { dayInHumanForm, dayOfDateParts, } from './calendar-day.js';
+import { UnknownTimeZoneError } from './failures.js';
+const isKnownZone = (zoneId) => Option.isSome(DateTime.zoneMakeNamed(zoneId));
+const zoneOf = (zone) => DateTime.zoneUnsafeMakeNamed(zone);
+const zonedAt = (instant, zone) => DateTime.setZone(dateTimeOfInstant(instant), zoneOf(zone));
+/**
+ * Takes an IANA zone name, and refuses a name the runtime does not know.
+ */
+export const zoneNamed = (zoneId) => isKnownZone(zoneId)
+    ? Either.right(zoneId)
+    : Either.left(new UnknownTimeZoneError({ zoneId }));
+/**
+ * Reads the IANA name back out of a zone, for a log line or a row.
+ */
+export const zoneIdOf = (zone) => zone;
+/**
+ * Takes a moment the machinery already holds as Effect's own UTC value.
+ * The queue envelope's `occurredAt` arrives that way, and this is where
+ * it becomes an instant.
+ */
+export const instantOfDateTime = (moment) => ({
+    epochMilliseconds: DateTime.toEpochMillis(moment),
+});
+/**
+ * Hands a moment back as Effect's own UTC value, for a row, an envelope,
+ * or any code that already speaks that type.
+ */
+export const dateTimeOfInstant = (instant) => DateTime.unsafeMake(instant.epochMilliseconds);
+/**
+ * The calendar day a moment falls on for a person standing in that zone.
+ * The same moment is a different day in two different places, and this
+ * is the function that says which.
+ */
+export const dayOfInstant = (instant, zone) => {
+    const parts = DateTime.toParts(zonedAt(instant, zone));
+    return dayOfDateParts(parts.year, parts.month, parts.day);
+};
+/**
+ * The moment a calendar day begins in that zone. On the night a country
+ * moves its clocks, that moment is not the same distance from midnight
+ * in Greenwich as it was the day before.
+ */
+export const startOfDay = (day, zone) => instantOfDateTime(DateTime.toUtc(DateTime.unsafeMakeZoned(`${day}T00:00:00.000`, {
+    timeZone: zoneOf(zone),
+    adjustForTimeZone: true,
+})));
+/**
+ * Writes a moment the way a person in that zone reads it:
+ * `19.03.2026 14:05 +02:00`. The offset stands in the text on purpose,
+ * so the same line never means two things in two halves of a year.
+ */
+export const instantInHumanForm = (instant, zone) => {
+    const zoned = zonedAt(instant, zone);
+    const parts = DateTime.toParts(zoned);
+    const day = dayInHumanForm(dayOfInstant(instant, zone));
+    const hours = String(parts.hours).padStart(2, '0');
+    const minutes = String(parts.minutes).padStart(2, '0');
+    const clock = `${hours}:${minutes}`;
+    return `${day} ${clock} ${DateTime.zonedOffsetIso(zoned)}`;
+};
+/**
+ * Today, as the calendar of that zone counts it, read from the clock the
+ * service already shares. A service that asked for today in Greenwich
+ * instead would close a customer's last day of the month two hours early.
+ */
+export const todayIn = (zone) => DateTime.now.pipe(Effect.map((moment) => dayOfInstant(instantOfDateTime(moment), zone)));

package/dist/time/period.d.ts

@@ -0,0 +1,45 @@
+import { Either } from 'effect';
+import { type CalendarDay } from './calendar-day.js';
+import { PeriodEndsBeforeItStartsError } from './failures.js';
+/**
+ * A run of calendar days. Both bounds belong to the period: the day in
+ * `from` and the day in `to` are inside it, and a period whose two days
+ * are the same is one day long. The rule is stated once, here, and every
+ * function below holds to it.
+ */
+export interface Period {
+    readonly from: CalendarDay;
+    readonly to: CalendarDay;
+}
+/**
+ * Takes two days as a period, earliest first. A pair that runs backwards
+ * comes back as a refusal naming both days as a person wrote them.
+ */
+export declare const periodOf: (from: CalendarDay, to: CalendarDay) => Either.Either<Period, PeriodEndsBeforeItStartsError>;
+/**
+ * The whole calendar month the given day falls in, as a period. A close
+ * that runs over one month takes any day of it and gets the same two
+ * bounds, so nobody adds a month and subtracts a day to find the last of
+ * February.
+ */
+export declare const monthOf: (day: CalendarDay) => Period;
+/**
+ * Answers whether the day belongs to the period. Either bound counts as
+ * inside.
+ */
+export declare const periodContains: (period: Period, day: CalendarDay) => boolean;
+/**
+ * Answers whether two periods share at least one day.
+ */
+export declare const periodsOverlap: (left: Period, right: Period) => boolean;
+/**
+ * Counts the days a period holds, both bounds included.
+ */
+export declare const lengthInDays: (period: Period) => number;
+/**
+ * Cuts a period into one part per calendar month it runs over, in
+ * order. The first part starts on the period's own first day and the
+ * last part ends on its own last day, so the parts cover the period
+ * exactly once and never reach past it.
+ */
+export declare const monthsOf: (period: Period) => readonly Period[];

package/dist/time/period.js

@@ -0,0 +1,55 @@
+import { Either } from 'effect';
+import { addDays, CalendarDayOrder, dayInHumanForm, daysBetween, firstDayOfTheMonthOf, lastDayOfTheMonthOf, } from './calendar-day.js';
+import { PeriodEndsBeforeItStartsError } from './failures.js';
+/**
+ * Takes two days as a period, earliest first. A pair that runs backwards
+ * comes back as a refusal naming both days as a person wrote them.
+ */
+export const periodOf = (from, to) => CalendarDayOrder(from, to) > 0
+    ? Either.left(new PeriodEndsBeforeItStartsError({
+        from: dayInHumanForm(from),
+        to: dayInHumanForm(to),
+    }))
+    : Either.right({ from, to });
+/**
+ * The whole calendar month the given day falls in, as a period. A close
+ * that runs over one month takes any day of it and gets the same two
+ * bounds, so nobody adds a month and subtracts a day to find the last of
+ * February.
+ */
+export const monthOf = (day) => ({
+    from: firstDayOfTheMonthOf(day),
+    to: lastDayOfTheMonthOf(day),
+});
+/**
+ * Answers whether the day belongs to the period. Either bound counts as
+ * inside.
+ */
+export const periodContains = (period, day) => CalendarDayOrder(period.from, day) <= 0 &&
+    CalendarDayOrder(day, period.to) <= 0;
+/**
+ * Answers whether two periods share at least one day.
+ */
+export const periodsOverlap = (left, right) => CalendarDayOrder(left.from, right.to) <= 0 &&
+    CalendarDayOrder(right.from, left.to) <= 0;
+/**
+ * Counts the days a period holds, both bounds included.
+ */
+export const lengthInDays = (period) => daysBetween(period.from, period.to) + 1;
+/**
+ * Cuts a period into one part per calendar month it runs over, in
+ * order. The first part starts on the period's own first day and the
+ * last part ends on its own last day, so the parts cover the period
+ * exactly once and never reach past it.
+ */
+export const monthsOf = (period) => {
+    const parts = [];
+    let start = period.from;
+    while (CalendarDayOrder(start, period.to) <= 0) {
+        const monthEnd = lastDayOfTheMonthOf(start);
+        const end = CalendarDayOrder(monthEnd, period.to) <= 0 ? monthEnd : period.to;
+        parts.push({ from: start, to: end });
+        start = addDays(end, 1);
+    }
+    return parts;
+};

package/dist/vitest/container-reuse.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Whether a live stand may outlive the run that started it. A developer
+ * machine sets `TESTCONTAINERS_REUSE_ENABLE=true` once and every later
+ * run finds the database and the AWS stand already up, which takes the
+ * container start out of the full check. A pipeline leaves it unset, so
+ * every run gets a stand nobody has touched.
+ *
+ * What no test here proves: that a second run really reaches the first
+ * run's container. Only two runs on one machine prove that, and the page
+ * on the live stands says how to watch it happen.
+ *
+ * @internal
+ */
+export declare const standsMayBeReused: (environment?: Readonly<Record<string, string | undefined>>) => boolean;

package/dist/vitest/container-reuse.js

@@ -0,0 +1,15 @@
+const OFF = new Set(['', '0', 'false', 'no']);
+/**
+ * Whether a live stand may outlive the run that started it. A developer
+ * machine sets `TESTCONTAINERS_REUSE_ENABLE=true` once and every later
+ * run finds the database and the AWS stand already up, which takes the
+ * container start out of the full check. A pipeline leaves it unset, so
+ * every run gets a stand nobody has touched.
+ *
+ * What no test here proves: that a second run really reaches the first
+ * run's container. Only two runs on one machine prove that, and the page
+ * on the live stands says how to watch it happen.
+ *
+ * @internal
+ */
+export const standsMayBeReused = (environment = process.env) => !OFF.has((environment.TESTCONTAINERS_REUSE_ENABLE ?? '').toLowerCase());

package/dist/vitest/dotenv.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Parses `.env` file contents into key-value pairs, one `KEY=value` per
+ * line. Skips blank lines and lines starting with `#`. Values keep any
+ * surrounding quotes as-is.
+ *
+ * @internal
+ */
+export declare const parseDotenv: (contents: string) => ReadonlyMap<string, string>;
+/**
+ * Loads a `.env` file into `process.env`, without overwriting a value the
+ * real environment already set. Call it from `vitest.config.ts`, before
+ * vitest forks its worker pool, so every worker inherits the same values.
+ *
+ * @internal
+ */
+export declare const loadDotenvIntoProcessEnv: (path: string) => void;

package/dist/vitest/dotenv.js

@@ -0,0 +1,48 @@
+import { readFileSync } from 'node:fs';
+/**
+ * Parses `.env` file contents into key-value pairs, one `KEY=value` per
+ * line. Skips blank lines and lines starting with `#`. Values keep any
+ * surrounding quotes as-is.
+ *
+ * @internal
+ */
+export const parseDotenv = (contents) => {
+    const variables = new Map();
+    for (const line of contents.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '' || trimmed.startsWith('#'))
+            continue;
+        const separatorIndex = trimmed.indexOf('=');
+        if (separatorIndex === -1)
+            continue;
+        const key = trimmed.slice(0, separatorIndex).trim();
+        const value = trimmed.slice(separatorIndex + 1).trim();
+        if (key === '')
+            continue;
+        variables.set(key, value);
+    }
+    return variables;
+};
+/**
+ * Loads a `.env` file into `process.env`, without overwriting a value the
+ * real environment already set. Call it from `vitest.config.ts`, before
+ * vitest forks its worker pool, so every worker inherits the same values.
+ *
+ * @internal
+ */
+export const loadDotenvIntoProcessEnv = (path) => {
+    let contents;
+    try {
+        contents = readFileSync(path, 'utf8');
+    }
+    catch {
+        return;
+    }
+    for (const [key, value] of parseDotenv(contents)) {
+        // @effect-diagnostics effect/processEnv:off
+        if (process.env[key] === undefined) {
+            process.env[key] = value;
+        }
+        // @effect-diagnostics effect/processEnv:error
+    }
+};

package/dist/vitest/effect-single-instance.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @internal
+ */
+export interface EffectCopy {
+    readonly packageDirectory: string;
+}
+/**
+ * @internal
+ */
+export declare const walkForEffectCopies: (nodeModulesDirectory: string, visited: Set<string>, found: EffectCopy[]) => void;
+/**
+ * Options for `oneEffectInstanceGuard`. `root` defaults to `repoRoot()`, the
+ * caller's own repository root — the same default every other guard in
+ * this mechanism uses.
+ *
+ * @internal
+ */
+export interface SingleEffectInstanceOptions {
+    readonly root?: string;
+}
+/**
+ * Registers a vitest suite that fails when a tree holds more than one copy of
+ * Effect.
+ *
+ * Registers a vitest suite that fails if more than one physical copy of the
+ * `effect` package is reachable from a consumer's `node_modules` tree, or if
+ * `require.resolve('effect')` disagrees between the consumer root and this
+ * package's own installed directory. Call it from a consumer's `*.test.ts`
+ * file — effect is a peer dependency precisely so the consumer keeps a single
+ * instance, and this is the guard that makes that invariant loud instead of
+ * silent (see `dec-20260902-8898ccfd`). It walks `node_modules` rather than
+ * the repository, so it takes no floor option; instead it refuses on zero
+ * copies found and on a resolution that answers nothing, because a comparison
+ * over an empty walk passes every time.
+ */
+export declare const oneEffectInstanceGuard: (options?: SingleEffectInstanceOptions) => void;