@ricsam/r5d-browser 0.0.137 → 0.0.139

package/dist/types/personal-main.d.ts

@@ -0,0 +1,9 @@
+import type { BrowserCliOptions } from "./cli-options";
+export declare function personalBrowserConnection(options: BrowserCliOptions): {
+    origin: string;
+    token: string;
+};
+/** Keep Chrome's OS environment intact while isolating r5d state per origin. */
+export declare function personalBrowserStateDirectory(origin: string, rootPath?: string): string;
+/** The locally retained keeper, profile and ledger outlive every web reconnect. */
+export declare function startPersonalBrowser(options: BrowserCliOptions, version: string): Promise<void>;

package/dist/types/personal-port-forward.d.ts

@@ -0,0 +1,45 @@
+import type { PersonalBrowserObserver } from "./personal-diagnostics";
+export type ForwardRequest = {
+    forwardId: string;
+    streamId: string;
+    requestId: string;
+    command: {
+        method: "connect" | "write" | "read" | "close";
+        offset?: number;
+        after?: number;
+        base64?: string;
+        end?: boolean;
+    };
+};
+export type ForwardCall = (request: ForwardRequest) => Promise<any>;
+export declare class PersonalForwardResponseError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    constructor(status: number, message: string, code?: string | undefined);
+}
+/** Local loopback sockets outlive every HTTP relay/web connection. Each byte
+ * operation waits for its immutable acknowledgement before advancing offsets. */
+export declare class PersonalPortForwardManager {
+    private readonly call;
+    private readonly observer?;
+    private active;
+    private failures;
+    private queue;
+    private stopping;
+    constructor(call: ForwardCall, observer?: PersonalBrowserObserver | undefined);
+    private observe;
+    list(): {
+        forwardId: string;
+        ready: boolean;
+        activeConnections: number;
+        lastError: {
+            error: string;
+            at: string;
+        } | null;
+    }[];
+    reconcile(raw: unknown): Promise<void>;
+    private start;
+    private stop;
+    private accept;
+    close(): Promise<void>;
+}

package/dist/types/personal-relay-client.d.ts

