@cedarjs/api 8.0.0-canary.3450 → 8.0.0-canary.3451

package/README.md

@@ -39,18 +39,6 @@ Note: CedarJS logging is setup for its api side only. For browser and web side e
 
 For detailed logger configuration, see the CedarJS logger package [README](./src/logger/README.md).
 
-### Sandbox
-
-`@cedarjs/api/sandbox` runs a Node script on untrusted input — an uploaded
-photo, a third party's PDF — in a locked-down child process: none of your app's environment
-variables (on Windows a few system ones remain), read access only to its
-script, the packages it imports and the paths you allow, no writes, no
-child processes, no network, a heap cap, a timeout and output limits. Use it
-for parsing, decoding or converting files you didn't create (sharp, pdf.js,
-…). It's defense in depth on top of Node's permission model, not a security
-boundary, and native addons aren't limited by that model. See the sandbox
-[README](./src/sandbox/README.md).
-
 ## Contributing
 
 `@cedarjs/api` uses a few things you should be familiar with:

package/dist/index.js

@@ -8,9 +8,9 @@ export * from "./cors.js";
 export * from "./event.js";
 export * from "./signedTokens/index.js";
 const prismaVersion = "7.10.0";
-const redwoodVersion = "8.0.0-canary.3450";
-const cedarjsVersion = "8.0.0-canary.3450";
-const cedarVersion = "8.0.0-canary.3450";
+const redwoodVersion = "8.0.0-canary.3451";
+const cedarjsVersion = "8.0.0-canary.3451";
+const cedarVersion = "8.0.0-canary.3451";
 export {
   cedarVersion,
   cedarjsVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/api",
-  "version": "8.0.0-canary.3450",
+  "version": "8.0.0-canary.3451",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cedarjs/cedar.git",
@@ -40,12 +40,6 @@
         "default": "./dist/logger/index.js"
       }
     },
