@jini-ai/platform 0.5.10 → 0.6.11

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @jini-ai/platform
 
+## 0.6.11
+
+### Patch Changes
+
+- Tool inputs apply a sole near-miss and declared input aliases; plugin-load outcomes are reported; `web_fetch` reads SVG/JS as text; `content_read` suggests its resource first; the browser falls back to system Chrome.
+- `./node` file-tree projects with revision undo and a React-free `./session`; `./html` gains a non-throwing region scan and pure region edits; async atomic writes in platform.
+- Updated dependencies
+- Updated dependencies
+  - @jini-ai/core@0.6.11
+
+## 0.6.10
+
+### Patch Changes
+
+- e16a907: Preserve page-reader emphasis, raw Markdown text and inline-code whitespace; cap HTML before synchronous conversion.
+
+  The library projection retains its definition-list, fenced-code language, q/kbd, explicit hard-break and compact GFM table serialization. Ordinary text remains unescaped.
+
+- b63cb5f: Add an explicit child-environment omission helper that reports dropped key names without exposing values, including case-insensitive matching for Windows hosts.
+- Updated dependencies [22f0619]
+- Updated dependencies [82ed2d3]
+- Updated dependencies [5a3de86]
+  - @jini-ai/core@0.6.10
+
 ## 0.5.10 — 2026-10-22
 
 - 2026-10-22: Mail: sender-identity resolver, payload hash covers the full delivery, rate-limit fixes, console preview; coverage.
@@ -54,6 +78,7 @@
 ## Unreleased
 
 - New `./object-store` (node): `createLocalFsObjectStore({ rootDir })` and `createLocalFsObjectStoreProvider()` — the default `local` provider for `@jini-ai/core/object-store`. Path formula `join(rootDir, key)`, byte-identical to cms `LocalFsBlobStore`; atomic `ifAbsent` via `wx`; keys escaping the root are refused.
+
 ### Compilation fixes
 
 - Omit an absent guarded HTTP abort signal to satisfy the canonical request contract.
@@ -66,7 +91,6 @@
 - Remove `./trash` and the trash root namespace; import `@jini-ai/cms/trash`.
 - Move both capabilities' behavior tests with their source; platform retains only generic OS/transport capabilities.
 
-
 ### Shared platform primitives
 
 - BREAKING: HTTP primitive types now come from `@jini-ai/core/primitives`; guarded HTTP exports

package/dist/fs/atomic-write.d.ts