@@ -0,0 +1,51 @@
+import { BrowserKeeper } from "./runtime/keeper";
+import { type BrowserReceipt } from "./runtime/protocol";
+import { z } from "zod";
+export declare const PersonalBrowserAction: z.ZodObject<{
+    id: z.ZodString;
+    requestHash: z.ZodString;
+    request: z.ZodObject<{
+        action: z.ZodEnum<{
+            list_tabs: "list_tabs";
+            list_downloads: "list_downloads";
+            get_download: "get_download";
+            open_tab: "open_tab";
+            close_tab: "close_tab";
+            navigate: "navigate";
+            set_viewport: "set_viewport";
+            read_page: "read_page";
+            screenshot: "screenshot";
+            move_mouse: "move_mouse";
+            mouse_click: "mouse_click";
+            scroll: "scroll";
+            wait_for: "wait_for";
+            form_input: "form_input";
+            keyboard: "keyboard";
+            keyboard_type: "keyboard_type";
+            run_js: "run_js";
+            upload_begin: "upload_begin";
+            upload_chunk: "upload_chunk";
+            upload_attach: "upload_attach";
+            upload_abort: "upload_abort";
+        }>;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** Network replacement never disposes this keeper. Its ledger decides whether an
+ * action ran; polling the same server queue item cannot replay a browser effect. */
+export declare class PersonalBrowserProcessor {
+    private readonly keeper;
+    readonly identity: {
+        installationId: string;
+        userId: string;
+        instanceId: string;
+    };
+    private readonly nextEpoch?;
+    private epoch;
+    constructor(keeper: BrowserKeeper, identity: {
+        installationId: string;
+        userId: string;
+        instanceId: string;
+    }, nextEpoch?: (() => number) | undefined);
+    execute(raw: unknown): Promise<BrowserReceipt>;
+}

package/dist/types/personal-relay-shutdown.d.ts

@@ -0,0 +1,19 @@
+type RelayAction = {
+    id: string;
+    requestHash: string;
+};
+export type PersonalBrowserAcknowledgement = {
+    id: string;
+    requestHash: string;
+    state: "completed" | "unknown";
+    result: unknown;
+};
+/** Shutdown cancels queue observation, never an admitted browser effect or its receipt. */
+export declare class PersonalBrowserRelayShutdown {
+    private readonly polls;
+    get stopping(): boolean;
+    get pollSignal(): AbortSignal;
+    stop(): void;
+    dispatch<T extends RelayAction>(actions: readonly T[], execute: (action: T) => Promise<unknown>, acknowledge: (receipt: PersonalBrowserAcknowledgement) => Promise<unknown>): Promise<void>;
+}
+export {};

package/dist/types/runtime/chromium-factory.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import type { BrowserExecutor } from "./keeper";
+/** Declarative built-in factory approval, NOT an arbitrary JS module or Chromium argument escape hatch. */
+export declare const ChromiumFactoryApproval: z.ZodObject<{
+    kind: z.ZodLiteral<"isolated-chromium-v1">;
+    executablePath: z.ZodString;
+    allowedOrigins: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type ChromiumFactoryApproval = z.infer<typeof ChromiumFactoryApproval>;
+export declare function loadApprovedChromiumFactory(filename: string, sha256: string): ChromiumFactoryApproval;
+export type ChromiumKeeperIdentity = {
+    runId: string;
+    browserPid: number;
+    keeperPid: number;
+    profile: string;
+    downloads: string;
+    uploads: string;
+};
+export declare function createIsolatedChromiumRuntime(input: {
+    runs: string;
+    approval: ChromiumFactoryApproval;
+}): Promise<{
+    executor: BrowserExecutor;
+    identity: ChromiumKeeperIdentity;
+}>;

package/dist/types/runtime/fixtures/counter-main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/runtime/fixtures/counter-runtime.d.ts

@@ -1,3 +1,7 @@
-import type { BrowserKeeperRuntimeFactory } from "../main";
+import type { BrowserExecutor } from "../keeper";
 /** Offline subprocess proof. No Chrome, network, profiles or user resources. */
-export declare const createBrowserKeeperRuntime: BrowserKeeperRuntimeFactory;
+export declare const createBrowserKeeperRuntime: ({ directory }: {
+    directory: string;
+}) => Promise<{
+    executor: BrowserExecutor;
+}>;

package/dist/types/runtime/isolated-root.d.ts

@@ -0,0 +1,12 @@
+export declare function isolatedBrowserRoot(root: string, installationId: string, userId: string): {
+    ledger: string;
+    runs: string;
+};
+export declare function freshBrowserRun(runs: string): {
+    id: string;
+    directory: string;
+    profile: string;
+    downloads: string;
+    uploads: string;
+    home: string;
+};

package/dist/types/runtime/main.d.ts

@@ -1,16 +1,23 @@
-import { type BrowserExecutor } from "./keeper";
-export type BrowserKeeperRuntimeFactory = (input: {
-    installationId: string;
-    userId: string;
-    directory: string;
-}) => Promise<{
-    executor: BrowserExecutor;
-    dispose?: () => Promise<void>;
-}>;
-/**
- * Explicit, private, standalone launch surface. runtimeModule is trusted operator code, not a wire field.
- * It must export createBrowserKeeperRuntime, constructing browserRuntimeExecutor(runtime) INSIDE this process.
- */
+import { z } from "zod";
+import { type ChromiumKeeperIdentity } from "./chromium-factory";
+export declare const BrowserKeeperConfig: z.ZodObject<{
+    installationId: z.ZodString;
+    userId: z.ZodString;
+    instanceId: z.ZodString;
+    releaseId: z.ZodString;
+    root: z.ZodString;
+    factory: z.ZodObject<{
+        approvalPath: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>;
+    adapters: z.ZodArray<z.ZodObject<{
+        ownerId: z.ZodString;
+        token: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Only the built-in isolated REAL Chromium factory is reachable from this startup boundary. */
 export declare function startConfiguredBrowserKeeper(configPath: string): Promise<{
+    socketPath: string;
+    identity: ChromiumKeeperIdentity;
     close(): Promise<void>;
 }>;

package/dist/types/runtime/private-paths.d.ts

@@ -0,0 +1,4 @@
+/** Reject symlink ancestors, non-canonical paths and writable-by-other-user ancestors. */
+export declare function assertPrivatePath(filename: string, kind: "directory" | "file", immutable?: boolean): void;
+export declare function readPrivateFile(filename: string, maximumBytes: number, immutable?: boolean): Buffer;
+export declare function makePrivateDirectory(directory: string): void;

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@ricsam/r5d-browser",
-  "version": "0.0.137",
+  "version": "0.0.139",
   "type": "module",
-  "main": "./dist/cjs/main.cjs",
+  "main": "./dist/mjs/main.mjs",
   "module": "./dist/mjs/main.mjs",
   "types": "./dist/types/main.d.ts",
   "exports": {
     ".": {
       "types": "./dist/types/main.d.ts",
       "import": "./dist/mjs/main.mjs",
-      "require": "./dist/cjs/main.cjs"
+      "default": "./dist/mjs/main.mjs"
     }
   },
   "repository": {
@@ -18,11 +18,12 @@
     "directory": "packages/r5d-browser"
   },
   "bin": {
-    "r5d-browser": "dist/cjs/main.cjs"
+    "r5d-browser": "dist/mjs/main.mjs"
   },
   "dependencies": {
-    "@ricsam/r5d-api": "^0.0.137",
+    "@ricsam/r5d-api": "^0.0.139",
     "playwright-core": "1.62.1",
+    "zod": "^4.1.13",
     "ws": "^8.18.3"
   },
   "files": [

package/dist/cjs/browser-input.cjs

@@ -1,87 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var browser_input_exports = {};
-__export(browser_input_exports, {
-  MAX_VIEWPORT_DIMENSION: () => MAX_VIEWPORT_DIMENSION,
-  normalizeBrowserInput: () => normalizeBrowserInput,
-  parseViewportInput: () => parseViewportInput
-});
-module.exports = __toCommonJS(browser_input_exports);
-const browserInputFields = {
-  list_tabs: { required: [], optional: [] },
-  list_downloads: { required: [], optional: [] },
-  get_download: { required: ["downloadId"], optional: ["offset", "maxBytes"] },
-  open_tab: { required: [], optional: ["url", "disposition"] },
-  close_tab: { required: ["tabId"], optional: [] },
-  navigate: { required: ["tabId", "url"], optional: [] },
-  set_viewport: { required: ["tabId"], optional: ["width", "height", "reset"] },
-  read_page: { required: ["tabId"], optional: ["depth", "maxChars"] },
-  screenshot: { required: ["tabId"], optional: ["fullPage"] },
-  move_mouse: { required: ["tabId", "x", "y"], optional: [] },
-  mouse_click: { required: ["tabId"], optional: ["ref", "x", "y", "button", "clickCount"] },
-  scroll: { required: ["tabId"], optional: ["ref", "direction", "amount", "x", "y"] },
-  wait_for: { required: ["tabId"], optional: ["selector", "text", "url", "loadState", "state", "timeoutMs"] },
-  form_input: { required: ["tabId", "ref"], optional: ["value", "values", "checked"] },
-  keyboard: { required: ["tabId", "keys"], optional: ["modifiers"] },
-  keyboard_type: { required: ["tabId", "text"], optional: ["mode", "delayMs"] },
-  run_js: { required: ["tabId", "code"], optional: [] },
-  upload_files: { required: ["tabId", "files"], optional: ["ref", "selector"] },
-  upload_begin: { required: ["tabId", "uploadId", "files"], optional: ["ref", "selector"] },
-  upload_chunk: { required: ["tabId", "uploadId", "index", "offset", "base64"], optional: [] },
-  upload_attach: { required: ["tabId", "uploadId", "hashes"], optional: [] },
-  upload_abort: { required: ["tabId", "uploadId"], optional: [] },
-  port_forward: { required: ["workerPort"], optional: ["browserPort"] },
-  list_port_forwards: { required: [], optional: [] },
-  stop_port_forward: { required: ["forwardId"], optional: [] }
-};
-const MAX_VIEWPORT_DIMENSION = 4096;
-function parseViewportInput(input) {
-  if (input.reset !== void 0 && typeof input.reset !== "boolean") throw new Error("set_viewport reset must be a boolean.");
-  if (input.reset === true) {
-    if (input.width !== void 0 || input.height !== void 0)
-      throw new Error("set_viewport accepts width/height or reset: true, not both.");
-    return null;
-  }
-  const { width, height } = input;
-  for (const [name, value] of Object.entries({ width, height })) {
-    if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > MAX_VIEWPORT_DIMENSION) {
-      throw new Error(
-        `set_viewport requires ${name} to be an integer from 1 to ${MAX_VIEWPORT_DIMENSION} CSS pixels, or reset: true without dimensions.`
-      );
-    }
-  }
-  return { width, height };
-}
-function normalizeBrowserInput(action, input) {
-  const fields = browserInputFields[action];
-  for (const key of fields.required) {
-    if (input[key] === null || input[key] === void 0) throw new Error(`${action} requires ${key}.`);
-  }
-  const normalized = { ...input };
-  for (const key of fields.optional) {
-    if (normalized[key] === null) delete normalized[key];
-  }
-  return normalized;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  MAX_VIEWPORT_DIMENSION,
-  normalizeBrowserInput,
-  parseViewportInput
-});