@jini-ai/platform 0.6.15-rc.2 → 0.6.16

package/dist/fs/user-data-directories.js

@@ -1,6 +1,8 @@
 import path from "node:path";
 import fs from "node:fs";
 import { execFileSync } from "node:child_process";
+import { windowsSystemTool } from "../windows-system-tools.js";
+import { fallbackIfMissing } from "./errno.js";
 /** Electron-free OS directory rules. Windows uses roaming app-data and the redirected Personal
  * known folder; Linux honors XDG user-dirs. No directories are created by this resolver.
  * env-paths is intentionally not used: its Windows data directory is LocalAppData/<app>/Data.
@@ -43,21 +45,17 @@ export function readOptionalText({ file }, _options = {}) {
         return fs.readFileSync(file, "utf8");
     }
     catch (error) {
-        if (error.code === "ENOENT")
-            return undefined;
-        throw error;
+        return fallbackIfMissing(error, undefined);
     }
 }
 function readWindowsDocuments() {
-    // eslint-disable-next-line sonarjs/no-os-command-from-path -- Fixed Windows registry utility/argv intentionally uses the desktop operator's trusted PATH, not request input.
-    const output = execFileSync("reg.exe", ["query", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders", "/v", "Personal"], { encoding: "utf8", timeout: 3000, windowsHide: true });
+    const output = execFileSync(windowsSystemTool({ relativePath: ["reg.exe"] }), ["query", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders", "/v", "Personal"], { encoding: "utf8", timeout: 3000, windowsHide: true });
     return /Personal\s+REG_(?:EXPAND_)?SZ\s+(.+)/.exec(output)?.[1]?.trim();
 }
 /** OneDrive publishes account mount paths in HKCU; absent accounts are a normal empty result. */
 export function readWindowsOneDriveRoots(_required, _options = {}) {
     try {
-        // eslint-disable-next-line sonarjs/no-os-command-from-path -- Fixed Windows registry utility/argv intentionally uses the desktop operator's trusted PATH, not request input.
-        const output = execFileSync("reg.exe", ["query", "HKCU\\Software\\Microsoft\\OneDrive\\Accounts", "/s", "/v", "UserFolder"], { encoding: "utf8", timeout: 3000, windowsHide: true });
+        const output = execFileSync(windowsSystemTool({ relativePath: ["reg.exe"] }), ["query", "HKCU\\Software\\Microsoft\\OneDrive\\Accounts", "/s", "/v", "UserFolder"], { encoding: "utf8", timeout: 3000, windowsHide: true });
         return [...output.matchAll(/UserFolder\s+REG_(?:EXPAND_)?SZ\s+([^\r\n]+)/g)].map((match) => match[1].trim());
     }
     catch (error) {

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

@@ -1,6 +1,8 @@
 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.
+ * Hosts may probe availability to resolve an ambiguous name to its sole available directory.
+ * Offline records and explicit ID selection are preserved; probe failures propagate.
  * @complexity O(n) registered/child directories and validation probes.
  */
 export declare function selectWorkspaceDirectory({ home, entries, fallback, selected, roots, listDirectories, isInitialized }: {
@@ -15,5 +17,9 @@ export declare function selectWorkspaceDirectory({ home, entries, fallback, sele
     isInitialized: (required: {
         path: string;
     }) => boolean;
-}, _options?: {}): string;
+}, { isAvailable }?: {
+    isAvailable?: (required: {
+        path: string;
+    }) => boolean;
+}): string;
 //# sourceMappingURL=workspace-directory.d.ts.map

package/dist/fs/workspace-directory.js

@@ -1,9 +1,11 @@
 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.
+ * Hosts may probe availability to resolve an ambiguous name to its sole available directory.
+ * Offline records and explicit ID selection are preserved; probe failures propagate.
  * @complexity O(n) registered/child directories and validation probes.
  */
-export function selectWorkspaceDirectory({ home, entries, fallback, selected, roots = [home], listDirectories, isInitialized }, _options = {}) {
+export function selectWorkspaceDirectory({ home, entries, fallback, selected, roots = [home], listDirectories, isInitialized }, { isAvailable } = {}) {
     if (selected !== undefined) {
         const byId = entries.find((entry) => entry.id === selected);
         if (byId)
@@ -13,8 +15,13 @@ export function selectWorkspaceDirectory({ home, entries, fallback, selected, ro
             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)
+        if (matches.length > 1) {
+            // A stale scratch catalog row must not block the sole live site or choose by row order.
+            const available = matches.filter(dir => isAvailable?.({ path: dir }) ?? true);
+            if (available.length === 1)
+                return available[0];
             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 }))];

package/dist/fs.js

@@ -8,6 +8,7 @@
  * Keeps private `errorCode` / `errorMessage` copies so it owns no cross-module
  * runtime surface.
  */
+import { randomUUID } from "node:crypto";
 import { copyFile, mkdir, readFile, rename, rm, stat } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 /** @internal Extract a Node `error.code` as a string, or `null` when the value carries no code. */
@@ -72,7 +73,7 @@ export async function atomicCopyFile(sourcePath, destinationPath, options = {})
     if (existing != null && options.overwrite !== true) {
         throw destinationExistsError(destination);
     }
-    const tempPath = join(destinationDir, `.${basename(destination)}.${process.pid}.${Date.now().toString(36)}.${Math.random().toString(36).slice(2)}.tmp`);
+    const tempPath = join(destinationDir, `.${basename(destination)}.${process.pid}.${Date.now().toString(36)}.${randomUUID()}.tmp`);
     try {
         await copyFile(source, tempPath);
         // Rename replaces the old file atomically. Removing it first opens a

package/dist/http/guarded/client.js

@@ -1,6 +1,7 @@
 // Policy refusals use EgressRefusedError; DNS, connection and transport failures retain their
 // own errors because they are operational failures, not decisions that a different URL fixes.
 import { classifyIpAddress } from "../../net/address.js";
+import { effectivePort } from "../../core/effective-port.js";
 import { FetchTimeoutError } from "../../fetch-with-timeout.js";
 import { isIP } from "node:net";
 import { EgressRefusedError } from "./errors.js";
@@ -55,7 +56,7 @@ function assertNoPrivateAddress(hostname, addresses) {
 }
 async function resolvePinnedPeer(url, policy, dns) {
     assertAllowedTarget(url, policy);
-    const port = url.port ? Number(url.port) : url.protocol === "https:" ? 443 : 80;
+    const port = effectivePort({ url });
     const hostname = stripIpv6Brackets(url.hostname);
     const isDevAllowlisted = policy.devHostAllowlist.includes(hostname);
     const addresses = await resolveHostAddresses(url.hostname, dns);

package/dist/http.js

@@ -43,6 +43,7 @@ export async function waitForHttpOk(url, { timeoutMs = 20000 } = {}) {
         }
         await sleep(150);
     }
-    throw new Error(`timed out waiting for ${url}${lastError ? ` (${lastError.message})` : ""}`);
+    const detail = lastError ? ` (${lastError.message})` : "";
+    throw new Error(`timed out waiting for ${url}${detail}`);
 }
 //# sourceMappingURL=http.js.map

package/dist/index.d.ts

@@ -43,7 +43,7 @@ export { atomicCopyFile, pathContains, readLogTail, removePathBestEffort } from
 export type { HttpWaitOptions } from "./http.js";
 export { waitForHttpOk } from "./http.js";
 export type { DeadlineSignalOptions, FetchWithTimeoutOptions } from "./fetch-with-timeout.js";
-export { FETCH_TIMEOUT_MS, FetchTimeoutError, createDeadlineSignal, fetchWithTimeout } from "./fetch-with-timeout.js";
+export { FETCH_TIMEOUT_MS, FetchTimeoutError, ResponseLimitExceededError, createDeadlineSignal, fetchWithTimeout } from "./fetch-with-timeout.js";
 export type { WellKnownUserToolchainOptions } from "./toolchain.js";
 export { wellKnownUserToolchainBins } from "./toolchain.js";
 export type { BufferedCommandResult } from "./shell.js";

package/dist/index.js

@@ -37,7 +37,7 @@ export { mergeProxyAwareEnv, parseMacosScutilProxyOutput, parseWindowsInternetSe
 export { collectProcessTreePids, createProcessStampArgs, isProcessAlive, listProcessSnapshots, listProcessUsage, matchesProcessStamp, matchesStampedProcess, readFlagValue, readProcessStamp, readProcessStampFromCommand, spawnBackgroundProcess, spawnLoggedProcess, stopProcesses, waitForProcessExit, } from "./process.js";
 export { atomicCopyFile, pathContains, readLogTail, removePathBestEffort } from "./fs.js";
 export { waitForHttpOk } from "./http.js";
-export { FETCH_TIMEOUT_MS, FetchTimeoutError, createDeadlineSignal, fetchWithTimeout } from "./fetch-with-timeout.js";
+export { FETCH_TIMEOUT_MS, FetchTimeoutError, ResponseLimitExceededError, createDeadlineSignal, fetchWithTimeout } from "./fetch-with-timeout.js";
 export { wellKnownUserToolchainBins } from "./toolchain.js";
 export { execCommandViaLoginShell, execFileBuffered } from "./shell.js";
 export { AssetCacheError, assertSafePublicUrl, assetCacheKey, assetCacheRewriteUrl, createAssetCache, createAssetCacheDispatcher, createValidatingLookup, isCacheableExternalUrl, } from "./asset-cache.js";

package/dist/mail/builtin-providers.js

@@ -6,6 +6,7 @@
  * `hosted: false`, so it can never make a site look configured.
  */
 import { nowIso } from "@jini-ai/core/primitives";
+import { effectivePort } from "../core/effective-port.js";
 import { SmtpMailerAdapter } from "./smtp.js";
 /**
  * SMTP endpoint packed into a credential `baseUrl` (`https://host:port`); 443/465 = implicit TLS.
@@ -13,7 +14,7 @@ import { SmtpMailerAdapter } from "./smtp.js";
  */
 export function parseSmtpEndpoint({ baseUrl }) {
     const url = new URL(baseUrl);
-    const port = url.port ? Number(url.port) : url.protocol === "https:" ? 443 : 80;
+    const port = effectivePort({ url });
     return { host: url.hostname, port, secure: port === 443 || port === 465 };
 }
 export function createSmtpMailProvider(required) {
@@ -39,7 +40,8 @@ export function createConsoleMailProvider(required, optional = {}) {
             // The body is the point of a local mailer: a sign-in or confirmation link must be usable from the
             // log, since nothing is delivered. Text is preferred (readable); an html-only message shows its html.
             const body = message.text ?? message.html;
-            log(`[mail:console] to=${message.to.email} subject=${JSON.stringify(message.subject)}${body === undefined ? "" : `\n${body}`}`);
+            const bodySuffix = body === undefined ? "" : `\n${body}`;
+            log(`[mail:console] to=${message.to.email} subject=${JSON.stringify(message.subject)}${bodySuffix}`);
             return { ok: true, providerMessageId: `console-${counter}`, acceptedAt: nowIso({ clock: required.clock }) };
         },
         async sendBatch({ messages, ...delivery }) {

package/dist/mail/feedback.js

@@ -37,7 +37,7 @@ export function createMailFeedbackIngest(required, optional = {}) {
     const apply = async (input) => {
         const outcome = await required.inbox.record(input);
         if (outcome === "duplicate")
-            return outcome;
+            return "duplicate";
         const scope = suppressionScopeFor({ event: input.event });
         if (scope !== null) {
             const reason = input.event.kind === "complained" ? "complained" : "bounced";

package/dist/mail/prepare-sender-email.js

@@ -54,7 +54,7 @@ export async function prepareSenderEmail(required, _optional = {}) {
     validateEmailSourceTemplate({ fields: source.fields, template });
     const resolved = await sender.resolveEvent({ ...context, eventId });
     // MOVE: Compare against the latest activation so re-enabling cannot revive a backlog.
-    if (!binding.activatedAt || !(Date.parse(resolved.occurredAt) >= Date.parse(binding.activatedAt)))
+    if (!occurredSinceActivation({ occurredAt: resolved.occurredAt, activatedAt: binding.activatedAt }))
         throw new EmailSenderError({ code: "configuration" });
     const to = recipientAddress({ source, resolved, recipientId: binding.recipientId });
     const { values, warnings } = templateValues({ fields: source.fields, tokens: template.fields, values: resolved.values });
@@ -65,4 +65,10 @@ export async function prepareSenderEmail(required, _optional = {}) {
         replyTo: { email: binding.replyTo }, subject: rendered.subject, html: rendered.html, text: rendered.text,
         purpose: source.purpose, lane: source.lane, warnings };
 }
+/** True only for an event at or after the binding's activation; an unparsable time is never current. */
+function occurredSinceActivation({ occurredAt, activatedAt }) {
+    if (!activatedAt)
+        return false;
+    return Date.parse(occurredAt) >= Date.parse(activatedAt);
+}
 //# sourceMappingURL=prepare-sender-email.js.map

package/dist/mail/provider.js

@@ -64,14 +64,20 @@ function laneStatus(required) {
 export function computeMailStatus(required, optional = {}) {
     const { setting, registry, hasCredential } = required;
     const lanes = ["transactional", "bulk"].map((lane) => laneStatus({ lane, providerId: setting[lane], registry, hasCredential }));
-    const warnings = [];
-    const domain = optional.senderDomainState;
+    const senderWarning = senderDomainWarning(optional.senderDomainState);
+    const warnings = senderWarning === undefined ? [] : [senderWarning];
+    return { state: overallMailState(lanes), lanes, warnings };
+}
+function senderDomainWarning(domain) {
     if (domain === null)
-        warnings.push("sender_unknown");
-    else if (domain !== undefined && domain !== "verified")
-        warnings.push("sender_unverified");
-    const ready = lanes.filter((status) => status.state === "ready").length;
-    const state = ready === lanes.length ? "ready" : lanes[0].state === "unconfigured" ? "unconfigured" : "degraded";
-    return { state, lanes, warnings };
+        return "sender_unknown";
+    if (domain === undefined || domain === "verified")
+        return undefined;
+    return "sender_unverified";
+}
+function overallMailState(lanes) {
+    if (lanes.every((status) => status.state === "ready"))
+        return "ready";
+    return lanes[0].state === "unconfigured" ? "unconfigured" : "degraded";
 }
 //# sourceMappingURL=provider.js.map

package/dist/mail/rate-limit.js

@@ -7,7 +7,9 @@
  */
 export function createMailLaneLimiter(required, optional = {}) {
     const { perSecond, burst } = required.limit;
-    if (!(perSecond > 0) || !(burst >= 1))
+    // Positive comparisons on purpose: NaN fails both and is rejected.
+    const validLimit = perSecond > 0 && burst >= 1;
+    if (!validLimit)
         throw new RangeError("mail rate limit needs perSecond > 0 and burst >= 1");
     const now = optional.now ?? Date.now;
     // At least one token whenever burst > 1: 20% of a small burst (Resend's 2) floors to 0, which let

package/dist/messages.js

@@ -5,7 +5,7 @@ export const defaultPlatformMessages = {
     atomicSymlinkRefused: () => "atomic write refused a symbolic-link destination",
     atomicPermissionsRefused: () => "atomic write refused non-owner-only permissions",
     atomicJsonUnserializable: () => "atomic JSON data must be serializable",
-    fileLockIntervalsInvalid: () => "file lock intervals must be positive safe integers (timeout may be zero; stale may be Infinity)",
+    fileLockIntervalsInvalid: () => "file lock intervals must be positive safe integers (timeout may be zero or Infinity; stale may be Infinity)",
     fileLockWriteNoProgress: () => "file lock ownership write made no progress",
     egressRefused: () => "egress to the requested host was refused by the outbound network policy",
     rootKeySealedWarning: ({ subject }) => `IMPORTANT: anything sealed while ${subject} was in place was sealed under key material derived from these same bytes, `,

package/dist/net/endpoint-policy.js

@@ -13,7 +13,13 @@ function normalizeBracketedIpv6(hostname) {
     // form, so `localhost.` must normalize to `localhost` before the equality
     // check below — and `0.0.0.0.`, `10.0.0.1.`, etc. must normalize before
     // the IPv4 classifier parses them. Strips one or more trailing dots.
-    return stripped.toLowerCase().replace(/\.+$/, '');
+    // A scan rather than /\.+$/, which backtracks quadratically on long interior dot runs. This module
+    // stays import-free (see its contract test), so it does not use core's trimCharsEnd.
+    const lowered = stripped.toLowerCase();
+    let end = lowered.length;
+    while (end > 0 && lowered[end - 1] === '.')
+        end -= 1;
+    return lowered.slice(0, end);
 }
 function parseIpv4(hostname) {
     const parts = hostname.split('.');
@@ -71,7 +77,7 @@ export function expandIpv6({ address: addr }) {
         const fill = 8 - left.length - right.length;
         if (fill < 1)
             return null;
-        groups = [...left, ...new Array(fill).fill(0), ...right];
+        groups = [...left, ...Array.from({ length: fill }, () => 0), ...right];
     }
     if (!validIpv6Groups(groups))
         return null;
@@ -88,8 +94,8 @@ function foldIpv4Tail(s) {
         if (o.length !== 4 || o.some((n) => !Number.isInteger(n) || n < 0 || n > 255))
             return null;
         // `o` is now a validated 4-element array — indices 0-3 always defined.
-        const hi = (((o[0] << 8) | o[1])).toString(16);
-        const lo = (((o[2] << 8) | o[3])).toString(16);
+        const hi = ((o[0] << 8) | o[1]).toString(16);
+        const lo = ((o[2] << 8) | o[3]).toString(16);
         s = `${v4[1]}${hi}:${lo}`;
     }
     return s;
@@ -116,9 +122,11 @@ function classifyIpv4Bytes(bytes) {
 function isPrivateIpv4Bytes([a, b]) {
     if (a === 100)
         return b >= 64 && b <= 127;
-    return a === 10 ||
-        (a === 172 && b >= 16 && b <= 31) ||
-        (a === 192 && b === 168);
+    if (a === 172)
+        return b >= 16 && b <= 31;
+    if (a === 192)
+        return b === 168;
+    return a === 10;
 }
 // Each /96 prefix carries IPv4 in the final four bytes. Matching canonical
 // bytes also handles expanded IPv6 and WHATWG URL's dotted-to-hex normalization.

package/dist/net/index.d.ts

@@ -1,2 +1,3 @@
 export { isPrivateAddress, expandIpv6, isLoopbackApiHost, isBlockedExternalApiHostname, isLoopbackHostname } from "./address.js";
+export { probeLoopbackHttp } from './local-http-probe.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/net/index.js

@@ -1,2 +1,3 @@
 export { isPrivateAddress, expandIpv6, isLoopbackApiHost, isBlockedExternalApiHostname, isLoopbackHostname } from "./address.js";
+export { probeLoopbackHttp } from './local-http-probe.js';
 //# sourceMappingURL=index.js.map

package/dist/net/local-http-probe.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Probe a loopback service once, accepting only HTTP 200 without following redirects.
+ * @param required Absolute HTTP(S) URL. Non-loopback targets are refused before connecting.
+ * @param options Optional expected leaf PEM, TLS server name and request deadline (default 1500ms).
+ * @returns False for transport, TLS, timeout or non-200 failures; true for an authenticated 200.
+ * @throws For malformed URLs, certificate PEM or invalid timeout values (configuration errors).
+ * @complexity O(c) time/space for c certificate bytes; one bounded network request.
+ */
+export declare function probeLoopbackHttp({ url }: {
+    url: string;
+}, { certificate, servername, timeoutMs }?: {
+    certificate?: string | Buffer | undefined;
+    servername?: string | undefined;
+    timeoutMs?: number;
+}): Promise<boolean>;
+//# sourceMappingURL=local-http-probe.d.ts.map

package/dist/net/local-http-probe.js

@@ -0,0 +1,36 @@
+import { X509Certificate } from 'node:crypto';
+import { get as httpGet } from 'node:http';
+import { get as httpsGet } from 'node:https';
+import { isLoopbackHostname } from './address.js';
+/**
+ * Probe a loopback service once, accepting only HTTP 200 without following redirects.
+ * @param required Absolute HTTP(S) URL. Non-loopback targets are refused before connecting.
+ * @param options Optional expected leaf PEM, TLS server name and request deadline (default 1500ms).
+ * @returns False for transport, TLS, timeout or non-200 failures; true for an authenticated 200.
+ * @throws For malformed URLs, certificate PEM or invalid timeout values (configuration errors).
+ * @complexity O(c) time/space for c certificate bytes; one bounded network request.
+ */
+export function probeLoopbackHttp({ url }, { certificate, servername, timeoutMs = 1500 } = {}) {
+    const target = new URL(url);
+    if (!isLoopbackHostname({ hostname: target.hostname }))
+        return Promise.resolve(false);
+    if (target.protocol !== 'http:' && target.protocol !== 'https:')
+        return Promise.resolve(false);
+    const hostname = target.hostname.replace(/^\[|\]$/g, '').replace(/\.$/, '');
+    // Only the configured leaf is a trust anchor, never an issuer bundled after it.
+    // Partial-chain trust permits mkcert leaves without installing their CA into this Node process.
+    const trust = certificate === undefined ? {} : { ca: new X509Certificate(certificate).toString(), allowPartialTrustChain: true };
+    const options = {
+        agent: false, signal: AbortSignal.timeout(timeoutMs), rejectUnauthorized: true,
+        // Do not let a hosts-file/DNS override turn the localhost exception into remote trust.
+        hostname: hostname.replace(/^localhost$/, '127.0.0.1'),
+        servername: servername ?? (hostname === 'localhost' ? 'localhost' : undefined),
+        ...trust,
+    };
+    return new Promise(resolve => {
+        const receive = (response) => { response.resume(); resolve(response.statusCode === 200); };
+        const get = target.protocol === 'https:' ? httpsGet : httpGet;
+        get(target, options, receive).once('error', () => resolve(false));
+    });
+}
+//# sourceMappingURL=local-http-probe.js.map

package/dist/object-store/local-fs.js

@@ -29,7 +29,9 @@ function contained(required) {
     const { rootDir, key } = required;
     const path = join(rootDir, key);
     const rel = relative(resolve(rootDir), resolve(path));
-    if (key === '' || isAbsolute(key) || rel === '' || rel.startsWith('..') || isAbsolute(rel)) {
+    const invalidKey = key === '' || isAbsolute(key);
+    const escapesRoot = rel === '' || rel.startsWith('..') || isAbsolute(rel);
+    if (invalidKey || escapesRoot) {
         throw new Error(`object key '${key}' is outside the store root`);
     }
     return path;

package/dist/process.js

@@ -13,6 +13,8 @@
 import { execFile, spawn } from "node:child_process";
 import { posix, win32 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
+import { captureLineTail } from "@jini-ai/core/text";
+import { windowsPowerShell } from "./windows-system-tools.js";
 import { createCommandInvocation } from "./command.js";
 import { execFileBuffered } from "./shell.js";
 /** @internal Extract a Node `error.code` as a string, or `null` when the value carries no code. */
@@ -195,9 +197,7 @@ export function isProcessAlive(pid) {
         return true;
     }
     catch (error) {
-        if (errorCode(error) === "ESRCH")
-            return false;
-        return true;
+        return errorCode(error) !== "ESRCH";
     }
 }
 /**
@@ -221,10 +221,12 @@ function parsePsOutput(stdout) {
     return stdout
         .split(/\r?\n/)
         .map((line) => {
-        const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.+)$/);
-        if (!match)
+        // Same as /^\s*(\d+)\s+(\d+)\s+(.+)$/, split so the command tail cannot backtrack.
+        const match = /^\s*(\d+)\s+(\d+)/.exec(line);
+        const command = match ? captureLineTail({ rest: line.slice(match[0].length) }, { minWhitespace: 1 }) : null;
+        if (!match || command === null)
             return null;
-        return { pid: Number(match[1]), ppid: Number(match[2]), command: match[3] };
+        return { pid: Number(match[1]), ppid: Number(match[2]), command };
     })
         .filter((snapshot) => snapshot != null);
 }
@@ -248,8 +250,7 @@ async function listWindowsProcessSnapshots() {
         "Get-CimInstance Win32_Process | Select-Object ProcessId, ParentProcessId, CommandLine | ConvertTo-Json -Compress",
     ].join("; ");
     const stdout = await new Promise((resolveList, rejectList) => {
-        // eslint-disable-next-line sonarjs/no-os-command-from-path -- Fixed process-enumeration utility intentionally uses the trusted host PATH; command and argv are code-owned.
-        execFile("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", command], { encoding: "utf8", maxBuffer: 8 * 1024 * 1024 }, (error, out) => {
+        execFile(windowsPowerShell(), ["-NoProfile", "-NonInteractive", "-Command", command], { encoding: "utf8", maxBuffer: 8 * 1024 * 1024 }, (error, out) => {
             if (error)
                 rejectList(error);
             else
@@ -341,7 +342,7 @@ function parseCimUsage(stdout) {
 /** @internal Fixed executable and argv, invoked directly without a command shell. */
 function processUsageCommand(windows) {
     return windows
-        ? { command: "powershell.exe", args: ["-NoProfile", "-NonInteractive", "-Command",
+        ? { command: windowsPowerShell(), args: ["-NoProfile", "-NonInteractive", "-Command",
                 "$ErrorActionPreference = 'Stop'; Get-CimInstance Win32_Process | Select-Object ProcessId, ParentProcessId, WorkingSetSize, UserModeTime, KernelModeTime, Name | ConvertTo-Json -Compress"] }
         : { command: "ps", args: ["-axo", "pid=,ppid=,rss=,time=,comm="] };
 }

package/dist/proxy-env.js

@@ -11,6 +11,7 @@
  * proxy-config tools; owns no other sibling dependency.
  */
 import { execFileSync } from "node:child_process";
+import { captureLineTail } from "@jini-ai/core/text";
 const CANONICAL_PROXY_ENV_KEYS = new Map([
     ["all_proxy", "ALL_PROXY"],
     ["http_proxy", "HTTP_PROXY"],
@@ -78,18 +79,21 @@ function collectSourceProxyEntries(input) {
         if (value == null)
             continue;
         const canonicalKey = canonicalProxyEnvKey(key);
-        if (!canonicalKey) {
+        if (canonicalKey)
+            keepPreferredProxyEntry(proxyEntries, { canonicalKey, key, value });
+        else
             input.merged[key] = value;
-            continue;
-        }
-        const current = proxyEntries.get(canonicalKey);
-        const preferLowercase = key === key.toLowerCase();
-        if (!current || preferLowercase || !current.preferLowercase) {
-            proxyEntries.set(canonicalKey, { preferLowercase, value });
-        }
     }
     return proxyEntries;
 }
+/** @internal Record `key`'s value unless a lowercase spelling of the same variable already won. */
+function keepPreferredProxyEntry(proxyEntries, entry) {
+    const current = proxyEntries.get(entry.canonicalKey);
+    const preferLowercase = entry.key === entry.key.toLowerCase();
+    if (!current || preferLowercase || !current.preferLowercase) {
+        proxyEntries.set(entry.canonicalKey, { preferLowercase, value: entry.value });
+    }
+}
 /** @internal Whether `env` already contains any case-variant of the given canonical proxy key. */
 function hasCanonicalProxyEnv(env, canonicalKey) {
     return Object.keys(env).some((key) => key.toLowerCase() === canonicalKey.toLowerCase());
@@ -249,16 +253,20 @@ function parseScutilLines(stdout) {
 }
 /** @internal Record one `N : value` ExceptionsList entry; returns whether the array is still open (false on `}`). */
 function collectScutilException(line, exceptions) {
-    const match = line.match(/^\d+\s*:\s*(.+)$/);
-    if (match)
-        exceptions.push(match[1].trim());
+    // Same as /^\d+\s*:\s*(.+)$/, split so the value tail cannot backtrack.
+    const index = /^\d+\s*:/.exec(line);
+    const value = index ? captureLineTail({ rest: line.slice(index[0].length) }) : null;
+    if (value !== null)
+        exceptions.push(value.trim());
     return line !== "}";
 }
 /** @internal Record one top-level `Name : value` scutil scalar, ignoring lines of any other shape. */
 function collectScutilScalar(line, scalars) {
-    const match = line.match(/^([A-Za-z][A-Za-z0-9]*)\s*:\s*(.+)$/);
-    if (match)
-        scalars.set(match[1], match[2].trim());
+    // Same as /^([A-Za-z][A-Za-z0-9]*)\s*:\s*(.+)$/, split so the value tail cannot backtrack.
+    const name = /^([A-Za-z][A-Za-z0-9]*)\s*:/.exec(line);
+    const value = name ? captureLineTail({ rest: line.slice(name[0].length) }) : null;
+    if (name && value !== null)
+        scalars.set(name[1], value.trim());
 }
 /** @internal The `<prefix>Proxy`/`<prefix>Port` URL when `<prefix>Enable` is `1`, else `null`. */
 function scutilEnabledProxy(input) {

package/dist/secrets/credential-sets/index.d.ts

@@ -4,5 +4,6 @@ export { buildVaultAad } from "./vault.aad.js";
 export { createVaultMetaParsers, isCopyableKind } from "./vault.meta.js";
 export { SecretsVaultService, type VaultServiceDeps, type VaultPutInput, type VaultCopyInput } from "./vault.service.js";
 export { InMemoryVaultRepo } from "./vault.repo.memory.js";
+export { captureVaultArchive, prepareVaultArchiveRestore, type VaultArchiveEntry } from "./vault-archive.js";
 export { matchingCredentialProviderIds, selectCredentialForProvider, suggestCredentialWorksFor, normalizeCredentialWorksFor, type CredentialProviderDescriptor, type MatchableCredential } from "./provider-matches.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/secrets/credential-sets/index.js

@@ -3,5 +3,6 @@ export { buildVaultAad } from "./vault.aad.js";
 export { createVaultMetaParsers, isCopyableKind } from "./vault.meta.js";
 export { SecretsVaultService } from "./vault.service.js";
 export { InMemoryVaultRepo } from "./vault.repo.memory.js";
+export { captureVaultArchive, prepareVaultArchiveRestore } from "./vault-archive.js";
 export { matchingCredentialProviderIds, selectCredentialForProvider, suggestCredentialWorksFor, normalizeCredentialWorksFor } from "./provider-matches.js";
 //# sourceMappingURL=index.js.map

package/dist/secrets/credential-sets/provider-matches.js

@@ -23,15 +23,26 @@ export function normalizeCredentialWorksFor({ value }, _options = {}) {
  */
 export function matchingCredentialProviderIds({ credential, providers }, _options = {}) {
     const { credentialType, worksFor } = credential.meta;
-    if ((credential.kind !== "vendor" && credential.kind !== "custom") ||
-        (credential.kind === "custom" && credentialType !== "custom") || (credentialType !== "vendor" && credentialType !== "custom") ||
-        !Array.isArray(worksFor) || Array.from(worksFor).some(id => typeof id !== "string" || !id || id !== id.toLowerCase() || /\s/.test(id)))
+    if (!hasMatchableType({ kind: credential.kind, credentialType }) ||
+        !Array.isArray(worksFor) || !Array.from(worksFor).every(isCanonicalProviderId))
         return [];
     const ids = new Set(worksFor);
     return providers.filter(provider => (credentialType !== "custom" || provider.acceptsCustomToken) &&
         (ids.has(provider.id.toLowerCase()) || ids.has(provider.vendorId.toLowerCase())))
         .map(provider => provider.id);
 }
+/** vendor/custom rows only; a custom-kind row must also carry the custom subtype. */
+function hasMatchableType({ kind, credentialType }) {
+    if (kind !== "vendor" && kind !== "custom")
+        return false;
+    if (kind === "custom" && credentialType !== "custom")
+        return false;
+    return credentialType === "vendor" || credentialType === "custom";
+}
+/** A non-empty, already-lowercased ID without whitespace, as {@link normalizeCredentialWorksFor} stores it. */
+function isCanonicalProviderId(id) {
+    return typeof id === "string" && id !== "" && id === id.toLowerCase() && !/\s/.test(id);
+}
 /** Select an eligible explicit ID, the descriptor's provider-group default, or a sole candidate.
  * Missing IDs and unresolved ambiguity return null; custom-group defaults do not rank candidates.
  * @complexity O(credentials * average worksFor) time, O(credentials) candidate space.

package/dist/secrets/credential-sets/vault-archive.d.ts

@@ -0,0 +1,41 @@
+import type { SecretsVaultService } from "./vault.service.js";
+import { type VaultKind, type VaultMeta, type VaultOptions, type VaultPutRecord, type VaultQuery, type VaultRepoPort } from "./vault.types.js";
+/** Logical transport only: source workspace, root keys, envelopes and revision history never travel. */
+export interface VaultArchiveEntry {
+    id: string;
+    kind: VaultKind;
+    ownerKey: string;
+    binding: string | null;
+    provider: string | null;
+    label: string;
+    isDefault: boolean;
+    meta: VaultMeta;
+    payload: VaultMeta | null;
+}
+/** Capture through the owning service's authorization and parsers. Hosts supply exact scopes and
+ * attachment-filtered repositories; this helper never discovers other workspaces or principals.
+ * Diagnostics contain only a count, because even labels/IDs may contain pasted secrets.
+ * @example const captured = await captureVaultArchive({ vault, repo, queries: [siteScope] });
+ * @complexity O(rows + payload bytes), bounded to 2,000 rows by the transport contract.
+ */
+export declare function captureVaultArchive({ vault, queries, repo }: {
+    vault: SecretsVaultService;
+    queries: readonly VaultQuery[];
+    repo?: Pick<VaultRepoPort, "list">;
+}, _options?: VaultOptions): Promise<{
+    entries: VaultArchiveEntry[];
+    notices: string[];
+}>;
+/** Validate and re-seal every entry before the host atomically commits any of them. Keeping the
+ * transaction in the host lets settings and vault rows join the same commit. Never call put in a
+ * loop: a bad later entry must leave the recipient completely unchanged.
+ * @throws VaultError or the host's policy error; callers expose a fixed optional-import notice.
+ * @example const records = await prepareVaultArchiveRestore({ vault, workspaceId, entries });
+ * @complexity O(entries + payload bytes), at most 2,000 entries.
+ */
+export declare function prepareVaultArchiveRestore({ vault, workspaceId, entries }: {
+    vault: SecretsVaultService;
+    workspaceId: string;
+    entries: readonly VaultArchiveEntry[];
+}, _options?: VaultOptions): Promise<VaultPutRecord[]>;
+//# sourceMappingURL=vault-archive.d.ts.map