@molecule/api-code-sandbox-docker 1.0.1 → 1.0.2

package/README.md

@@ -3,7 +3,7 @@ AUTO-GENERATED — DO NOT EDIT THIS FILE.
 Generated by `mlcl sync-docs` from the package's src/index.ts JSDoc + mlcl/registry.json.
 Edits here are overwritten on the next commit (molecule's pre-commit hook regenerates).
 To change this document, edit the module-level JSDoc in src/index.ts.
-Generated: 2026-08-04T01:47:54.321Z
+Generated: 2026-08-05T12:53:11.363Z
 -->
 
 # @molecule/api-code-sandbox-docker
@@ -82,6 +82,29 @@ interface DockerConfig {
   labelPrefix?: string
   /** Preview URL template. Use {port} placeholder. */
   previewUrlTemplate?: string
+  /**
+   * Docker repository holding sandbox TEMPLATES — one tag per template id.
+   * Defaults to `molecule-sandbox-template` (or `SANDBOX_TEMPLATE_REPOSITORY`).
+   *
+   * Deliberately NOT the base image's repository. Sharing one repository between
+   * the base image and every template makes `docker images <repo>` and any
+   * cleanup written against it operate on both, and the only thing standing
+   * between a template sweep and the base image is a tag-prefix convention.
+   */
+  templateRepository?: string
+  /**
+   * Registry host for sharing templates across hosts, e.g. `registry.example.com`
+   * (or `SANDBOX_TEMPLATE_REGISTRY`). When unset, `publishTemplate`/`fetchTemplate`
+   * throw with an actionable message: the daemon CAN talk to a registry, so the
+   * capability is present and only the address is missing.
+   */
+  templateRegistry?: string
+  /**
+   * Base64-encoded Docker `X-Registry-Auth` value for {@link DockerConfig.templateRegistry}
+   * (or `SANDBOX_TEMPLATE_REGISTRY_AUTH`). Defaults to an empty credential set,
+   * which is what an anonymous or already-logged-in daemon needs.
+   */
+  templateRegistryAuth?: string
 }
 ```
 
@@ -97,6 +120,12 @@ interface ProcessEnv {
   DOCKER_HOST?: string
   /** Docker network sandbox containers attach to (default `molecule-sandbox`, ICC-off). Overridden by `config.network`. [C1-1] */
   SANDBOX_DOCKER_NETWORK?: string
+  /** Docker repository holding sandbox templates (default `molecule-sandbox-template`). Overridden by `config.templateRepository`. */
+  SANDBOX_TEMPLATE_REPOSITORY?: string
+  /** Registry host for sharing templates across hosts. Overridden by `config.templateRegistry`. */
+  SANDBOX_TEMPLATE_REGISTRY?: string
+  /** Base64 `X-Registry-Auth` value for `SANDBOX_TEMPLATE_REGISTRY`. Overridden by `config.templateRegistryAuth`. */
+  SANDBOX_TEMPLATE_REGISTRY_AUTH?: string
 }
 ```
 
@@ -114,6 +143,24 @@ function createProvider(config?: DockerConfig): SandboxProvider
 
 **Returns:** A `SandboxProvider` that manages Docker containers as sandboxes.
 
+#### `resolvePublishPorts(ports)`
+
+Validate the ports a caller asked to publish, falling back to this provider's
+historical API + Vite pair when it named none.
+
+Rejects rather than filters: a caller that asked for a port it cannot have
+needs to hear so, because the alternative is a dev server running inside a
+sandbox that nothing on the outside can ever reach — which looks like a broken
+application, not a bad argument.
+
+```typescript
+function resolvePublishPorts(ports?: number[]): number[]
+```
+
+- `ports` — Ports inside the sandbox the caller wants reachable.
+
+**Returns:** The ports to expose and bind.
+
 #### `withTransientRetry(op, opts)`
 
 Retry a Docker API operation that failed with a TRANSIENT fault — a request
@@ -222,7 +269,50 @@ prerequisite.
 container/volume size (it needs specific storage drivers — e.g. overlay2 on xfs
 with `pquota` — and errors on the common overlay2/ext4 host), so this provider
 enforces none. The core `resources.diskMB` is accepted but not applied here; cap
-disk at the host / volume level instead.
+disk at the host / volume level instead. `setResources({ diskMB })` THROWS
+rather than accepting a ceiling it cannot enforce.
+
+**Templates are not `commit` alone, and that is not an optimization.**
+`commitTemplate` copies the caller-named `capturePaths` into a throwaway,
+volume-less container and commits THAT. A sandbox keeps the project on a
+volume, and a volume is not part of a container's writable layer — so
+committing a sandbox directly yields an image that builds, tags, and boots
+with an empty workspace, with no error anywhere. The throwaway container
+handles tenant-authored bytes and is committed into something other tenants
+boot, so it runs with `--network none`, `CapDrop: ALL` plus the three
+capabilities extraction needs, a memory cap and a process cap, and setuid/setgid
+bits are stripped from the extracted tree afterwards.
+
+Templates live in their OWN repository (`templateRepository`, default
+`molecule-sandbox-template`) rather than sharing the base image's, so nothing
+written to sweep templates can reach the base image. `publishTemplate` /
+`fetchTemplate` use a Docker registry and require `templateRegistry`; without
+it they THROW rather than returning "not found", because "there is no shared
+store" and "the shared store does not have it" are different answers.
+
+**`hibernate()`/`resume()` report which mechanism ran.** A CRIU checkpoint
+preserves the process tree; a stop does not, and whether CRIU is available is a
+property of the host (the daemon's experimental flag plus the `criu` package),
+discovered at runtime. A sandbox that runs its dev servers as detached exec
+processes comes back from a stop-style wake alive and serving nothing, so
+callers must branch on `processesPreserved` — never on `status`, which says
+`running` either way. The first response that shows CRIU is unavailable
+disables it for the rest of the process.
+
+**`find()` costs one request per match.** Docker's container LIST omits
+`State.StartedAt`, which is the only field distinguishing an interrupted
+creation (`startedAt: null` — holds storage forever, will never run) from an
+ordinary stopped sandbox, so each match is then inspected. Narrow with
+`labels`; an unfiltered query on a busy host inspects every container.
+
+**`capacity()` measures THIS host, so it reports nothing for a TCP daemon.**
+Over a `tcp://` endpoint the daemon writes to a different machine's storage,
+and returning this machine's numbers would be a confident wrong answer — so it
+returns empty `headroom` and says why. On a local socket it reports free bytes
+and free inodes on the daemon's `DockerRootDir` plus `MemAvailable`. Inodes are
+omitted (not reported as zero) on filesystems with dynamic inode allocation.
+`admits` is always `null`: Docker has no quota of its own to consult, so the
+floors and the refusal stay with the caller.
 
 ## Translations
 

package/dist/archive.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Bulk file transfer in and out of a Docker sandbox, as POSIX tar streams.
+ *
+ * The Engine API has a first-class endpoint pair for this
+ * (`GET`/`PUT /containers/{id}/archive`), so the bond does not need to
+ * orchestrate `tar` through an exec. That matters beyond tidiness: an exec-based
+ * pipe has to survive two hijacked sockets and gives no status code you can
+ * trust, which is how a workspace capture ends up "succeeding" with half a tree.
+ *
+ * Nothing is buffered. A project tree is gigabytes across hundreds of thousands
+ * of files; reading one into this process to hand it to the next call would trade
+ * a slow transfer for a dead API.
+ *
+ * **Extraction does not restore ownership or setuid bits.** `copyUIDGID` is left
+ * off, and callers capturing a tenant-authored tree into something another tenant
+ * boots must additionally strip setuid/setgid — `commitTemplate` does. An archive
+ * is data, and honoring the mode bits in data is how it becomes an escalation.
+ *
+ * @module
+ */
+import type { DockerDownload, DockerUpload } from './request.js';
+/** What the archive capability needs from the provider. */
+export interface ArchiveContext {
+    download: DockerDownload;
+    upload: DockerUpload;
+}
+/**
+ * Stream a directory tree out of a sandbox as a POSIX tar archive.
+ *
+ * The archive is rooted at the LAST segment of `path` — an export of
+ * `/workspace` yields entries under `workspace/` — which is what makes it
+ * extractable into the parent directory on the way back in.
+ *
+ * @param ctx - Archive context.
+ * @param containerId - The sandbox to read from.
+ * @param path - Absolute path inside the sandbox.
+ * @returns A tar byte stream.
+ */
+export declare function exportContainerFiles(ctx: ArchiveContext, containerId: string, path: string): Promise<AsyncIterable<Uint8Array>>;
+/**
+ * Stream a POSIX tar archive into a sandbox, extracting it at `path`.
+ *
+ * @param ctx - Archive context.
+ * @param containerId - The sandbox to write to.
+ * @param path - Absolute destination directory inside the sandbox.
+ * @param archive - The tar byte stream to extract.
+ */
+export declare function importContainerFiles(ctx: ArchiveContext, containerId: string, path: string, archive: AsyncIterable<Uint8Array>): Promise<void>;
+//# sourceMappingURL=archive.d.ts.map

package/dist/archive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive.d.ts","sourceRoot":"","sources":["../src/archive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAEhE,2DAA2D;AAC3D,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,cAAc,CAAA;IACxB,MAAM,EAAE,YAAY,CAAA;CACrB;AAmBD;;;;;;;;;;;GAWG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,cAAc,EACnB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAMpC;AAED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,cAAc,EACnB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,aAAa,CAAC,UAAU,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC,CAOf"}

package/dist/archive.js

@@ -0,0 +1,61 @@
+/**
+ * Bulk file transfer in and out of a Docker sandbox, as POSIX tar streams.
+ *
+ * The Engine API has a first-class endpoint pair for this
+ * (`GET`/`PUT /containers/{id}/archive`), so the bond does not need to
+ * orchestrate `tar` through an exec. That matters beyond tidiness: an exec-based
+ * pipe has to survive two hijacked sockets and gives no status code you can
+ * trust, which is how a workspace capture ends up "succeeding" with half a tree.
+ *
+ * Nothing is buffered. A project tree is gigabytes across hundreds of thousands
+ * of files; reading one into this process to hand it to the next call would trade
+ * a slow transfer for a dead API.
+ *
+ * **Extraction does not restore ownership or setuid bits.** `copyUIDGID` is left
+ * off, and callers capturing a tenant-authored tree into something another tenant
+ * boots must additionally strip setuid/setgid — `commitTemplate` does. An archive
+ * is data, and honoring the mode bits in data is how it becomes an escalation.
+ *
+ * @module
+ */
+/** Generous by design: this moves whole project trees, not files. */
+const TRANSFER_TIMEOUT_MS = 600_000;
+/**
+ * Reject a path that is not a plain absolute path.
+ *
+ * @param path - Candidate path.
+ * @throws {Error} When the path is relative or contains a traversal segment.
+ */
+function assertAbsolutePath(path) {
+    if (!path.startsWith('/') || path.includes('..') || path.includes('\0')) {
+        throw new Error(`Invalid sandbox path ${JSON.stringify(path.slice(0, 64))}: must be absolute and free of ".." segments`);
+    }
+}
+/**
+ * Stream a directory tree out of a sandbox as a POSIX tar archive.
+ *
+ * The archive is rooted at the LAST segment of `path` — an export of
+ * `/workspace` yields entries under `workspace/` — which is what makes it
+ * extractable into the parent directory on the way back in.
+ *
+ * @param ctx - Archive context.
+ * @param containerId - The sandbox to read from.
+ * @param path - Absolute path inside the sandbox.
+ * @returns A tar byte stream.
+ */
+export async function exportContainerFiles(ctx, containerId, path) {
+    assertAbsolutePath(path);
+    return ctx.download(`/containers/${containerId}/archive?path=${encodeURIComponent(path)}`, TRANSFER_TIMEOUT_MS);
+}
+/**
+ * Stream a POSIX tar archive into a sandbox, extracting it at `path`.
+ *
+ * @param ctx - Archive context.
+ * @param containerId - The sandbox to write to.
+ * @param path - Absolute destination directory inside the sandbox.
+ * @param archive - The tar byte stream to extract.
+ */
+export async function importContainerFiles(ctx, containerId, path, archive) {
+    assertAbsolutePath(path);
+    await ctx.upload(`/containers/${containerId}/archive?path=${encodeURIComponent(path)}`, archive, TRANSFER_TIMEOUT_MS);
+}

package/dist/capacity.d.ts

@@ -0,0 +1,71 @@
+/**
+ * What this Docker host can still fit.
+ *
+ * A sandbox is admitted long before it is expensive: creating one populates a
+ * fresh volume with a dependency tree, and by the time that fails the host is
+ * already out of something and every OTHER sandbox on it is failing too. So the
+ * caller wants to refuse the boot while it can still say so cleanly — and to do
+ * that it needs a measurement only the provider can take.
+ *
+ * Three axes, because they run out separately and independently:
+ *
+ * - **Blocks.** The obvious one.
+ * - **Inodes.** A populated `node_modules` is hundreds of thousands of tiny
+ *   files. On a filesystem with a fixed inode table this exhausts first, and
+ *   every file creation on the host then fails with `ENOSPC` while `df -h`
+ *   reports gigabytes free — a failure that looks like nothing else.
+ * - **Memory.** Each running sandbox holds a live container resident, and unlike
+ *   disk this is NOT reclaimed by idle hibernation on any useful timescale. A
+ *   burst of simultaneously-active users oversubscribes the host until the OOM
+ *   killer starts choosing victims among sandboxes that were working fine.
+ *
+ * `MemAvailable` from `/proc/meminfo`, not `os.freemem()`. The kernel's estimate
+ * counts reclaimable page cache; `MemFree` does not, and on any warm host it
+ * understates free memory badly enough to reject boots the host could serve.
+ *
+ * **This measures the host THIS PROCESS runs on**, which is only the right host
+ * when the daemon is local. Over a TCP endpoint the numbers would describe the
+ * wrong machine, so the answer is `inconclusive`-shaped instead: no headroom
+ * fields, and a `detail` that says why. Reporting a comfortable local number for
+ * a remote daemon is the exact conflation this codebase refuses everywhere else.
+ *
+ * @module
+ */
+import type { SandboxCapacity } from '@molecule/api-code-sandbox';
+import type { DockerRequest } from './request.js';
+/** The subset of `fs.StatsFs` this module uses. */
+export interface FilesystemStats {
+    /** Block size in bytes. */
+    bsize: number;
+    /** Blocks available to an unprivileged process. */
+    bavail: number;
+    /** Free file nodes, or `-1`/`0` on filesystems without a fixed inode table. */
+    ffree: number;
+}
+/** What the capacity capability needs from the provider. */
+export interface CapacityContext {
+    request: DockerRequest;
+    /**
+     * Whether the daemon is reached over a local unix socket. Only then does this
+     * process's filesystem describe the storage the daemon writes to.
+     */
+    daemonIsLocal: boolean;
+    /** Filesystem statistics for a path. Injected so this is testable without a disk. */
+    statfs: (path: string) => Promise<FilesystemStats>;
+    /** Available memory in bytes, or `null` when it cannot be read. */
+    availableMemoryBytes: () => Promise<number | null>;
+    warn?: (message: string, meta?: Record<string, unknown>) => void;
+}
+/**
+ * Measure what the host backing this daemon can still fit.
+ *
+ * `admits` is always `null`: Docker has no admission opinion of its own — it has
+ * no quota, no plan, and no notion of "too many". The caller compares the
+ * headroom against its own floors. A provider that DID have such an opinion
+ * (an account quota, a rate limit) would answer here instead.
+ *
+ * @param ctx - Capacity context.
+ * @returns Measured headroom and an explanation of anything unmeasurable.
+ */
+export declare function measureDockerCapacity(ctx: CapacityContext): Promise<SandboxCapacity>;
+//# sourceMappingURL=capacity.d.ts.map

package/dist/capacity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capacity.d.ts","sourceRoot":"","sources":["../src/capacity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAEjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,mDAAmD;AACnD,MAAM,WAAW,eAAe;IAC9B,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAA;IACd,+EAA+E;IAC/E,KAAK,EAAE,MAAM,CAAA;CACd;AAED,4DAA4D;AAC5D,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,aAAa,CAAA;IACtB;;;OAGG;IACH,aAAa,EAAE,OAAO,CAAA;IACtB,qFAAqF;IACrF,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,CAAA;IAClD,mEAAmE;IACnE,oBAAoB,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAClD,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;CACjE;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAuD1F"}

package/dist/capacity.js

@@ -0,0 +1,98 @@
+/**
+ * What this Docker host can still fit.
+ *
+ * A sandbox is admitted long before it is expensive: creating one populates a
+ * fresh volume with a dependency tree, and by the time that fails the host is
+ * already out of something and every OTHER sandbox on it is failing too. So the
+ * caller wants to refuse the boot while it can still say so cleanly — and to do
+ * that it needs a measurement only the provider can take.
+ *
+ * Three axes, because they run out separately and independently:
+ *
+ * - **Blocks.** The obvious one.
+ * - **Inodes.** A populated `node_modules` is hundreds of thousands of tiny
+ *   files. On a filesystem with a fixed inode table this exhausts first, and
+ *   every file creation on the host then fails with `ENOSPC` while `df -h`
+ *   reports gigabytes free — a failure that looks like nothing else.
+ * - **Memory.** Each running sandbox holds a live container resident, and unlike
+ *   disk this is NOT reclaimed by idle hibernation on any useful timescale. A
+ *   burst of simultaneously-active users oversubscribes the host until the OOM
+ *   killer starts choosing victims among sandboxes that were working fine.
+ *
+ * `MemAvailable` from `/proc/meminfo`, not `os.freemem()`. The kernel's estimate
+ * counts reclaimable page cache; `MemFree` does not, and on any warm host it
+ * understates free memory badly enough to reject boots the host could serve.
+ *
+ * **This measures the host THIS PROCESS runs on**, which is only the right host
+ * when the daemon is local. Over a TCP endpoint the numbers would describe the
+ * wrong machine, so the answer is `inconclusive`-shaped instead: no headroom
+ * fields, and a `detail` that says why. Reporting a comfortable local number for
+ * a remote daemon is the exact conflation this codebase refuses everywhere else.
+ *
+ * @module
+ */
+/**
+ * Measure what the host backing this daemon can still fit.
+ *
+ * `admits` is always `null`: Docker has no admission opinion of its own — it has
+ * no quota, no plan, and no notion of "too many". The caller compares the
+ * headroom against its own floors. A provider that DID have such an opinion
+ * (an account quota, a rate limit) would answer here instead.
+ *
+ * @param ctx - Capacity context.
+ * @returns Measured headroom and an explanation of anything unmeasurable.
+ */
+export async function measureDockerCapacity(ctx) {
+    if (!ctx.daemonIsLocal) {
+        return {
+            admits: null,
+            detail: 'The Docker daemon is reached over a TCP endpoint, so this process cannot measure the ' +
+                'storage or memory the daemon actually writes to. No headroom is reported rather than ' +
+                "reporting this machine's numbers for a different machine.",
+            headroom: {},
+        };
+    }
+    const notes = [];
+    const headroom = {};
+    let rootDir = '/var/lib/docker';
+    try {
+        const info = (await ctx.request('/info'));
+        if (info?.DockerRootDir)
+            rootDir = info.DockerRootDir;
+    }
+    catch (error) {
+        // Not fatal: the default root is right on the overwhelming majority of
+        // hosts, and a wrong path surfaces as a statfs failure below rather than as
+        // a confident wrong number.
+        ctx.warn?.('Could not read DockerRootDir from the daemon — assuming the default', { error });
+        notes.push(`could not read the daemon's storage root, assumed ${rootDir}`);
+    }
+    try {
+        const stats = await ctx.statfs(rootDir);
+        headroom.diskBytes = stats.bavail * stats.bsize;
+        // A filesystem with dynamic inodes (btrfs, xfs) reports 0 or -1 free nodes.
+        // That is "not applicable", not "exhausted", so it is omitted rather than
+        // reported as zero — a caller comparing against a floor would refuse every
+        // boot on such a host.
+        if (stats.ffree > 0)
+            headroom.inodes = stats.ffree;
+    }
+    catch (error) {
+        ctx.warn?.('Could not measure free space on the daemon storage root', { rootDir, error });
+        notes.push(`free space on ${rootDir} is unmeasurable`);
+    }
+    const memoryBytes = await ctx.availableMemoryBytes();
+    if (memoryBytes === null) {
+        notes.push('available memory is unreadable on this platform');
+    }
+    else {
+        headroom.memoryBytes = memoryBytes;
+    }
+    return {
+        admits: null,
+        detail: notes.length > 0
+            ? `Measured the host backing the local Docker daemon (${rootDir}); ${notes.join('; ')}.`
+            : `Measured the host backing the local Docker daemon (${rootDir}).`,
+        headroom,
+    };
+}

package/dist/egress.d.ts

@@ -0,0 +1,49 @@
+import type { EgressVerdict } from '@molecule/api-code-sandbox';
+import type { DockerRequest } from './request.js';
+/** Inputs the probe needs from the provider. */
+export interface EgressProbeContext {
+    request: DockerRequest;
+    /** The sandbox network name — the probe must be subject to the same rules. */
+    network: string;
+    /** Image to run the probe in; needs a `node` binary. */
+    baseImage: string;
+    /** Label namespace, used for the orphan sweep. */
+    labelPrefix: string;
+    /** Optional logger for cleanup failures. */
+    warn?: (message: string, meta?: Record<string, unknown>) => void;
+}
+/**
+ * The client program: raw `net.connect` to each target.
+ *
+ * Raw sockets, never `fetch` — proxy env is blanked AND a raw connect ignores it
+ * regardless, so this exercises the DIRECT path the proxy does not cover and only
+ * the firewall stops.
+ *
+ * @param targets - Destinations to attempt.
+ * @param timeoutMs - Per-connection timeout.
+ * @returns Program source.
+ */
+export declare function buildProbeScript(targets: Array<{
+    host: string;
+    port: number;
+}>, timeoutMs: number): string;
+/**
+ * The host-netns listener program for leg 2.
+ *
+ * @param port - Port to bind.
+ * @param timeoutMs - How long to wait for a connection.
+ * @returns Program source.
+ */
+export declare function buildListenerScript(port: number, timeoutMs: number): string;
+/**
+ * Run BOTH legs and combine them into one verdict.
+ *
+ * A `filtered` verdict requires both legs to be denied. Either leg observing a
+ * successful connection is conclusive `open`; anything that could not be observed
+ * is `inconclusive`.
+ *
+ * @param ctx - Probe context.
+ * @returns The combined verdict.
+ */
+export declare function verifyDockerEgress(ctx: EgressProbeContext): Promise<EgressVerdict>;
+//# sourceMappingURL=egress.d.ts.map

package/dist/egress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"egress.d.ts","sourceRoot":"","sources":["../src/egress.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAE/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,gDAAgD;AAChD,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,aAAa,CAAA;IACtB,8EAA8E;IAC9E,OAAO,EAAE,MAAM,CAAA;IACf,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAA;IACjB,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAA;IACnB,4CAA4C;IAC5C,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;CACjE;AAoFD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EAC9C,SAAS,EAAE,MAAM,GAChB,MAAM,CAUR;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAU3E;AA2OD;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC,aAAa,CAAC,CA6ExF"}