@venn-lang/contracts 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,620 @@
+import { A as DirEntry, C as Random, D as SpawnArgs, E as ProcessResult, M as Clock, N as VirtualClock, O as LockProvider, S as SecretProvider, T as ProcessProvider, _ as KnownSecret, a as Unsubscribe, c as ManifestProvider, d as PackageInfo, f as PackageManagerName, g as WorkspaceSettings, h as ToolingSettings, i as SystemSignal, j as FileSystem, k as Release, l as BuildTarget, m as TargetKind, n as SignalHandler, o as FormatSettings, p as Profile, r as SignalSource, s as Manifest, t as ALL_SIGNALS, u as Dependency, w as ProcessHandle, x as Secret } from "./signal-source.types-BI3TYaCi.js";
+//#region src/capabilities/host-capability.d.ts
+/**
+ * Every capability a Host may expose. A port or plugin declares which it
+ * requires, a host advertises which it provides, and negotiation compares the
+ * two before anything binds.
+ */
+declare const ALL_CAPABILITIES: readonly ["fs", "process", "net", "clock", "random", "secrets", "log", "io"];
+/** One capability name, drawn from {@link ALL_CAPABILITIES}. */
+type HostCapability = (typeof ALL_CAPABILITIES)[number];
+//#endregion
+//#region src/dotenv/dotenv-files.d.ts
+/**
+ * The dotenv files read when `venn.toml` does not name its own.
+ *
+ * The order is the precedence, lowest first: what everyone shares, then what
+ * this environment adds, then what this machine keeps to itself. The `.local`
+ * ones are what a `.gitignore` is for.
+ */
+declare const DOTENV_CONVENTION: readonly string[];
+/**
+ * Which files to read, in order, for one environment.
+ *
+ * The runner and the editor both ask this, so they cannot disagree about where
+ * a value lives.
+ *
+ * @param args.configured - `[env] files` from `venn.toml`. Empty or absent
+ * falls back to {@link DOTENV_CONVENTION}.
+ * @param args.name - the selected environment, substituted for `${name}`.
+ */
+declare function dotenvFiles(args: {
+  configured?: readonly string[];
+  name: string;
+}): string[];
+//#endregion
+//#region src/dotenv/parse-dotenv.d.ts
+/**
+ * Read a `.env` file: `NAME=value`, one per line.
+ *
+ * Deliberately small. It understands comments, blank lines, an `export `
+ * prefix, and quotes around a value that needs them. No variable expansion:
+ * `${OTHER}` is left alone, because Venn already interpolates in its own
+ * strings and two syntaxes for one idea is how people get surprised.
+ *
+ * @returns every name found, later lines winning over earlier ones.
+ */
+declare function parseDotenv(content: string): Record<string, string>;
+//#endregion
+//#region src/errors/venn-error.d.ts
+/** Structured, serializable, redaction-safe detail attached to a {@link VennError}. */
+type VennErrorDetail = Readonly<Record<string, unknown>>;
+/**
+ * The single error type that crosses a contracts boundary.
+ *
+ * Every failure carries a stable `VNxxxx` code, so conformance suites assert on
+ * `.code` and never on prose. Messages stay free to improve.
+ */
+declare class VennError extends Error {
+  readonly code: string;
+  readonly detail: VennErrorDetail | undefined;
+  constructor(args: {
+    code: string;
+    message: string;
+    detail?: VennErrorDetail;
+  });
+}
+//#endregion
+//#region src/errors/contract-codes.d.ts
+/** VN2010: a port requires capabilities the host does not provide. */
+declare function hostMissingCapability(args: {
+  portId: string;
+  missing: readonly HostCapability[];
+  present: readonly HostCapability[];
+}): VennError;
+/** VN2011: an implementation is missing one or more methods the port declares. */
+declare function portShapeMismatch(args: {
+  portId: string;
+  missing: readonly string[];
+}): VennError;
+/** VN2012: code reached a capability the host declared unavailable. */
+declare function capabilityUnavailable(args: {
+  capability: HostCapability;
+  method: string;
+}): VennError;
+//#endregion
+//#region src/logger/logger.types.d.ts
+/** How loudly one entry asks to be heard. */
+type LogLevel = "debug" | "info" | "warn" | "error";
+/** One line of log, as data rather than as formatted text. */
+interface LogEntry {
+  readonly level: LogLevel;
+  readonly message: string;
+}
+/** The minimal structured logger a host exposes. */
+interface Logger {
+  log(entry: LogEntry): void;
+}
+/** A {@link Logger} that also retains what it was given, for assertions. */
+interface MemoryLogger extends Logger {
+  readonly entries: readonly LogEntry[];
+}
+//#endregion
+//#region src/logger/console-logger.d.ts
+/** Logger backed by the global console, so it works in a Worker and in Node. */
+declare function createConsoleLogger(): Logger;
+//#endregion
+//#region src/logger/memory-logger.d.ts
+/** The double: keeps every entry in `entries` instead of printing it. */
+declare function createMemoryLogger(): MemoryLogger;
+//#endregion
+//#region src/port/port.types.d.ts
+/**
+ * A typed contract carrying at least two implementations, one real and one
+ * double.
+ *
+ * Deliberately not a Zod schema: in Zod 4 `z.function` is a factory rather than
+ * a validatable type, so a port's function shape cannot be expressed as data.
+ * `methods` buys a compile-time check (each entry must be a key of `T`) and a
+ * load-time one (`typeof` per method); the behavioural guarantee is the
+ * conformance suite.
+ *
+ * @typeParam T - the interface the implementation must satisfy.
+ */
+interface Port<T> {
+  /** Stable identity, e.g. "venn.port.filesystem". */
+  readonly id: string;
+  /** Version of the contract, not of the package. Removing a method bumps it. */
+  readonly version: number;
+  /** Capabilities negotiated against `Host.caps` before binding. */
+  readonly requires: readonly HostCapability[];
+  /** Methods an implementation must provide. Each must be a key of `T`. */
+  readonly methods: readonly (keyof T & string)[];
+}
+/**
+ * A `Port<T>` with its element type erased. Every `Port<T>` is assignable to it
+ * (its `methods` widen to `string[]`), so a heterogeneous collection of ports,
+ * such as the runtime's binding table, types without variance friction.
+ */
+type AnyPort = {
+  readonly id: string;
+  readonly version: number;
+  readonly requires: readonly HostCapability[];
+  readonly methods: readonly string[];
+};
+//#endregion
+//#region src/port/assert-capabilities.d.ts
+/**
+ * Checks the host against what the port requires.
+ *
+ * @throws VennError VN2010 when a required capability is absent.
+ */
+declare function assertCapabilities<T>(args: {
+  port: Port<T>;
+  caps: readonly HostCapability[];
+}): void;
+//#endregion
+//#region src/port/assert-port-shape.d.ts
+/**
+ * Checks the implementation against the methods the port declares.
+ *
+ * @throws VennError VN2011 when a declared method is missing or is not callable.
+ */
+declare function assertPortShape<T>(args: {
+  port: Port<T>;
+  impl: unknown;
+}): void;
+//#endregion
+//#region src/port/bind-port.d.ts
+/**
+ * The single loader entry. Negotiates capabilities, checks the implementation's
+ * shape, then hands it back typed as `T`.
+ *
+ * Both checks run before anything is bound, so a mismatch is reported at start
+ * up rather than as a `TypeError` in the middle of a test.
+ *
+ * @param args.port - the descriptor to bind against.
+ * @param args.impl - the candidate implementation, untrusted.
+ * @param args.caps - the capabilities the host advertises.
+ * @returns `args.impl` typed as `T`.
+ * @throws VennError VN2010 when the host lacks a required capability, VN2011
+ * when the implementation is missing a declared method.
+ */
+declare function bindPort<T>(args: {
+  port: Port<T>;
+  impl: unknown;
+  caps: readonly HostCapability[];
+}): T;
+//#endregion
+//#region src/port/missing-capabilities.d.ts
+/**
+ * The gap between what is required and what the host offers.
+ *
+ * @returns the required capabilities absent from `caps`, in the order required.
+ */
+declare function missingCapabilities(args: {
+  requires: readonly HostCapability[];
+  caps: readonly HostCapability[];
+}): readonly HostCapability[];
+//#endregion
+//#region src/ports/clock/clock.port.d.ts
+/**
+ * The {@link Clock} contract. Implementations: `system-clock`, `virtual-clock`.
+ *
+ * `advance` and `setTime` are absent on purpose: they are how a test drives a
+ * virtual clock, not something a caller of the port may reach for.
+ */
+declare const ClockPort: Port<Clock>;
+//#endregion
+//#region src/ports/clock/system-clock.d.ts
+/** Wall-clock time, on the `Date` and `setTimeout` globals. */
+declare function createSystemClock(): Clock;
+//#endregion
+//#region src/ports/clock/virtual-clock.d.ts
+/**
+ * The double. `sleep` advances internal time and resolves at once, so a test
+ * about a timeout costs nothing to run.
+ *
+ * @param args.start - the epoch this clock begins at. Defaults to 0.
+ */
+declare function createVirtualClock(args?: {
+  start?: number;
+}): VirtualClock;
+//#endregion
+//#region src/ports/file-system/file-system.errors.d.ts
+/** VN8010: a read or a remove targeted a path that does not exist. */
+declare function fsNotFound(args: {
+  path: string;
+}): VennError;
+//#endregion
+//#region src/ports/file-system/file-system.port.d.ts
+/**
+ * The {@link FileSystem} contract. Implementations: `node-fs`, `memory-fs`.
+ */
+declare const FileSystemPort: Port<FileSystem>;
+//#endregion
+//#region src/ports/file-system/memory-fs.d.ts
+/** The double: byte-exact, isolated per instance, no disk. */
+declare function createMemoryFs(): FileSystem;
+//#endregion
+//#region src/ports/lock-provider/fake-lock.d.ts
+/** The double: grants immediately and serialises nothing. */
+declare function createFakeLock(): LockProvider;
+//#endregion
+//#region src/ports/lock-provider/in-process-lock.d.ts
+/**
+ * The real one: a chained-promise mutex per name. Waiters are served in the
+ * order they asked, and the chain lives only in this process.
+ */
+declare function createInProcessLock(): LockProvider;
+//#endregion
+//#region src/ports/lock-provider/lock-provider.port.d.ts
+/**
+ * The {@link LockProvider} contract. Implementations: `in-process-lock`,
+ * `fake-lock`.
+ *
+ * Requires nothing: a mutex is bookkeeping, so it binds even on a host with no
+ * capabilities at all.
+ */
+declare const LockProviderPort: Port<LockProvider>;
+//#endregion
+//#region src/ports/process-provider/fake-process.d.ts
+/**
+ * The double: a scripted process that never touches the OS.
+ *
+ * Output is streamed before the wait resolves, exactly as the real one does it,
+ * so a caller that shows progress is exercised here and not only against a real
+ * machine.
+ *
+ * @param args.exitCode - what every run reports. Defaults to 0.
+ * @param args.output - what every run writes. Defaults to nothing.
+ */
+declare function createFakeProcess(args?: {
+  exitCode?: number;
+  output?: string;
+}): ProcessProvider;
+//#endregion
+//#region src/ports/process-provider/process-provider.port.d.ts
+/**
+ * The {@link ProcessProvider} contract. Implementations: `node-spawn`,
+ * `fake-process`.
+ */
+declare const ProcessProviderPort: Port<ProcessProvider>;
+//#endregion
+//#region src/ports/random/fixed-random.d.ts
+/** The double: always the same value, and always `min` from `int`. */
+declare function createFixedRandom(args?: {
+  value?: number;
+}): Random;
+//#endregion
+//#region src/ports/random/random.port.d.ts
+/**
+ * The {@link Random} contract. Implementations: `seeded-random`,
+ * `fixed-random`.
+ */
+declare const RandomPort: Port<Random>;
+//#endregion
+//#region src/ports/random/seeded-random.d.ts
+/**
+ * The real one: a mulberry32 PRNG, seeded once per worker. Same seed, same
+ * sequence, so a run reproduces.
+ */
+declare function createSeededRandom(args: {
+  seed: number;
+}): Random;
+//#endregion
+//#region src/ports/secret-provider/env-secrets.d.ts
+/**
+ * The real one: secrets from `process.env`.
+ *
+ * The `process` global is probed rather than imported, so this file stays
+ * neutral and reports every name as absent in a Worker instead of throwing.
+ */
+declare function createEnvSecrets(): SecretProvider;
+//#endregion
+//#region src/ports/secret-provider/memory-secrets.d.ts
+/**
+ * The double: secrets given by name, wrapped so they still redact.
+ *
+ * @param args.values - the raw values, keyed by secret name.
+ */
+declare function createMemorySecrets(args: {
+  values: Record<string, string>;
+}): SecretProvider;
+//#endregion
+//#region src/ports/secret-provider/secret.d.ts
+/** What every serialised secret collapses to. */
+declare const REDACTED = "‹redigido›";
+/**
+ * Wrap a raw value so it cannot leak through `toString` or `toJSON`.
+ *
+ * @param args.reveal - the raw value, reachable only via `Secret.reveal()`.
+ */
+declare function makeSecret(args: {
+  reveal: string;
+}): Secret;
+//#endregion
+//#region src/ports/secret-provider/secret-provider.port.d.ts
+/**
+ * The {@link SecretProvider} contract. Implementations: `env-secrets`,
+ * `memory-secrets`.
+ */
+declare const SecretProviderPort: Port<SecretProvider>;
+//#endregion
+//#region src/host/host.types.d.ts
+/**
+ * Everything the core is allowed to reach: assembled at the entry point, then
+ * passed inward. The core receives this and imports nothing else.
+ *
+ * Three assemblers build one: `createHost.worker`, `createHost.test`, and
+ * `createNodeHost` from `@venn-lang/contracts/node`.
+ */
+interface Host {
+  readonly fs: FileSystem;
+  readonly proc: ProcessProvider;
+  readonly clock: Clock;
+  readonly random: Random;
+  readonly secrets: SecretProvider;
+  readonly log: Logger;
+  readonly lock: LockProvider;
+  readonly caps: readonly HostCapability[];
+}
+//#endregion
+//#region src/host/create-test-host.d.ts
+/**
+ * A host of doubles, every capability granted. The default for tests.
+ *
+ * @param overrides - replaces individual members, e.g. a real clock.
+ */
+declare function createTestHost(overrides?: Partial<Host>): Host;
+//#endregion
+//#region src/host/create-worker-host.d.ts
+/**
+ * Host for a Web Worker: an in-memory file system, no `process`, no `net`.
+ *
+ * `proc` is a stand-in whose every method throws VN2012, so reaching for a
+ * subprocess in the editor fails with a diagnostic instead of a `TypeError`.
+ */
+declare function createWorkerHost(): Host;
+//#endregion
+//#region src/host/create-host.d.ts
+/**
+ * The neutral host assemblers.
+ *
+ * `node` is deliberately absent: it pulls `node:*`, so it lives behind
+ * `@venn-lang/contracts/node` as `createNodeHost` and this entry stays Worker-safe.
+ */
+declare const createHost: {
+  readonly worker: typeof createWorkerHost;
+  readonly test: typeof createTestHost;
+};
+//#endregion
+//#region src/host/unavailable.d.ts
+/**
+ * A stand-in for a port the host cannot provide, such as `process` in a Worker.
+ *
+ * @param args.capability - the capability the host lacks, named in the error.
+ * @param args.methods - the port's declared methods, usually `SomePort.methods`.
+ * @returns an object shaped like `T` whose every method throws VN2012 when
+ * called, rather than failing as a `TypeError` mid-run.
+ */
+declare function unavailable<T>(args: {
+  capability: HostCapability;
+  methods: readonly string[];
+}): T;
+//#endregion
+//#region src/ports/console/console.types.d.ts
+/**
+ * The program's console: standard streams and process arguments.
+ *
+ * Everything a script needs to talk to the outside world without knowing
+ * whether it runs on Node, in a test, or in a browser worker. The host supplies
+ * the wiring.
+ */
+interface Console {
+  /** Write to standard output, exactly as given (no trailing newline). */
+  write(text: string): void;
+  /** Write to standard error. */
+  writeError(text: string): void;
+  /** Read the next line from standard input, or null at end of input. */
+  readLine(): Promise<string | null>;
+  /** The command-line arguments passed after the script path. */
+  args(): readonly string[];
+}
+//#endregion
+//#region src/ports/console/console.port.d.ts
+/**
+ * The {@link Console} contract. Implementations: `node-console`,
+ * `memory-console`.
+ */
+declare const ConsolePort: Port<Console>;
+//#endregion
+//#region src/ports/console/memory-console.d.ts
+/** A {@link Console} that keeps its transcript instead of printing it. */
+interface MemoryConsole extends Console {
+  readonly out: string;
+  readonly err: string;
+}
+/**
+ * The double: records what was written, reads from a scripted input.
+ *
+ * @param args.input - the lines `readLine` hands back, in order.
+ * @param args.argv - what `args()` reports.
+ */
+declare function createMemoryConsole(args?: {
+  input?: readonly string[];
+  argv?: readonly string[];
+}): MemoryConsole;
+//#endregion
+//#region src/ports/manifest-provider/default-manifest.d.ts
+/**
+ * A manifest with nothing declared: what a project without a `venn.toml` is.
+ *
+ * The one place stating what a project gets for saying nothing at all, so a
+ * caller who wants one field need not spell the other dozen.
+ *
+ * @param overrides - fields to state explicitly. `name` and `version` fall back
+ * to `[package]` before falling back to the defaults.
+ */
+declare function defaultManifest(overrides?: Partial<Manifest>): Manifest;
+//#endregion
+//#region src/ports/manifest-provider/edit/edit-dependency.d.ts
+/** What to change, and in which table. */
+interface DependencyEdit {
+  /** The manifest as written. */
+  text: string;
+  name: string;
+  /** Defaults to {@link DEPENDENCIES}. Pass `"dev-dependencies"` for the other. */
+  table?: string;
+}
+/** The table an edit touches unless told otherwise. */
+declare const DEPENDENCIES = "dependencies";
+/**
+ * The manifest with one dependency written in, everything else untouched.
+ *
+ * Entries are kept in name order, so two people adding two packages produce two
+ * one-line diffs rather than a conflict. A name already there is replaced where
+ * it stands, because an upgrade should not move the line.
+ *
+ * @returns the whole manifest as text. A missing table is appended at the end.
+ */
+declare function addDependency(args: DependencyEdit & {
+  version: string;
+}): string;
+/**
+ * The manifest without that dependency.
+ *
+ * @returns the text unchanged when the name is not there: absent is already the
+ * wanted state.
+ */
+declare function removeDependency(args: DependencyEdit): string;
+//#endregion
+//#region src/ports/manifest-provider/manifest.port.d.ts
+/**
+ * The {@link ManifestProvider} contract. Implementations: `toml-manifest`,
+ * `memory-manifest`.
+ *
+ * Requires nothing: reading the file is the caller's job, and what arrives here
+ * is already text.
+ */
+declare const ManifestProviderPort: Port<ManifestProvider>;
+//#endregion
+//#region src/ports/manifest-provider/memory-manifest.d.ts
+/**
+ * The double: a preset manifest, with no file involved.
+ *
+ * Takes only what the caller cares about. The rest is what a project that
+ * declared nothing would get, which is exactly what the real provider gives a
+ * `venn.toml` silent on those tables.
+ */
+declare function createMemoryManifest(args: {
+  manifest: Partial<Manifest>;
+}): ManifestProvider;
+//#endregion
+//#region src/ports/manifest-provider/read/read-package.d.ts
+/**
+ * The same table, reduced to what a member may inherit from its workspace.
+ *
+ * A name is never inherited, being the one thing that must differ between two
+ * members, so `[workspace.package]` carrying one is read as carrying none.
+ */
+declare function readInheritable(data: Record<string, unknown>): Partial<PackageInfo>;
+//#endregion
+//#region src/ports/manifest-provider/read/read-profiles.d.ts
+/**
+ * What each build is for, and what that costs.
+ *
+ * `dev` reports what it finds and carries on, because a project being worked on
+ * is half-written most of the time. `release` refuses to build over a problem.
+ * Neither has to be written in a manifest for the defaults to apply.
+ */
+declare const DEFAULT_PROFILES: Readonly<Record<string, Profile>>;
+//#endregion
+//#region src/ports/manifest-provider/read/read-targets.d.ts
+/** Where a `lib` target starts when the manifest does not say. */
+declare const LIB_ROOT = "src/lib.vn";
+/** Where the default `bin` target starts when the manifest does not say. */
+declare const MAIN_ROOT = "src/main.vn";
+/** Where additional `bin` targets are looked for by convention. */
+declare const BIN_DIR = "src/bin";
+//#endregion
+//#region src/ports/manifest-provider/resolve-alias.d.ts
+/** Where a `#alias/…` specifier points. */
+interface AliasTarget {
+  /** The directory `[paths]` maps the alias to. */
+  dir: string;
+  /** What followed the alias, with the separating slash removed. */
+  rest: string;
+}
+/**
+ * Split a `#alias/rest` import specifier against `[paths]` from `venn.toml`.
+ *
+ * @returns undefined when the specifier names no configured alias, which the
+ * caller reads as a relative or bare path.
+ */
+declare function resolveAlias(args: {
+  spec: string;
+  paths: Record<string, string>;
+}): AliasTarget | undefined;
+//#endregion
+//#region src/ports/manifest-provider/toml/parse-toml.d.ts
+/**
+ * A TOML reader for `venn.toml`: sections, nested `[a.b]`, arrays of tables
+ * (`[[bin]]`), `key = value`, strings, numbers, bools, arrays and inline tables.
+ *
+ * Not a full TOML parser. No dates, no multi-line strings, no dotted keys.
+ * `venn.toml` is our own format, so the subset is a decision rather than a
+ * shortfall.
+ *
+ * @returns the root table. Malformed lines are skipped, never thrown on.
+ */
+declare function parseToml(content: string): Record<string, unknown>;
+//#endregion
+//#region src/ports/manifest-provider/toml-docs.d.ts
+/**
+ * The comment block written directly above a key, read as that key's
+ * documentation. The same idea as `##` above a declaration in a `.vn`.
+ *
+ * A blank line breaks the block, so a comment separated from a key belongs to
+ * nobody and is never attributed to the next one down.
+ *
+ * @returns documentation keyed by the key it sits above.
+ */
+declare function tomlDocs(content: string): Record<string, string>;
+//#endregion
+//#region src/ports/manifest-provider/toml-manifest.d.ts
+/**
+ * The real one: parse `venn.toml` into a {@link Manifest}.
+ *
+ * Parsing happens once, at construction, so repeated `load()` calls are free
+ * and always agree.
+ *
+ * @param args.content - the manifest as written.
+ */
+declare function createTomlManifest(args: {
+  content: string;
+}): ManifestProvider;
+//#endregion
+//#region src/ports/signal-source/fake-signals.d.ts
+/** A {@link SignalSource} with the bell a test rings. */
+interface FakeSignals extends SignalSource {
+  /** Deliver `signal` to everyone still listening for it. */
+  raise(signal: SystemSignal): void;
+  /** Which signals are currently being listened for, for assertions. */
+  readonly listening: readonly SystemSignal[];
+}
+/**
+ * The double: a signal arrives because a test said so. No process, no operating
+ * system, no risk of stopping the test runner along with the code under test.
+ */
+declare function createFakeSignals(): FakeSignals;
+//#endregion
+//#region src/ports/signal-source/signal-source.port.d.ts
+/**
+ * The {@link SignalSource} contract. Implementations: `node-signals`,
+ * `fake-signals`.
+ */
+declare const SignalSourcePort: Port<SignalSource>;
+//#endregion
+export { ALL_CAPABILITIES, ALL_SIGNALS, type AliasTarget, type AnyPort, BIN_DIR, type BuildTarget, type Clock, ClockPort, type Console, ConsolePort, DEFAULT_PROFILES, DEPENDENCIES, DOTENV_CONVENTION, type Dependency, type DependencyEdit, type DirEntry, type FakeSignals, type FileSystem, FileSystemPort, type FormatSettings, type Host, type HostCapability, type KnownSecret, LIB_ROOT, type LockProvider, LockProviderPort, type LogEntry, type LogLevel, type Logger, MAIN_ROOT, type Manifest, type ManifestProvider, ManifestProviderPort, type MemoryConsole, type MemoryLogger, type PackageInfo, type PackageManagerName, type Port, type ProcessHandle, type ProcessProvider, ProcessProviderPort, type ProcessResult, type Profile, REDACTED, type Random, RandomPort, type Release, type Secret, type SecretProvider, SecretProviderPort, type SignalHandler, type SignalSource, SignalSourcePort, type SpawnArgs, type SystemSignal, type TargetKind, type ToolingSettings, type Unsubscribe, VennError, type VennErrorDetail, type VirtualClock, type WorkspaceSettings, addDependency, assertCapabilities, assertPortShape, bindPort, capabilityUnavailable, createConsoleLogger, createEnvSecrets, createFakeLock, createFakeProcess, createFakeSignals, createFixedRandom, createHost, createInProcessLock, createMemoryConsole, createMemoryFs, createMemoryLogger, createMemoryManifest, createMemorySecrets, createSeededRandom, createSystemClock, createTestHost, createTomlManifest, createVirtualClock, createWorkerHost, defaultManifest, dotenvFiles, fsNotFound, hostMissingCapability, makeSecret, missingCapabilities, parseDotenv, parseToml, portShapeMismatch, readInheritable, removeDependency, resolveAlias, tomlDocs, unavailable };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/capabilities/host-capability.ts","../src/dotenv/dotenv-files.ts","../src/dotenv/parse-dotenv.ts","../src/errors/venn-error.ts","../src/errors/contract-codes.ts","../src/logger/logger.types.ts","../src/logger/console-logger.ts","../src/logger/memory-logger.ts","../src/port/port.types.ts","../src/port/assert-capabilities.ts","../src/port/assert-port-shape.ts","../src/port/bind-port.ts","../src/port/missing-capabilities.ts","../src/ports/clock/clock.port.ts","../src/ports/clock/system-clock.ts","../src/ports/clock/virtual-clock.ts","../src/ports/file-system/file-system.errors.ts","../src/ports/file-system/file-system.port.ts","../src/ports/file-system/memory-fs.ts","../src/ports/lock-provider/fake-lock.ts","../src/ports/lock-provider/in-process-lock.ts","../src/ports/lock-provider/lock-provider.port.ts","../src/ports/process-provider/fake-process.ts","../src/ports/process-provider/process-provider.port.ts","../src/ports/random/fixed-random.ts","../src/ports/random/random.port.ts","../src/ports/random/seeded-random.ts","../src/ports/secret-provider/env-secrets.ts","../src/ports/secret-provider/memory-secrets.ts","../src/ports/secret-provider/secret.ts","../src/ports/secret-provider/secret-provider.port.ts","../src/host/host.types.ts","../src/host/create-test-host.ts","../src/host/create-worker-host.ts","../src/host/create-host.ts","../src/host/unavailable.ts","../src/ports/console/console.types.ts","../src/ports/console/console.port.ts","../src/ports/console/memory-console.ts","../src/ports/manifest-provider/default-manifest.ts","../src/ports/manifest-provider/edit/edit-dependency.ts","../src/ports/manifest-provider/manifest.port.ts","../src/ports/manifest-provider/memory-manifest.ts","../src/ports/manifest-provider/read/read-package.ts","../src/ports/manifest-provider/read/read-profiles.ts","../src/ports/manifest-provider/read/read-targets.ts","../src/ports/manifest-provider/resolve-alias.ts","../src/ports/manifest-provider/toml/parse-toml.ts","../src/ports/manifest-provider/toml-docs.ts","../src/ports/manifest-provider/toml-manifest.ts","../src/ports/signal-source/fake-signals.ts","../src/ports/signal-source/signal-source.port.ts"],"mappings":"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"}