-    "./sandbox": {
-      "default": {
-        "types": "./dist/sandbox/index.d.ts",
-        "default": "./dist/sandbox/index.js"
-      }
-    },
     "./webhooks": {
       "default": {
         "types": "./dist/webhooks/index.d.ts",
@@ -90,7 +84,7 @@
     "title-case": "3.0.3"
   },
   "devDependencies": {
-    "@cedarjs/framework-tools": "8.0.0-canary.3450",
+    "@cedarjs/framework-tools": "8.0.0-canary.3451",
     "@types/aws-lambda": "8.10.164",
     "@types/jsonwebtoken": "9.0.10",
     "@types/memjs": "1",
@@ -100,7 +94,6 @@
     "memjs": "1.3.2",
     "publint": "0.3.25",
     "redis": "6.3.0",
-    "sharp": "0.35.5",
     "split2": "4.2.0",
     "ts-toolbelt": "9.6.0",
     "typescript": "5.9.3",

package/dist/sandbox/concurrencyLimiter.d.ts

@@ -1,22 +0,0 @@
-/**
- * Runs `fn` once a slot is free; resolves or rejects with what `fn` does.
- */
-export type ConcurrencyLimiter = <T>(fn: () => Promise<T>) => Promise<T>;
-/**
- * A limiter that lets at most `max` tasks run at once; the rest wait their
- * turn, first come first served. Use it around `runSandboxedChild()`: each
- * sandboxed child is a whole Node process, and a burst of uploads shouldn't
- * start a hundred of them.
- *
- * The limit is per limiter, in this process. Create one per kind of work
- * at module level, not one per call.
- *
- * @example
- * ```ts
- * const limit = createConcurrencyLimiter(2)
- *
- * const result = await limit(() => runSandboxedChild({ ... }))
- * ```
- */
-export declare const createConcurrencyLimiter: (max: number) => ConcurrencyLimiter;
-//# sourceMappingURL=concurrencyLimiter.d.ts.map

package/dist/sandbox/concurrencyLimiter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"concurrencyLimiter.d.ts","sourceRoot":"","sources":["../../src/sandbox/concurrencyLimiter.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;AAExE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB,GAAI,KAAK,MAAM,KAAG,kBAkCtD,CAAA"}

package/dist/sandbox/concurrencyLimiter.js

@@ -1,33 +0,0 @@
-const createConcurrencyLimiter = (max) => {
-  if (!Number.isInteger(max) || max < 1) {
-    throw new Error(`max must be a positive integer, got ${max}`);
-  }
-  let running = 0;
-  const waiting = [];
-  const acquire = async () => {
-    if (running < max) {
-      running += 1;
-      return;
-    }
-    await new Promise((resolve) => waiting.push(resolve));
-  };
-  const release = () => {
-    const next = waiting.shift();
-    if (next) {
-      next();
-    } else {
-      running -= 1;
-    }
-  };
-  return async (fn) => {
-    await acquire();
-    try {
-      return await fn();
-    } finally {
-      release();
-    }
-  };
-};
-export {
-  createConcurrencyLimiter
-};

package/dist/sandbox/findChildScript.d.ts

@@ -1,29 +0,0 @@
-/**
- * Finds a sandboxed child's script for the module that runs it. Call it
- * with `import.meta.dirname` and the script's name without extension, the
- * same way in every build:
- *
- * - from source (tests, `cedar exec`), `<baseName>.ts` (or `.js`) in
- *   `dir`, which Node runs by stripping its types;
- * - in a regular build, `<baseName>.js` in `dir`, where the build puts it
- *   next to its caller;
- * - in a bundled build (`cedar build --ud`, and so on Netlify and Vercel),
- *   where the caller is part of a bundle,
- *   `api/dist/ud/sandbox-children/<baseName>.js` in the app (looked for
- *   from `dir` up). A bundled build needs each child's name to be unique
- *   in `api/src`.
- *
- * Throws when there's no such script, so a build that lost it fails loudly
- * instead of running without it.
- *
- * Keep the child script plain enough to run as-is: no path aliases like
- * `src/…`, no TypeScript-only syntax such as enums, and imports of packages
- * only, never of your app's own modules.
- *
- * @example
- * ```ts
- * const script = findChildScript(import.meta.dirname, 'resize.child')
- * ```
- */
-export declare const findChildScript: (dir: string, baseName: string) => string;
-//# sourceMappingURL=findChildScript.d.ts.map

package/dist/sandbox/findChildScript.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"findChildScript.d.ts","sourceRoot":"","sources":["../../src/sandbox/findChildScript.ts"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,EAAE,UAAU,MAAM,KAAG,MAiB/D,CAAA"}

package/dist/sandbox/findChildScript.js

@@ -1,35 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-const SANDBOX_CHILDREN_DIR = path.join("api", "dist", "ud", "sandbox-children");
-const findBundledChild = (dir, baseName) => {
-  let current = dir;
-  for (; ; ) {
-    const candidate = path.join(current, SANDBOX_CHILDREN_DIR, `${baseName}.js`);
-    if (fs.existsSync(candidate)) {
-      return candidate;
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-};
-const findChildScript = (dir, baseName) => {
-  for (const name of [`${baseName}.js`, `${baseName}.ts`]) {
-    const candidate = path.join(dir, name);
-    if (fs.existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  const bundled = findBundledChild(dir, baseName);
-  if (bundled) {
-    return bundled;
-  }
-  throw new Error(
-    `findChildScript: no ${baseName}.js or ${baseName}.ts in ${dir}, and no ${path.join(SANDBOX_CHILDREN_DIR, `${baseName}.js`)} from it up`
-  );
-};
-export {
-  findChildScript
-};

package/dist/sandbox/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Run code on untrusted input in a sandboxed, locked-down child process.
- * See `runSandboxedChild()` and ./README.md.
- */
-export { DEFAULT_SANDBOX_HEAP_MB, DEFAULT_SANDBOX_MAX_INPUT_BYTES, DEFAULT_SANDBOX_MAX_OUTPUT_BYTES, DEFAULT_SANDBOX_TIMEOUT_MS, runSandboxedChild, sandboxedChildArgs, } from './runSandboxedChild.js';
-export type { RunSandboxedChildOptions, SandboxedChildArgsOptions, SandboxedChildFailure, SandboxedChildResult, } from './runSandboxedChild.js';
-export { createConcurrencyLimiter } from './concurrencyLimiter.js';
-export type { ConcurrencyLimiter } from './concurrencyLimiter.js';
-export { permissionModelBlocksNetwork } from './noNetworkPreload.js';
-export { findChildScript } from './findChildScript.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/sandbox/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sandbox/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,uBAAuB,EACvB,+BAA+B,EAC/B,gCAAgC,EAChC,0BAA0B,EAC1B,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,wBAAwB,CAAA;AAC/B,YAAY,EACV,wBAAwB,EACxB,yBAAyB,EACzB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAA;AAClE,YAAY,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAA;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/sandbox/index.js

@@ -1,22 +0,0 @@
-import {
-  DEFAULT_SANDBOX_HEAP_MB,
-  DEFAULT_SANDBOX_MAX_INPUT_BYTES,
-  DEFAULT_SANDBOX_MAX_OUTPUT_BYTES,
-  DEFAULT_SANDBOX_TIMEOUT_MS,
-  runSandboxedChild,
-  sandboxedChildArgs
-} from "./runSandboxedChild.js";
-import { createConcurrencyLimiter } from "./concurrencyLimiter.js";
-import { permissionModelBlocksNetwork } from "./noNetworkPreload.js";
-import { findChildScript } from "./findChildScript.js";
-export {
-  DEFAULT_SANDBOX_HEAP_MB,
-  DEFAULT_SANDBOX_MAX_INPUT_BYTES,
-  DEFAULT_SANDBOX_MAX_OUTPUT_BYTES,
-  DEFAULT_SANDBOX_TIMEOUT_MS,
-  createConcurrencyLimiter,
-  findChildScript,
-  permissionModelBlocksNetwork,
-  runSandboxedChild,
-  sandboxedChildArgs
-};

package/dist/sandbox/noNetworkPreload.d.ts

@@ -1,16 +0,0 @@
-/**
- * Whether this Node's permission model restricts network access. On Node
- * 25 and later it does: under `--permission`, without `--allow-net`, a
- * child can't open sockets, listen, look up names or `fetch`. On Node 24
- * it doesn't, so `runSandboxedChild()` loads a preload that takes the
- * network away from JavaScript instead (see `NO_NETWORK_PRELOAD`).
- *
- * Neither limits native code: an addon makes its own system calls.
- */
-export declare const permissionModelBlocksNetwork: () => boolean;
-/**
- * The `--import` argument that loads the no-network preload, as a `data:`
- * URL. Loading it needs no file and no read permission.
- */
-export declare const noNetworkPreloadArg: () => string;
-//# sourceMappingURL=noNetworkPreload.d.ts.map

package/dist/sandbox/noNetworkPreload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"noNetworkPreload.d.ts","sourceRoot":"","sources":["../../src/sandbox/noNetworkPreload.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,eACe,CAAA;AAiIxD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,cAC2C,CAAA"}

package/dist/sandbox/noNetworkPreload.js

@@ -1,109 +0,0 @@
-const permissionModelBlocksNetwork = () => process.allowedNodeEnvironmentFlags.has("--allow-net");
-const NO_NETWORK_PRELOAD = String.raw`
-const BLOCKED = new Set([
-  'net',
-  'tls',
-  'dgram',
-  'dns',
-  'dns/promises',
-  'http',
-  'https',
-  'http2',
-  '_http_agent',
-  '_http_client',
-  '_http_common',
-  '_http_incoming',
-  '_http_outgoing',
-  '_http_server',
-  '_tls_common',
-  '_tls_wrap',
-])
-
-const isBlocked = (id) =>
-  typeof id === 'string' && BLOCKED.has(id.replace(/^node:/, ''))
-
-const refuse = (what) =>
-  function noNetwork() {
-    throw new Error('No network access in a sandboxed child (' + what + ')')
-  }
-
-const getBuiltinModule = process.getBuiltinModule.bind(process)
-const { registerHooks, syncBuiltinESMExports } =
-  getBuiltinModule('node:module')
-
-// The modules themselves first, before the hooks below make them
-// unreachable. Builtin modules are shared, so Node's own users of them
-// (http uses net) get the patched functions too
-const net = getBuiltinModule('node:net')
-net.Socket.prototype.connect = refuse('net.Socket#connect')
-net.Server.prototype.listen = refuse('net.Server#listen')
-net.connect = refuse('net.connect')
-net.createConnection = refuse('net.createConnection')
-
-const tls = getBuiltinModule('node:tls')
-tls.connect = refuse('tls.connect')
-
-const dgram = getBuiltinModule('node:dgram')
-for (const name of ['bind', 'connect', 'send']) {
-  dgram.Socket.prototype[name] = refuse('dgram.Socket#' + name)
-}
-
-const dns = getBuiltinModule('node:dns')
-for (const [label, api] of [
-  ['dns', dns],
-  ['dns.promises', dns.promises],
-]) {
-  for (const name of Object.keys(api)) {
-    if (typeof api[name] === 'function') {
-      api[name] = refuse(label + '.' + name)
-    }
-  }
-}
-
-// The handles under stdin, stdout and stderr (a Pipe or a TTY). Their
-// class can make new handles that connect or bind, e.g. to a Unix socket.
-// Reading process.stdin and friends here also opens the child's own stdio
-// before open() is taken away
-for (const stream of [process.stdin, process.stdout, process.stderr]) {
-  const handle = stream._handle
-  const proto = handle && Object.getPrototypeOf(handle)
-  if (!proto) {
-    continue
-  }
-  for (const name of ['bind', 'bind6', 'connect', 'connect6', 'listen', 'open']) {
-    if (typeof proto[name] === 'function') {
-      proto[name] = refuse(handle.constructor.name + '#' + name)
-    }
-  }
-}
-
-syncBuiltinESMExports()
-
-// Then the ways to the modules
-registerHooks({
-  resolve(specifier, context, nextResolve) {
-    if (isBlocked(specifier)) {
-      refuse('import of ' + specifier)()
-    }
-    return nextResolve(specifier, context)
-  },
-})
-
-process.getBuiltinModule = (id) => {
-  if (isBlocked(id)) {
-    refuse('process.getBuiltinModule(' + id + ')')()
-  }
-  return getBuiltinModule(id)
-}
-
-for (const name of ['fetch', 'WebSocket', 'EventSource']) {
-  delete globalThis[name]
-}
-
-//# sourceURL=cedar-sandbox-no-network-preload.js
-`;
-const noNetworkPreloadArg = () => `--import=data:text/javascript,${encodeURIComponent(NO_NETWORK_PRELOAD)}`;
-export {
-  noNetworkPreloadArg,
-  permissionModelBlocksNetwork
-};

package/dist/sandbox/runSandboxedChild.d.ts

@@ -1,186 +0,0 @@
-/** The heap cap for a sandboxed child, in MB, unless `heapMb` is given */
-export declare const DEFAULT_SANDBOX_HEAP_MB = 256;
-/** How long a sandboxed child may run, unless `timeoutMs` is given */
-export declare const DEFAULT_SANDBOX_TIMEOUT_MS = 10000;
-/** The most bytes sent to a sandboxed child, unless `maxInputBytes` is given */
-export declare const DEFAULT_SANDBOX_MAX_INPUT_BYTES: number;
-/** The most bytes read back from a sandboxed child, unless `maxOutputBytes` is given */
-export declare const DEFAULT_SANDBOX_MAX_OUTPUT_BYTES: number;
-export interface SandboxedChildArgsOptions {
-    /**
-     * The Node script the child runs: a `.js`/`.mjs`/`.cjs` file, or a `.ts`
-     * file Node can run by stripping its types. It may read itself.
-     */
-    script: string;
-    /**
-     * The packages the child imports, by name (`['sharp']`). The child may
-     * read each one's folder and those of everything it depends on
-     * (dependencies, and installed optional and peer dependencies, which is
-     * where native packages keep their platform's binaries), resolved from
-     * the script's folder the way Node will resolve its imports. Nothing
-     * else in `node_modules` is readable. A package that isn't installed
-     * there fails the run (`'spawn-error'`) before a child starts.
-     */
-    packages?: string[];
-    /**
-     * Files and directories (and everything under them) the child may read
-     * besides its own script and its `packages`. Everything else on disk is
-     * unreadable to the child: `.env`, your app's source, uploaded files.
-     */
-    readable?: string[];
-    /**
-     * Whether the child may load native addons (`.node` files), as a library
-     * like sharp needs. Off by default. Node's permission model does not
-     * apply to native code: an addon, or an attacker who takes over one, can
-     * do anything the OS lets the process do. Turn this on only for fixed,
-     * known libraries, never for an addon the input could choose.
-     */
-    allowAddons?: boolean;
-    /** The child's heap cap (`--max-old-space-size`), in MB. Default 256. */
-    heapMb?: number;
-    /** Arguments for the child script, in `process.argv.slice(2)` */
-    args?: string[];
-}
-/**
- * The `node` command-line arguments for running `script` as a sandboxed
- * child process: Node's permission model (`--permission`) with read access
- * to `script`, its `packages` and `readable` only, no network, a heap cap, and code generation from
- * strings (`eval`, `new Function`) turned off. No file writes, no child
- * processes, no worker threads, no WASI, no inspector, and native addons
- * only with `allowAddons`.
- *
- * On Node 25 and later the permission model blocks the network. On Node 24
- * it doesn't, so the arguments also load a preload that takes the network
- * away from JavaScript in the child (see `permissionModelBlocksNetwork()`).
- *
- * `runSandboxedChild()` uses this; it's exported for spawning the child
- * yourself (e.g. in a test probing what the child can do). Pass an empty
- * `env` when you do: the arguments restrict what the child may touch, not
- * what it inherits.
- *
- * The permission model checks the path a file is opened by, and Node opens
- * the script and the modules it imports by their real paths, so the
- * script is given by its real path, and other paths by both (an app
- * deployed behind a `current -> releases/…` symlink would otherwise be
- * refused its own files). Throws if a path doesn't exist.
- */
-export declare const sandboxedChildArgs: ({ script, packages, readable, allowAddons, heapMb, args, }: SandboxedChildArgsOptions) => string[];
-export interface RunSandboxedChildOptions extends SandboxedChildArgsOptions {
-    /** The untrusted bytes, written to the child's stdin */
-    input: Uint8Array;
-    /**
-     * The child is killed (SIGKILL) if it hasn't exited after this many
-     * milliseconds. Default 10 000. Like the byte limits, it must be a finite
-     * number from 0 up; anything else (`NaN` from a missing setting, say) is
-     * a `'spawn-error'` and no child is started.
-     */
-    timeoutMs?: number;
-    /**
-     * Larger input is refused without starting the child. Default 25 MiB.
-     */
-    maxInputBytes?: number;
-    /**
-     * The child is killed as soon as it has written more than this many bytes
-     * to stdout. Default 25 MiB.
-     */
-    maxOutputBytes?: number;
-    /** The child's working directory. Default: the script's folder. */
-    cwd?: string;
-}
-/** Why a sandboxed child produced no output */
-export type SandboxedChildFailure = 
-/** The input was over `maxInputBytes`; no child was started */
-'input-too-large'
-/** The child ran past `timeoutMs` and was killed */
- | 'timeout'
-/** The child wrote more than `maxOutputBytes` and was killed */
- | 'output-too-large'
-/** The child exited non-zero or was killed by a signal */
- | 'exit'
-/** The child couldn't be started, or a limit isn't a valid number */
- | 'spawn-error';
-export type SandboxedChildResult = {
-    ok: true;
-    /** Everything the child wrote to stdout */
-    output: Buffer;
-    /** What the child wrote to stderr (the last 4000 characters) */
-    stderr: string;
-} | {
-    ok: false;
-    failure: SandboxedChildFailure;
-    /** A one-line description, for a log */
-    message: string;
-    /** What the child wrote to stderr (the last 4000 characters) */
-    stderr: string;
-    exitCode: number | null;
-    signal: NodeJS.Signals | null;
-};
-/**
- * Runs a Node script on untrusted bytes in a locked-down (sandboxed) child
- * process, so a crafted input that exploits a parser bug lands in a process
- * that can't read your secrets or touch your files. Use it for parsing,
- * decoding or converting files your users or third parties send you:
- * resizing a photo with sharp, rendering a PDF page with pdf.js, unpacking
- * an archive, parsing a spreadsheet.
- *
- * The child:
- *
- * - gets an **empty environment** — no `DATABASE_URL`, no API keys, none of
- *   your `.env`;
- * - runs under **Node's permission model**: it may read its own script,
- *   the `packages` it imports and the `readable` paths,
- *   nothing else; it may not write files, spawn processes, start workers,
- *   or `eval`; it may load native addons only with `allowAddons`;
- * - has **no network**: no sockets, no `fetch`, no DNS (on Node 24 through
- *   a preload, see `permissionModelBlocksNetwork()`);
- * - gets the input on **stdin**, and its **stdout** is the result, used only
- *   if it exits with code 0;
- * - is **bounded**: a heap cap, a hard timeout (SIGKILL), and caps on input
- *   and output size.
- *
- * It never rejects: every failure — a non-zero exit, a timeout, too much
- * output, a crash — is an `{ ok: false }` result with a `failure` and a
- * `message` for your log. Treat the output as untrusted too, and check it
- * (e.g. that it's really a PNG) before using it.
- *
- * Limit how many run at once with `createConcurrencyLimiter()`: each child
- * is a whole Node process.
- *
- * **This is defense in depth, not a security boundary.** Node documents
- * that its permission model does not protect against malicious code that
- * is already running in the process. None of it constrains native code: a
- * native addon (`allowAddons`), or an exploit in one, makes its own system
- * calls, so for those children what holds is the empty environment, the
- * separate process and its limits. An external binary like ffmpeg needs an
- * OS-level sandbox (a container, seccomp, a separate user).
- *
- * @example
- * ```ts
- * import {
- *   createConcurrencyLimiter,
- *   findChildScript,
- *   runSandboxedChild,
- * } from '@cedarjs/api/sandbox'
- *
- * const limit = createConcurrencyLimiter(2)
- *
- * const result = await limit(() =>
- *   runSandboxedChild({
- *     script: findChildScript(import.meta.dirname, 'resize.child'),
- *     packages: ['sharp'],
- *     allowAddons: true,
- *     input: uploadedBytes,
- *     timeoutMs: 10_000,
- *     maxOutputBytes: 4 * 1024 * 1024,
- *   }),
- * )
- *
- * if (result.ok) {
- *   // result.output: Buffer
- * } else {
- *   logger.warn({ failure: result.failure }, result.message)
- * }
- * ```
- */
-export declare const runSandboxedChild: ({ input, timeoutMs, maxInputBytes, maxOutputBytes, cwd, ...argsOptions }: RunSandboxedChildOptions) => Promise<SandboxedChildResult>;
-//# sourceMappingURL=runSandboxedChild.d.ts.map

package/dist/sandbox/runSandboxedChild.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runSandboxedChild.d.ts","sourceRoot":"","sources":["../../src/sandbox/runSandboxedChild.ts"],"names":[],"mappings":"AAaA,0EAA0E;AAC1E,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAC1C,sEAAsE;AACtE,eAAO,MAAM,0BAA0B,QAAS,CAAA;AAChD,gFAAgF;AAChF,eAAO,MAAM,+BAA+B,QAAW,CAAA;AACvD,wFAAwF;AACxF,eAAO,MAAM,gCAAgC,QAAW,CAAA;AAQxD,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,iEAAiE;IACjE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,kBAAkB,GAAI,4DAOhC,yBAAyB,KAAG,MAAM,EA6BpC,CAAA;AAED,MAAM,WAAW,wBAAyB,SAAQ,yBAAyB;IACzE,wDAAwD;IACxD,KAAK,EAAE,UAAU,CAAA;IACjB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,mEAAmE;IACnE,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAED,+CAA+C;AAC/C,MAAM,MAAM,qBAAqB;AAC/B,+DAA+D;AAC7D,iBAAiB;AACnB,oDAAoD;GAClD,SAAS;AACX,gEAAgE;GAC9D,kBAAkB;AACpB,0DAA0D;GACxD,MAAM;AACR,qEAAqE;GACnE,aAAa,CAAA;AAEjB,MAAM,MAAM,oBAAoB,GAC5B;IACE,EAAE,EAAE,IAAI,CAAA;IACR,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAA;IACd,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAA;CACf,GACD;IACE,EAAE,EAAE,KAAK,CAAA;IACT,OAAO,EAAE,qBAAqB,CAAA;IAC9B,wCAAwC;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAA;CAC9B,CAAA;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,eAAO,MAAM,iBAAiB,GAAI,0EAO/B,wBAAwB,KAAG,OAAO,CAAC,oBAAoB,CA+LzD,CAAA"}

package/dist/sandbox/runSandboxedChild.js

@@ -1,213 +0,0 @@
-import { spawn } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import {
-  noNetworkPreloadArg,
-  permissionModelBlocksNetwork
-} from "./noNetworkPreload.js";
-import { sandboxPackagePaths } from "./sandboxPackages.js";
-const MIB = 1024 * 1024;
-const DEFAULT_SANDBOX_HEAP_MB = 256;
-const DEFAULT_SANDBOX_TIMEOUT_MS = 1e4;
-const DEFAULT_SANDBOX_MAX_INPUT_BYTES = 25 * MIB;
-const DEFAULT_SANDBOX_MAX_OUTPUT_BYTES = 25 * MIB;
-const MAX_TIMEOUT_MS = 2 ** 31 - 1;
-const MAX_STDERR_CHARS = 4e3;
-const sandboxedChildArgs = ({
-  script,
-  packages = [],
-  readable = [],
-  allowAddons = false,
-  heapMb = DEFAULT_SANDBOX_HEAP_MB,
-  args = []
-}) => {
-  if (!Number.isInteger(heapMb) || heapMb <= 0) {
-    throw new Error(`heapMb must be a positive integer, got ${heapMb}`);
-  }
-  const realScript = fs.realpathSync(script);
-  const readPaths = [
-    .../* @__PURE__ */ new Set([
-      realScript,
-      ...sandboxPackagePaths(packages, realScript),
-      // Node may read a file through the path it was given or through
-      // its real path
-      ...readable.flatMap((p) => [path.resolve(p), fs.realpathSync(p)])
-    ])
-  ];
-  return [
-    `--max-old-space-size=${heapMb}`,
-    "--disallow-code-generation-from-strings",
-    "--permission",
-    ...allowAddons ? ["--allow-addons"] : [],
-    // Node warns that the permission model is experimental, and about
-    // --allow-addons; the warnings would end up in the failure message
-    "--no-warnings",
-    ...readPaths.map((p) => `--allow-fs-read=${p}`),
-    ...permissionModelBlocksNetwork() ? [] : [noNetworkPreloadArg()],
-    realScript,
-    ...args
-  ];
-};
-const runSandboxedChild = ({
-  input,
-  timeoutMs = DEFAULT_SANDBOX_TIMEOUT_MS,
-  maxInputBytes = DEFAULT_SANDBOX_MAX_INPUT_BYTES,
-  maxOutputBytes = DEFAULT_SANDBOX_MAX_OUTPUT_BYTES,
-  cwd,
-  ...argsOptions
-}) => {
-  const fail = (failure, message, rest = {}) => ({
-    ok: false,
-    failure,
-    message,
-    stderr: rest.stderr ?? "",
-    exitCode: rest.exitCode ?? null,
-    signal: rest.signal ?? null
-  });
-  const invalidLimit = [
-    ["timeoutMs", timeoutMs, MAX_TIMEOUT_MS],
-    ["maxInputBytes", maxInputBytes, Number.MAX_SAFE_INTEGER],
-    ["maxOutputBytes", maxOutputBytes, Number.MAX_SAFE_INTEGER]
-  ].find(
-    ([, value, max]) => typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > Number(max)
-  );
-  if (invalidLimit) {
-    const [name, value, max] = invalidLimit;
-    return Promise.resolve(
-      fail(
-        "spawn-error",
-        `${name} must be a number from 0 to ${max}, got ${String(value)}`
-      )
-    );
-  }
-  if (input.length > maxInputBytes) {
-    return Promise.resolve(
-      fail(
-        "input-too-large",
-        `input is ${input.length} bytes, over the ${maxInputBytes} byte limit`
-      )
-    );
-  }
-  let args;
-  try {
-    args = sandboxedChildArgs(argsOptions);
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    return Promise.resolve(fail("spawn-error", message));
-  }
-  return new Promise((resolve) => {
-    let settled = false;
-    let stderr = "";
-    const stderrTail = () => stderr.slice(-MAX_STDERR_CHARS);
-    let child;
-    const settle = (result) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timer);
-      resolve(result);
-    };
-    let killedFor = null;
-    const kill = (failure, message) => {
-      if (killedFor || settled) {
-        return;
-      }
-      killedFor = { failure, message };
-      clearTimeout(timer);
-      child?.kill("SIGKILL");
-    };
-    const timer = setTimeout(
-      () => kill("timeout", `timed out after ${timeoutMs} ms`),
-      timeoutMs
-    );
-    try {
-      child = spawn(process.execPath, args, {
-        // Nothing of the parent's environment: no database URL, no keys
-        env: {},
-        cwd: cwd ?? path.dirname(fs.realpathSync(argsOptions.script)),
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true
-      });
-    } catch (e) {
-      const message = e instanceof Error ? e.message : String(e);
-      settle(fail("spawn-error", message));
-      return;
-    }
-    const output = [];
-    let outputSize = 0;
-    child.stdout?.on("data", (chunk) => {
-      if (settled || killedFor) {
-        return;
-      }
-      outputSize += chunk.length;
-      if (outputSize > maxOutputBytes) {
-        kill(
-          "output-too-large",
-          `output is over the ${maxOutputBytes} byte limit`
-        );
-        return;
-      }
-      output.push(chunk);
-    });
-    child.stderr?.setEncoding("utf8");
-    child.stderr?.on("data", (chunk) => {
-      stderr = (stderr + chunk).slice(-MAX_STDERR_CHARS * 2);
-    });
-    child.on("error", (e) => {
-      if (child?.pid === void 0) {
-        settle(fail("spawn-error", e.message, { stderr: stderrTail() }));
-      }
-    });
-    child.on("exit", (exitCode, signal) => {
-      if (killedFor) {
-        settle(
-          fail(killedFor.failure, killedFor.message, {
-            stderr: stderrTail(),
-            exitCode,
-            signal
-          })
-        );
-      }
-    });
-    child.on("close", (exitCode, signal) => {
-      if (killedFor) {
-        settle(
-          fail(killedFor.failure, killedFor.message, {
-            stderr: stderrTail(),
-            exitCode,
-            signal
-          })
-        );
-        return;
-      }
-      if (exitCode === 0) {
-        settle({
-          ok: true,
-          output: Buffer.concat(output),
-          stderr: stderrTail()
-        });
-        return;
-      }
-      const lastLine = stderrTail().trim().split("\n").filter((line) => line.trim()).pop() ?? "";
-      settle(
-        fail(
-          "exit",
-          `exited with ${exitCode ?? signal}${lastLine ? `: ${lastLine}` : ""}`,
-          { stderr: stderrTail(), exitCode, signal }
-        )
-      );
-    });
-    child.stdin?.on("error", () => {
-    });
-    child.stdin?.end(input);
-  });
-};
-export {
-  DEFAULT_SANDBOX_HEAP_MB,
-  DEFAULT_SANDBOX_MAX_INPUT_BYTES,
-  DEFAULT_SANDBOX_MAX_OUTPUT_BYTES,
-  DEFAULT_SANDBOX_TIMEOUT_MS,
-  runSandboxedChild,
-  sandboxedChildArgs
-};

package/dist/sandbox/sandboxPackages.d.ts

@@ -1,16 +0,0 @@
-/**
- * The folders a sandboxed child needs to read to import `packages` from
- * `fromFile` (its script): each package's folder and, recursively, those
- * of its `dependencies` and installed `optionalDependencies` and
- * `peerDependencies`, each resolved from the folder of the package that
- * needs it, as Node will at run time. That covers nested versions, pnpm's
- * layout and native packages' platform binaries (`@img/sharp-<platform>`)
- * without naming a platform. Optional and peer dependencies that aren't
- * installed are skipped; a missing package or regular dependency throws.
- *
- * A package reached through a symlink is granted at both paths: Node reads
- * its `package.json` through the path it looked in, and its modules
- * through their real paths.
- */
-export declare const sandboxPackagePaths: (packages: string[], fromFile: string) => string[];
-//# sourceMappingURL=sandboxPackages.d.ts.map

package/dist/sandbox/sandboxPackages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sandboxPackages.d.ts","sourceRoot":"","sources":["../../src/sandbox/sandboxPackages.ts"],"names":[],"mappings":"AAoDA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,GAAI,UAAU,MAAM,EAAE,EAAE,UAAU,MAAM,aAuCvE,CAAA"}

package/dist/sandbox/sandboxPackages.js

@@ -1,63 +0,0 @@
-import fs from "node:fs";
-import { createRequire } from "node:module";
-import path from "node:path";
-const findPackage = (name, fromFile) => {
-  const passed = [];
-  for (const dir of createRequire(fromFile).resolve.paths(name) ?? []) {
-    const found = path.join(dir, name);
-    if (!fs.existsSync(path.join(found, "package.json"))) {
-      if (path.basename(dir) === "node_modules" && fs.existsSync(dir)) {
-        passed.push(
-          path.join(dir, name, "package.json"),
-          path.join(fs.realpathSync(dir), name, "package.json")
-        );
-      }
-      continue;
-    }
-    const realDir = fs.realpathSync(found);
-    const pkg = JSON.parse(
-      fs.readFileSync(path.join(realDir, "package.json"), "utf8")
-    );
-    return { found, realDir, pkg, passed };
-  }
-  return null;
-};
-const sandboxPackagePaths = (packages, fromFile) => {
-  const paths = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const visit = (name, from, required, by) => {
-    const found = findPackage(name, from);
-    if (!found) {
-      if (required) {
-        throw new Error(
-          `Can't find package "${name}" (needed by ${by}) in any node_modules folder Node looks in from ${path.dirname(from)}`
-        );
-      }
-      return;
-    }
-    paths.add(found.found).add(found.realDir);
-    for (const manifest2 of found.passed) {
-      paths.add(manifest2);
-    }
-    if (visited.has(found.realDir)) {
-      return;
-    }
-    visited.add(found.realDir);
-    const manifest = path.join(found.realDir, "package.json");
-    const { dependencies = {}, optionalDependencies = {} } = found.pkg;
-    const optional = { ...optionalDependencies, ...found.pkg.peerDependencies };
-    for (const dep of Object.keys(dependencies)) {
-      visit(dep, manifest, !(dep in optional), name);
-    }
-    for (const dep of Object.keys(optional)) {
-      visit(dep, manifest, false, name);
-    }
-  };
-  for (const name of packages) {
-    visit(name, fromFile, true, path.basename(fromFile));
-  }
-  return [...paths];
-};
-export {
-  sandboxPackagePaths
-};