@@ -109,7 +109,7 @@ export declare function writeJsonFileAtomic(required: Omit<AtomicWriteRequired,
  * Parent creation supports runtime-state and secret stores without another writer implementation. */
 export declare function writeFileAtomicAsync(required: {
     filePath: string;
-    content: string;
+    content: string | Uint8Array;
 }, options?: AtomicWriteOptions & {
     fs?: AtomicAsyncFilesystem;
     createParent?: boolean;

package/dist/fs/atomic-write.js

@@ -232,7 +232,7 @@ export async function writeFileAtomicAsync(required, options = {}) {
         closed = true;
         if (options.refuseSymlink)
             await ignoreMissingAsync(async () => assertNotSymlink(await filesystem.lstat(filePath), options));
-        await filesystem.rename(temporary, filePath);
+        await renameWithRetry({ filesystem, from: temporary, to: filePath });
         renamed = true;
         await syncDirectoryBestEffortAsync({ directory: path.dirname(filePath), open: (path, flags) => filesystem.open(path, flags) }, { platform });
     }
@@ -244,6 +244,23 @@ export async function writeFileAtomicAsync(required, options = {}) {
         throw error;
     }
 }
+/** Editors, antivirus and dev-server watchers can hold Windows destinations briefly.
+ * Retry only transient rename refusals; retain the same temporary file and fail after 5 tries.
+ * @complexity O(1) time/space, at most 150ms of backoff plus five filesystem calls.
+ */
+async function renameWithRetry({ filesystem, from, to }) {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            await filesystem.rename(from, to);
+            return;
+        }
+        catch (error) {
+            if (attempt >= 4 || !hasErrorCode(error, ['EPERM', 'EBUSY']))
+                throw error;
+            await new Promise(resolve => setTimeout(resolve, 10 * 2 ** attempt));
+        }
+    }
+}
 /** Pretty JSON can retain a state-store's trailing newline without changing its serialization. */
 export async function writeJsonFileAtomicAsync(required, options = {}) {
     const { data, ...writer } = required;

package/dist/web/web-page.d.ts

@@ -77,6 +77,8 @@ export interface WebFetchResult {
     meta: Record<string, string>;
     fetchedAt: string;
     rendered?: true;
+    /** Explains a browser-unavailable fallback; the returned content has not executed JavaScript. */
+    note?: string;
     data?: RenderedWebPage["data"];
     dataUnmatched?: RenderedWebPage["dataUnmatched"];
     dataTruncated?: boolean;
@@ -129,7 +131,8 @@ export interface WebFetchPorts {
  * @complexity O(url length + filter characters), with at most 20 filters of 500 characters each.
  */
 export declare function readWebFetchInput(input: Record<string, unknown>, _optional?: Record<string, never>): WebFetchInput;
-/** text/*, HTML/XHTML, XML (incl. RSS/Atom/sitemaps), JSON (incl. +json); a missing type is judged by the body. */
+/** text/*, JavaScript, SVG, HTML/XHTML, XML (incl. RSS/Atom/sitemaps), JSON (incl. +json);
+ * a missing type is judged by the body. */
 export declare function isAllowedContentType({ mediaType }: {
     mediaType: string;
 }, _optional?: Record<string, never>): boolean;

package/dist/web/web-page.js

@@ -108,11 +108,12 @@ function header(headers, name) {
             return value;
     return "";
 }
-/** text/*, HTML/XHTML, XML (incl. RSS/Atom/sitemaps), JSON (incl. +json); a missing type is judged by the body. */
+/** text/*, JavaScript, SVG, HTML/XHTML, XML (incl. RSS/Atom/sitemaps), JSON (incl. +json);
+ * a missing type is judged by the body. */
 export function isAllowedContentType({ mediaType }, _optional = {}) {
     if (mediaType === "" || mediaType.startsWith("text/"))
         return true;
-    return /^application\/(?:xhtml\+xml|xml|json|[\w.+-]+\+(?:xml|json))$/.test(mediaType);
+    return /^(?:image\/svg\+xml|application\/(?:javascript|ecmascript|xhtml\+xml|xml|json|[\w.+-]+\+(?:xml|json)))$/.test(mediaType);
 }
 function charsetOf(contentType, body, isHtml) {
     const fromHeader = /charset\s*=\s*"?([\w.:-]+)/i.exec(contentType)?.[1];
@@ -178,7 +179,7 @@ function render(format, body, isHtml, pageUrl, ports) {
 /** Renderer error codes whose meaning the model can act on; any other code falls through to transport mapping. */
 const RENDER_ERROR_MESSAGES = {
     WEB_RENDER_BUSY: "web_fetch_page: render capacity is busy; retry shortly.",
-    WEB_RENDER_UNAVAILABLE: "web_fetch_page: this deployment cannot render pages: its headless browser (Playwright Chromium) is not installed or failed to start.",
+    WEB_RENDER_UNAVAILABLE: "web_fetch_page: this deployment cannot render pages: its headless browser (Playwright Chromium or system Chrome) is not installed or failed to start.",
     WEB_RENDER_REFUSED: "web_fetch_page: the rendered page target is not a public internet address (including after redirects). Localhost, private-network and cloud-metadata addresses are refused.",
 };
 function errorCode({ error }, _optional = {}) {
@@ -268,11 +269,26 @@ async function enforceRateLimit({ ports, url, rateLimitScope, observe }) {
         throw new ToolInputError({ message: `web_fetch_page: too many fetches from ${host} in the last minute. Retry in ${verdict.retryAfterSeconds} seconds.` });
     }
 }
+/** Only an unavailable browser permits a guarded raw fetch; screenshots still require a browser.
+ * Reuses the call's deadline, rate-limit check and caller-safe error mapping.
+ * @complexity O(response bytes), with the same byte and redirect bounds as the ordinary fetch. */
 async function fetchRendered({ input, ports, url }, { signal, timeoutMs }) {
-    if (!ports.renderPage)
-        throw new ToolInputError({ message: "web_fetch_page: rendered pages are unavailable in this deployment." });
-    const page = await ports.renderPage({ input: { ...input, url: url.href } }, { signal, timeoutMs });
-    return projectRendered({ input, ports, url, page });
+    try {
+        if (!ports.renderPage)
+            throw Object.assign(new Error("Browser unavailable"), { code: "WEB_RENDER_UNAVAILABLE" });
+        const page = await ports.renderPage({ input: { ...input, url: url.href } }, { signal, timeoutMs });
+        return projectRendered({ input, ports, url, page });
+    }
+    catch (error) {
+        // Refusals, capacity, navigation and cancellation must never trigger a different network path.
+        if (signal.aborted || input.screenshot || errorCode({ error }) !== "WEB_RENDER_UNAVAILABLE")
+            throw error;
+        const response = await send(ports, url, signal, timeoutMs);
+        return {
+            ...project({ input, ports, url, response }),
+            note: "Browser unavailable; returned a guarded non-rendered fetch. JavaScript was not executed.",
+        };
+    }
 }
 function project({ input, ports, url, response }) {
     const contentType = header(response.headers, "content-type");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/platform",
-  "version": "0.5.10",
+  "version": "0.6.11",
   "description": "Generic OS/platform primitives: process exec and lifecycle, filesystem containment, HTTP readiness polling, toolchain discovery, blob storage, AWS signing, and an SSRF-safe asset cache.",
   "license": "Apache-2.0",
   "repository": {
@@ -200,7 +200,7 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@jini-ai/core": "^0.4.0"
+    "@jini-ai/core": "^0.6.11"
   },
   "publishConfig": {
     "access": "public",