@jini-ai/platform 0.5.1 → 0.5.3

package/dist/fs/verified-directory-move.js

@@ -0,0 +1,138 @@
+import { stageVerifiedFileRelocation } from "./verified-file-relocation.js";
+import fs from "node:fs";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+/** Fingerprint relative names, entry kinds, symlink targets and file bytes without following links.
+ * This is verification, never a log of file contents. Lease files are excluded by the host.
+ * @complexity O(bytes + entries log entries), O(entries + a fixed 64 KiB read buffer) space.
+ */
+export function directoryFingerprint({ dir }, { excluded = [], filesystem = fs } = {}) {
+    const digest = createHash("sha256");
+    function visit(relative) {
+        for (const entry of filesystem.readdirSync(path.join(dir, relative), { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            if (!relative && excluded.includes(entry.name))
+                continue;
+            const name = path.join(relative, entry.name), absolute = path.join(dir, name);
+            const stat = filesystem.lstatSync(absolute);
+            const kind = stat.isSymbolicLink() ? "link" : stat.isDirectory() ? "directory" : stat.isFile() ? "file" : "unsupported";
+            if (kind === "unsupported")
+                throw new Error(`Cannot move special filesystem entry: ${name}`);
+            digest.update(JSON.stringify([name, kind, stat.mode & 0o777]));
+            if (kind === "directory")
+                visit(name);
+            else if (kind === "link")
+                digest.update(JSON.stringify(filesystem.readlinkSync(absolute)));
+            else {
+                const fileDigest = createHash("sha256"), buffer = Buffer.allocUnsafe(64 * 1024);
+                const descriptor = filesystem.openSync(absolute, "r");
+                try {
+                    let bytes;
+                    while ((bytes = filesystem.readSync(descriptor, buffer, 0, buffer.length, null)) > 0)
+                        fileDigest.update(buffer.subarray(0, bytes));
+                }
+                finally {
+                    filesystem.closeSync(descriptor);
+                }
+                digest.update(fileDigest.digest());
+            }
+        }
+    }
+    visit("");
+    return digest.digest("hex");
+}
+/** Move only into an absent target. Verify before registry commit or source deletion.
+ * EXDEV uses copy/verify/retire/commit; failure restores the source and removes only our new copy.
+ * Same-filesystem failures roll the rename back. Commit must atomically update the host registry.
+ * @complexity O(bytes + entries log entries), with two verification passes.
+ */
+export function moveDirectoryVerified({ from, to, commit }, { excluded = [], filesystem = fs, prepareDestination, relocateFiles, verifyFile, backupId = randomUUID } = {}) {
+    const source = filesystem.realpathSync(from);
+    const target = path.resolve(to);
+    if (target === source || target.startsWith(source + path.sep))
+        throw new Error("A directory cannot be moved into itself.");
+    try {
+        filesystem.lstatSync(target);
+        throw new Error(`Move target already exists: ${target}`);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const before = directoryFingerprint({ dir: source }, { excluded, filesystem });
+    let copied = false;
+    try {
+        filesystem.renameSync(source, target);
+    }
+    catch (error) {
+        if (error.code !== "EXDEV")
+            throw error;
+        filesystem.mkdirSync(target);
+        copied = true;
+        try {
+            // The host may reserve the empty destination before any commit marker or database is copied.
+            prepareDestination?.({ path: target });
+            filesystem.cpSync(source, target, { recursive: true, force: false, errorOnExist: true, preserveTimestamps: true, verbatimSymlinks: true,
+                filter: (candidate) => candidate === source || !excluded.includes(path.relative(source, candidate).split(path.sep)[0]),
+            });
+        }
+        catch (failure) {
+            filesystem.rmSync(target, { recursive: true });
+            throw failure;
+        }
+    }
+    let retiredSource;
+    let staged;
+    try {
+        if (directoryFingerprint({ dir: target }, { excluded, filesystem }) !== before)
+            throw new Error("Moved directory verification failed.");
+        if (relocateFiles) {
+            if (!verifyFile)
+                throw new Error("File relocation requires a verification port.");
+            staged = stageVerifiedFileRelocation({ groups: relocateFiles({ source, target }), verify: verifyFile }, { filesystem, backupId, backupCovered: ({ from }) => copied && path.resolve(from).startsWith(target + path.sep) });
+        }
+        if (copied) {
+            const backupRoot = path.join(path.dirname(source), `.relocation-${backupId()}-backup`);
+            const backup = path.join(backupRoot, path.basename(source));
+            if (filesystem.existsSync(backup))
+                throw new Error(`Move backup target already exists: ${backup}`);
+            // The EXDEV original becomes a recovery folder before catalog commit, never a second live
+            // site at the old path if cleanup fails. An interrupted apply leaves explicit backups.
+            filesystem.mkdirSync(backupRoot);
+            filesystem.renameSync(source, backup);
+            retiredSource = backup;
+            const fd = filesystem.openSync(backupRoot, "r");
+            try {
+                filesystem.fsyncSync(fd);
+            }
+            finally {
+                filesystem.closeSync(fd);
+            }
+        }
+        // Persist directory-name changes for same-filesystem renames as well as EXDEV retirement.
+        for (const directory of new Set([path.dirname(source), path.dirname(target)])) {
+            const fd = filesystem.openSync(directory, "r");
+            try {
+                filesystem.fsyncSync(fd);
+            }
+            finally {
+                filesystem.closeSync(fd);
+            }
+        }
+        commit();
+    }
+    catch (error) {
+        if (retiredSource)
+            filesystem.renameSync(retiredSource, source);
+        staged?.rollback();
+        if (copied)
+            filesystem.rmSync(target, { recursive: true });
+        else
+            filesystem.renameSync(target, source);
+        throw error;
+    }
+    // If deletion fails after commit, the verified target and registry remain usable; old DB live
+    // names were already retired before commit. Never roll back a registry whose commit succeeded.
+    staged?.finalize();
+    // Keep the retired EXDEV recovery folder; it is never a registered/live site path.
+}
+//# sourceMappingURL=verified-directory-move.js.map

package/dist/fs/verified-file-relocation.d.ts

@@ -0,0 +1,27 @@
+import fs from "node:fs";
+export interface VerifiedFileGroup {
+    from: string;
+    to: string;
+    sidecars: readonly string[];
+}
+/** Stage related files together while both directory identities are reserved by the host. Raw
+ * sources remain intact through inspection so even WAL/SHM bytes are retained. Verification opens only
+ * stopped databases through an injected read-only inspector; the filesystem owner never uses SQL.
+ * @complexity O(total bytes + verification cost), bounded memory via native file copies.
+ */
+export declare function stageVerifiedFileRelocation({ groups, verify }: {
+    groups: readonly VerifiedFileGroup[];
+    verify: (required: {
+        path: string;
+    }) => string;
+}, { filesystem, backupCovered, backupId }?: {
+    filesystem?: typeof fs;
+    backupCovered?: (required: {
+        from: string;
+    }) => boolean;
+    backupId?: () => string;
+}): {
+    rollback: () => void;
+    finalize: () => void;
+};
+//# sourceMappingURL=verified-file-relocation.d.ts.map

package/dist/fs/verified-file-relocation.js

@@ -0,0 +1,115 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+/** Stage related files together while both directory identities are reserved by the host. Raw
+ * sources remain intact through inspection so even WAL/SHM bytes are retained. Verification opens only
+ * stopped databases through an injected read-only inspector; the filesystem owner never uses SQL.
+ * @complexity O(total bytes + verification cost), bounded memory via native file copies.
+ */
+export function stageVerifiedFileRelocation({ groups, verify }, { filesystem = fs, backupCovered = () => false, backupId = randomUUID } = {}) {
+    const created = [], retired = [], markers = [], redundantBackups = [];
+    const backupSuffix = `.relocation-${backupId()}-backup`;
+    const copyExclusive = (from, to) => {
+        // Reserve before copying so a disk-full failure is still ours to clean up. COPYFILE_EXCL
+        // alone may create a partial file before throwing, which cannot be tracked after the fact.
+        const fd = filesystem.openSync(to, "wx");
+        created.push(to);
+        filesystem.closeSync(fd);
+        filesystem.copyFileSync(from, to);
+        const copied = filesystem.openSync(to, "r+");
+        try {
+            filesystem.fsyncSync(copied);
+        }
+        finally {
+            filesystem.closeSync(copied);
+        }
+        syncParent(to);
+    };
+    const syncParent = (file) => {
+        // Directory fsync persists retirement/marker ordering before the host commits its catalog.
+        const fd = filesystem.openSync(path.dirname(file), "r");
+        try {
+            filesystem.fsyncSync(fd);
+        }
+        finally {
+            filesystem.closeSync(fd);
+        }
+    };
+    const rollback = () => {
+        for (const item of [...retired].reverse()) {
+            filesystem.renameSync(item.backup, item.from);
+            syncParent(item.from);
+        }
+        for (const file of [...created].reverse()) {
+            filesystem.rmSync(file, { force: true });
+            syncParent(file);
+        }
+    };
+    try {
+        for (const group of groups) {
+            const pairs = ["", ...group.sidecars].filter((suffix) => filesystem.existsSync(group.from + suffix))
+                .map((suffix) => ({ from: group.from + suffix, to: group.to + suffix }));
+            for (const pair of pairs)
+                if (!filesystem.lstatSync(pair.from).isFile())
+                    throw new Error(`Database move requires a regular file: ${pair.from}`);
+            filesystem.mkdirSync(path.dirname(group.to), { recursive: true });
+            const moving = path.resolve(group.from) !== path.resolve(group.to);
+            // A directory rename already carries unchanged DB paths atomically; verify those bytes
+            // without copying them. For a file move the original inode becomes the sole backup after
+            // verification: another full destination backup doubles storage without rollback benefit.
+            // Cross-volume directory moves already retain the untouched original directory. A copied
+            // DB inside that destination needs no second full backup of the same bytes.
+            if (moving) {
+                const marker = group.from + ".home2-relocation.json";
+                const fd = filesystem.openSync(marker, "wx");
+                created.push(marker);
+                markers.push(marker);
+                try {
+                    filesystem.writeFileSync(fd, JSON.stringify({ to: group.to, backup: group.from + backupSuffix }));
+                    filesystem.fsyncSync(fd);
+                }
+                finally {
+                    filesystem.closeSync(fd);
+                }
+                syncParent(marker);
+            }
+            const before = verify({ path: group.from });
+            for (const pair of pairs) {
+                if (path.resolve(pair.from) === path.resolve(pair.to))
+                    continue;
+                // A destination collision aborts; never overwrite another site's data or an old move.
+                copyExclusive(pair.from, pair.to);
+            }
+            if (verify({ path: group.to }) !== before)
+                throw new Error(`Database row counts changed while moving ${path.basename(group.to)}.`);
+            // Retire old live names BEFORE commit. Finalization removes recovery markers and redundant copies covered by the retained original: a crash
+            // or cleanup failure cannot leave two independently writable database names after commit.
+            if (moving)
+                for (const pair of pairs) {
+                    const backup = pair.from + backupSuffix;
+                    if (filesystem.existsSync(backup))
+                        throw new Error(`Database backup target already exists: ${backup}`);
+                    filesystem.renameSync(pair.from, backup);
+                    retired.push({ from: pair.from, backup });
+                    if (backupCovered({ from: pair.from }))
+                        redundantBackups.push(backup);
+                    syncParent(pair.from);
+                }
+        }
+    }
+    catch (error) {
+        rollback();
+        throw error;
+    }
+    return { rollback, finalize: () => {
+            for (const backup of redundantBackups) {
+                filesystem.rmSync(backup);
+                syncParent(backup);
+            }
+            for (const marker of markers) {
+                filesystem.rmSync(marker);
+                syncParent(marker);
+            }
+        } };
+}
+//# sourceMappingURL=verified-file-relocation.js.map

package/dist/fs/workspace-directory.d.ts

@@ -0,0 +1,19 @@
+import type { DirectoryRecord } from "./directory-registry.js";
+/** Shared selection policy for CLI/dev hosts. A registry ID disambiguates adopted paths;
+ * a basename selects the home first. No initialized home site preserves the supplied fallback.
+ * @complexity O(n) registered/child directories and validation probes.
+ */
+export declare function selectWorkspaceDirectory({ home, entries, fallback, selected, roots, listDirectories, isInitialized }: {
+    home: string;
+    entries: readonly DirectoryRecord[];
+    fallback: string;
+    selected?: string | undefined;
+    roots?: readonly string[];
+    listDirectories: (required: {
+        root: string;
+    }) => readonly string[];
+    isInitialized: (required: {
+        path: string;
+    }) => boolean;
+}, _options?: {}): string;
+//# sourceMappingURL=workspace-directory.d.ts.map

package/dist/fs/workspace-directory.js

@@ -0,0 +1,23 @@
+import path from "node:path";
+/** Shared selection policy for CLI/dev hosts. A registry ID disambiguates adopted paths;
+ * a basename selects the home first. No initialized home site preserves the supplied fallback.
+ * @complexity O(n) registered/child directories and validation probes.
+ */
+export function selectWorkspaceDirectory({ home, entries, fallback, selected, roots = [home], listDirectories, isInitialized }, _options = {}) {
+    if (selected !== undefined) {
+        const byId = entries.find((entry) => entry.id === selected);
+        if (byId)
+            return byId.path;
+        const inHome = path.join(home, selected);
+        if (isInitialized({ path: inHome }))
+            return inHome;
+        const matches = [...new Set([...entries.filter((entry) => path.basename(entry.path) === selected).map((entry) => entry.path),
+                ...roots.filter((root) => root !== home).map((root) => path.join(root, selected)).filter((dir) => isInitialized({ path: dir }))])];
+        if (matches.length > 1)
+            throw new Error("More than one registered directory has this name. Select its registry ID.");
+        return matches[0] ?? path.join(path.dirname(fallback), selected);
+    }
+    const candidates = [...entries.filter((entry) => path.dirname(entry.path) === home).sort((a, b) => (b.lastOpened ? Date.parse(b.lastOpened) : 0) - (a.lastOpened ? Date.parse(a.lastOpened) : 0)).map((entry) => entry.path), ...roots.flatMap((root) => listDirectories({ root }))];
+    return candidates.find((dir) => isInitialized({ path: dir })) ?? fallback;
+}
+//# sourceMappingURL=workspace-directory.js.map

package/dist/http/guarded/transport.fetch.d.ts

@@ -1,8 +1,20 @@
+import { type ClientRequest, type IncomingMessage } from "node:http";
+import { type RequestOptions } from "node:https";
 import type { HttpRequest, HttpResponse } from "@jini-ai/core/primitives";
 import type { PinnedPeer } from "./types.js";
 import type { HttpTransportAdapter } from "./ports.js";
+/** Native request effect port; peer pinning and TLS options remain owned by this adapter. */
+export interface NativeHttpTransportOptions {
+    /** Like node:http, invoke onResponse asynchronously, after returning the request handle. */
+    request?: (input: {
+        secure: boolean;
+        options: RequestOptions;
+        onResponse: (response: IncomingMessage) => void;
+    }, optional?: Record<string, never>) => ClientRequest;
+}
 export declare class FetchHttpTransportAdapter implements HttpTransportAdapter {
-    constructor(_required: Record<string, never>);
+    private readonly optional;
+    constructor(_required: Record<string, never>, optional?: NativeHttpTransportOptions);
     requestPinned({ request: req, peer }: {
         request: HttpRequest;
         peer: PinnedPeer;

package/dist/http/guarded/transport.fetch.js

@@ -11,7 +11,10 @@ import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
 /** Last-resort decoded-byte bound independent of any caller's response policy. */
 const ABSOLUTE_MAX_BYTES = 100 * 1024 * 1024;
 export class FetchHttpTransportAdapter {
-    constructor(_required) { }
+    optional;
+    constructor(_required, optional = {}) {
+        this.optional = optional;
+    }
     async requestPinned({ request: req, peer }) {
         const url = new URL(req.url);
         const isHttps = url.protocol === "https:";
@@ -31,7 +34,7 @@ export class FetchHttpTransportAdapter {
             ...(isHttps && peer.tlsServerName ? { servername: peer.tlsServerName } : {}),
         };
         return new Promise((resolve, reject) => {
-            const clientRequest = requestFn(options, (res) => {
+            const onResponse = (res) => {
                 // HEAD can advertise GET's compression but has no body to decompress.
                 const decoded = req.method === "HEAD" ? res : decodeBody(res.headers["content-encoding"], res);
                 const chunks = [];
@@ -74,7 +77,10 @@ export class FetchHttpTransportAdapter {
                 });
                 decoded.on("end", () => finish(false));
                 decoded.on("error", reject);
-            });
+            };
+            const clientRequest = this.optional.request
+                ? this.optional.request({ secure: isHttps, options, onResponse }, {})
+                : requestFn(options, onResponse);
             clientRequest.on("timeout", () => {
                 clientRequest.destroy(new Error(`request timed out after ${idleTimeoutMs}ms`));
             });

package/dist/index.d.ts

@@ -10,7 +10,7 @@
  * - `fs`         — filesystem containment, atomic copy, removal, log tails.
  * - `http`       — HTTP readiness polling.
  * - `fetch-with-timeout` — the shared `AbortSignal`-timeout wrapper every outbound `fetch()` call
- *   in this monorepo is meant to go through (2026-08-16 failure-mode audit, Finding 2).
+ *   in this monorepo is meant to go through.
  * - `toolchain`  — user-level toolchain bin discovery.
  * - `asset-cache` — SSRF-safe same-origin cache/proxy for sandboxed content's
  *   external media references.
@@ -26,62 +26,14 @@
  * - `blob-storage` — a backend-agnostic blob storage port + local-disk and
  *   S3-compatible implementations.
  *
- * The set of names exported here is intentionally identical to the pre-split
- * public surface; importers see no change.
 
- * Archived provenance rationale:
- * ## Design decision: `project-storage.ts` was split, not ported wholesale or dropped
- *
- * The task brief asked to verify the recon's "leans OD" flag on
- * `project-storage.ts` firsthand and either drop it or extract a generic core
- * with OD's project-specific parts as an adapter, "depending on what you
- * actually find." Read in full: the `ProjectStorage` interface,
- * `LocalProjectStorage`, and `S3ProjectStorage` classes carry no OD nouns in
- * their own logic — they're a backend-agnostic blob CRUD port (read/write/
- * list/delete/stat under a scoping key) plus a local-disk and an
- * S3-compatible implementation, both traversal-guarded. The **only** OD
- * coupling in the file is the bottom `resolveProjectStorage()` factory
- * function, which reads `OD_PROJECT_STORAGE`/`OD_S3_BUCKET`/`OD_S3_REGION`/
- * `OD_S3_PREFIX`/`OD_S3_ENDPOINT`/`OD_S3_ACCESS_KEY_ID`/
- * `OD_S3_SECRET_ACCESS_KEY`/`OD_S3_SESSION_TOKEN` directly from `process.env`.
- *
- * **Extracted, not dropped:** the interface + both implementations, ported to
- * `src/blob-storage.ts` as `BlobStorage`/`BlobFileMeta`/`LocalBlobStorage`/
- * `S3BlobStorage`/`S3BlobStorageOptions`/`StorageError`, with every
- * `projectId: string` parameter renamed to `namespace: string` — per
- * extraction-plan.md's Task-4 Port-2 finding ("OD's 'project' is a product
- * model; engine needs a generic workspace/session store interface") and §2.1's
- * "Runs key on an opaque `contextRef`, never `projectId`" convention, "project"
- * specifically is flagged elsewhere in this porting effort as OD's noun, not
- * the engine's — `namespace` carries no domain meaning here beyond "a
- * top-level grouping/scoping key," which is what the parameter actually is
- * structurally (nothing in `LocalBlobStorage`/`S3BlobStorage`'s logic assumes
- * it means a design project).
- *
- * **Dropped, not ported:** `resolveProjectStorage()`. This is OD adapter
- * wiring — a specific env-var-naming convention and the choice to read
- * `process.env` directly inside the engine layer — not generic engine
- * behavior. It has no equivalent anywhere else in this porting session's
- * established pattern (`createSqliteEventLog`, `LocalBlobStorage`,
- * `S3BlobStorage` are all called with explicit constructor arguments; none of
- * `@jini/*`'s existing adapters read `process.env` inside their own
- * constructors). A Jini host application composes its own equivalent
- * (`new LocalBlobStorage(root)` or `new S3BlobStorage({ bucket, region,
- * credentials, ... })` called directly, with whatever env-var convention that
- * host prefers) rather than inheriting OD's `OD_S3_*` names or its
- * env-selection shape.
- *
- * Landed in `@jini/platform`, not `@jini/sqlite`: this is a filesystem/network
- * blob-storage primitive with no SQL involvement, parallel to this package's
- * existing `fs.ts` (path containment / atomic copy) and `http.ts` (readiness
- * polling) roles — `@jini/sqlite` is reserved for the `EventLog` port adapter
- * and `better-sqlite3`-specific helpers (`db-inspect.ts`,
- * `backend-config.ts`), none of which this needs. `aws-sigv4.ts` lives
- * alongside it in the same package since it's `S3BlobStorage`'s only
- * dependency and has no other consumer yet.
+ * Blob storage uses opaque namespace scoping rather than a product's project model. Hosts supply
+ * configuration/credentials explicitly instead of inheriting product-prefixed environment names.
+ * Filesystem/network storage and its SigV4 signing belong here, with no kernel SQL-port dependency.
  */
 export type { CommandInvocation, CommandInvocationRequest } from "./command.js";
 export { createCommandInvocation, createPackageManagerInvocation } from "./command.js";
+export { omitEnvironmentKeys } from "./child-environment.js";
 export type { ResolveSystemProxyEnvOptions, SystemProxyCommandRunner } from "./proxy-env.js";
 export { mergeProxyAwareEnv, parseMacosScutilProxyOutput, parseWindowsInternetSettingsProxyOutput, resolveSystemProxyEnv, } from "./proxy-env.js";
 export type { ProcessSnapshot, ProcessStampContract, ProcessStampField, ProcessStampShape, SpawnProcessRequest, StampedProcessMatchCriteria, StopProcessesResult, } from "./process.js";
@@ -97,7 +49,7 @@ export { wellKnownUserToolchainBins } from "./toolchain.js";
 export type { BufferedCommandResult } from "./shell.js";
 export { execCommandViaLoginShell, execFileBuffered } from "./shell.js";
 export type { AssetCache, AssetCacheOptions, AssetCacheResult } from "./asset-cache.js";
-export { AssetCacheError, assertSafePublicUrl, assetCacheKey, assetCacheRewriteUrl, createAssetCache, createValidatingLookup, isCacheableExternalUrl, } from "./asset-cache.js";
+export { AssetCacheError, assertSafePublicUrl, assetCacheKey, assetCacheRewriteUrl, createAssetCache, createAssetCacheDispatcher, createValidatingLookup, isCacheableExternalUrl, } from "./asset-cache.js";
 export { expandHomePrefix, resolveProjectRelativePath } from "./home-expansion.js";
 export type { SandboxEnvConfig, SandboxRuntimeConfig, SandboxRuntimeRoots } from "./sandbox-env.js";
 export { applySandboxRuntimeEnv, ensureSandboxRuntimeDirs, isSandboxImportedProjectRootAllowed, isSandboxModeEnabled, resolveSandboxRuntimeConfig, resolveSandboxRuntimeConfigFromEnv, sandboxAgentProfilesConfigPath, sandboxImportAllowedRoots, sandboxImportedProjectRootUnavailableReason, } from "./sandbox-env.js";

package/dist/index.js

@@ -10,7 +10,7 @@
  * - `fs`         — filesystem containment, atomic copy, removal, log tails.
  * - `http`       — HTTP readiness polling.
  * - `fetch-with-timeout` — the shared `AbortSignal`-timeout wrapper every outbound `fetch()` call
- *   in this monorepo is meant to go through (2026-08-16 failure-mode audit, Finding 2).
+ *   in this monorepo is meant to go through.
  * - `toolchain`  — user-level toolchain bin discovery.
  * - `asset-cache` — SSRF-safe same-origin cache/proxy for sandboxed content's
  *   external media references.
@@ -26,61 +26,13 @@
  * - `blob-storage` — a backend-agnostic blob storage port + local-disk and
  *   S3-compatible implementations.
  *
- * The set of names exported here is intentionally identical to the pre-split
- * public surface; importers see no change.
 
- * Archived provenance rationale:
- * ## Design decision: `project-storage.ts` was split, not ported wholesale or dropped
- *
- * The task brief asked to verify the recon's "leans OD" flag on
- * `project-storage.ts` firsthand and either drop it or extract a generic core
- * with OD's project-specific parts as an adapter, "depending on what you
- * actually find." Read in full: the `ProjectStorage` interface,
- * `LocalProjectStorage`, and `S3ProjectStorage` classes carry no OD nouns in
- * their own logic — they're a backend-agnostic blob CRUD port (read/write/
- * list/delete/stat under a scoping key) plus a local-disk and an
- * S3-compatible implementation, both traversal-guarded. The **only** OD
- * coupling in the file is the bottom `resolveProjectStorage()` factory
- * function, which reads `OD_PROJECT_STORAGE`/`OD_S3_BUCKET`/`OD_S3_REGION`/
- * `OD_S3_PREFIX`/`OD_S3_ENDPOINT`/`OD_S3_ACCESS_KEY_ID`/
- * `OD_S3_SECRET_ACCESS_KEY`/`OD_S3_SESSION_TOKEN` directly from `process.env`.
- *
- * **Extracted, not dropped:** the interface + both implementations, ported to
- * `src/blob-storage.ts` as `BlobStorage`/`BlobFileMeta`/`LocalBlobStorage`/
- * `S3BlobStorage`/`S3BlobStorageOptions`/`StorageError`, with every
- * `projectId: string` parameter renamed to `namespace: string` — per
- * extraction-plan.md's Task-4 Port-2 finding ("OD's 'project' is a product
- * model; engine needs a generic workspace/session store interface") and §2.1's
- * "Runs key on an opaque `contextRef`, never `projectId`" convention, "project"
- * specifically is flagged elsewhere in this porting effort as OD's noun, not
- * the engine's — `namespace` carries no domain meaning here beyond "a
- * top-level grouping/scoping key," which is what the parameter actually is
- * structurally (nothing in `LocalBlobStorage`/`S3BlobStorage`'s logic assumes
- * it means a design project).
- *
- * **Dropped, not ported:** `resolveProjectStorage()`. This is OD adapter
- * wiring — a specific env-var-naming convention and the choice to read
- * `process.env` directly inside the engine layer — not generic engine
- * behavior. It has no equivalent anywhere else in this porting session's
- * established pattern (`createSqliteEventLog`, `LocalBlobStorage`,
- * `S3BlobStorage` are all called with explicit constructor arguments; none of
- * `@jini/*`'s existing adapters read `process.env` inside their own
- * constructors). A Jini host application composes its own equivalent
- * (`new LocalBlobStorage(root)` or `new S3BlobStorage({ bucket, region,
- * credentials, ... })` called directly, with whatever env-var convention that
- * host prefers) rather than inheriting OD's `OD_S3_*` names or its
- * env-selection shape.
- *
- * Landed in `@jini/platform`, not `@jini/sqlite`: this is a filesystem/network
- * blob-storage primitive with no SQL involvement, parallel to this package's
- * existing `fs.ts` (path containment / atomic copy) and `http.ts` (readiness
- * polling) roles — `@jini/sqlite` is reserved for the `EventLog` port adapter
- * and `better-sqlite3`-specific helpers (`db-inspect.ts`,
- * `backend-config.ts`), none of which this needs. `aws-sigv4.ts` lives
- * alongside it in the same package since it's `S3BlobStorage`'s only
- * dependency and has no other consumer yet.
+ * Blob storage uses opaque namespace scoping rather than a product's project model. Hosts supply
+ * configuration/credentials explicitly instead of inheriting product-prefixed environment names.
+ * Filesystem/network storage and its SigV4 signing belong here, with no kernel SQL-port dependency.
  */
 export { createCommandInvocation, createPackageManagerInvocation } from "./command.js";
+export { omitEnvironmentKeys } from "./child-environment.js";
 export { mergeProxyAwareEnv, parseMacosScutilProxyOutput, parseWindowsInternetSettingsProxyOutput, resolveSystemProxyEnv, } from "./proxy-env.js";
 export { collectProcessTreePids, createProcessStampArgs, isProcessAlive, listProcessSnapshots, matchesProcessStamp, matchesStampedProcess, readFlagValue, readProcessStamp, readProcessStampFromCommand, spawnBackgroundProcess, spawnLoggedProcess, stopProcesses, waitForProcessExit, } from "./process.js";
 export { atomicCopyFile, pathContains, readLogTail, removePathBestEffort } from "./fs.js";
@@ -88,7 +40,7 @@ export { waitForHttpOk } from "./http.js";
 export { FETCH_TIMEOUT_MS, FetchTimeoutError, fetchWithTimeout } from "./fetch-with-timeout.js";
 export { wellKnownUserToolchainBins } from "./toolchain.js";
 export { execCommandViaLoginShell, execFileBuffered } from "./shell.js";
-export { AssetCacheError, assertSafePublicUrl, assetCacheKey, assetCacheRewriteUrl, createAssetCache, createValidatingLookup, isCacheableExternalUrl, } from "./asset-cache.js";
+export { AssetCacheError, assertSafePublicUrl, assetCacheKey, assetCacheRewriteUrl, createAssetCache, createAssetCacheDispatcher, createValidatingLookup, isCacheableExternalUrl, } from "./asset-cache.js";
 export { expandHomePrefix, resolveProjectRelativePath } from "./home-expansion.js";
 export { applySandboxRuntimeEnv, ensureSandboxRuntimeDirs, isSandboxImportedProjectRootAllowed, isSandboxModeEnabled, resolveSandboxRuntimeConfig, resolveSandboxRuntimeConfigFromEnv, sandboxAgentProfilesConfigPath, sandboxImportAllowedRoots, sandboxImportedProjectRootUnavailableReason, } from "./sandbox-env.js";
 export { resolveDaemonCliPath, resolveDaemonPluginPreviewsDir, resolveDaemonResourceDir, resolveDaemonResourceRoot, resolveDataDir, resolveProcessResourcesPath, } from "./resource-paths.js";

package/dist/net/address.d.ts

@@ -23,14 +23,7 @@ export declare function expandIpv6({ address: addr }: {
 export declare function isPrivateAddress({ address: addr }: {
     address: string;
 }): boolean;
-/** True for `localhost`, `::1`, `127.0.0.0/8`, and their IPv4-mapped-IPv6 forms. */
-export declare function isLoopbackApiHost({ hostname }: {
-    hostname: string;
-}): boolean;
-/** True for RFC1918/link-local/CGNAT/multicast/unspecified/unique-local-IPv6 addresses — private network space a public caller should never be steered into. */
-export declare function isBlockedExternalApiHostname({ hostname }: {
-    hostname: string;
-}): boolean;
+export { isLoopbackApiHost, isBlockedExternalApiHostname } from './endpoint-policy.js';
 /** True when `hostname` is `localhost`, an IPv6 loopback literal, or a `127.0.0.0/8` IPv4 literal. */
 export declare function isLoopbackHostname({ hostname }: {
     readonly hostname: unknown;