tywrap 0.5.1 → 0.6.1

package/src/utils/codec.ts

@@ -40,7 +40,7 @@ export interface SklearnEstimator {
   params: Record<string, unknown>;
 }
 
-export type CodecEnvelope =
+export type ValueEnvelope =
   | {
       readonly __tywrap__: 'dataframe';
       readonly codecVersion?: number;
@@ -337,7 +337,7 @@ function reshapeArray(flat: unknown[], shape: readonly number[]): unknown {
 // Why: decoding needs to reject incompatible envelopes before we attempt to interpret payloads.
 const CODEC_VERSION = 1;
 
-function assertCodecVersion(envelope: { codecVersion?: unknown }, marker: string): void {
+function assertCodecVersion(envelope: { codecVersion?: unknown }, typeTag: string): void {
   if (!('codecVersion' in envelope)) {
     return;
   }
@@ -346,235 +346,256 @@ function assertCodecVersion(envelope: { codecVersion?: unknown }, marker: string
     return;
   }
   if (typeof version !== 'number' || !Number.isFinite(version)) {
-    throw new Error(`Invalid ${marker} envelope: codecVersion must be a number`);
+    throw new Error(`Invalid ${typeTag} envelope: codecVersion must be a number`);
   }
   if (version !== CODEC_VERSION) {
-    throw new Error(`Unsupported ${marker} envelope codecVersion: ${version}`);
+    throw new Error(`Unsupported ${typeTag} envelope codecVersion: ${version}`);
   }
 }
 
-function decodeEnvelopeCore<T>(
-  value: unknown,
+/**
+ * Per-typeTag decode handler.
+ *
+ * Why: each scientific value envelope type (dataframe, series, ndarray, scipy.sparse,
+ * torch.tensor, sklearn.estimator) has its own validation and decode logic. Splitting
+ * the dispatch into one handler per type keeps each branch focused and testable while
+ * preserving byte-identical decoded output.
+ */
+type EnvelopeHandler = <T>(
+  value: { [k: string]: unknown },
   decodeArrow: (bytes: Uint8Array) => MaybePromise<T>,
   recurse: (value: unknown) => MaybePromise<T | unknown>
-): MaybePromise<T | unknown> {
-  if (!isObject(value)) {
-    return value;
-  }
-  const marker = (value as { __tywrap__?: unknown }).__tywrap__;
-  if (typeof marker !== 'string') {
-    return value as unknown;
-  }
+) => MaybePromise<T | unknown>;
 
-  if (
-    marker === 'dataframe' ||
-    marker === 'series' ||
-    marker === 'ndarray' ||
-    marker === 'scipy.sparse' ||
-    marker === 'torch.tensor' ||
-    marker === 'sklearn.estimator'
-  ) {
-    assertCodecVersion(value as { codecVersion?: unknown }, marker);
-  }
-
-  if (marker === 'dataframe') {
-    const encoding = (value as { encoding?: unknown }).encoding;
-    if (encoding === 'arrow') {
-      const b64 = (value as { b64?: unknown }).b64;
-      if (typeof b64 !== 'string') {
-        throw new Error('Invalid dataframe envelope: missing b64');
-      }
-      const bytes = fromBase64(b64);
-      return decodeArrow(bytes);
-    }
-    if (encoding === 'json') {
-      if (!('data' in (value as object))) {
-        throw new Error('Invalid dataframe envelope: missing data');
-      }
-      return (value as { data: unknown }).data;
+/**
+ * Decode an Arrow-or-JSON envelope (dataframe / series).
+ *
+ * Why: dataframe and series share identical arrow/json handling; the only difference
+ * is the typeTag name used in error messages.
+ */
+function decodeArrowOrJsonEnvelope<T>(
+  value: { [k: string]: unknown },
+  decodeArrow: (bytes: Uint8Array) => MaybePromise<T>,
+  typeTag: string
+): MaybePromise<T | unknown> {
+  const encoding = value.encoding;
+  if (encoding === 'arrow') {
+    const b64 = value.b64;
+    if (typeof b64 !== 'string') {
+      throw new Error(`Invalid ${typeTag} envelope: missing b64`);
     }
-    throw new Error(`Invalid dataframe envelope: unsupported encoding ${String(encoding)}`);
+    const bytes = fromBase64(b64);
+    return decodeArrow(bytes);
   }
-
-  if (marker === 'series') {
-    const encoding = (value as { encoding?: unknown }).encoding;
-    if (encoding === 'arrow') {
-      const b64 = (value as { b64?: unknown }).b64;
-      if (typeof b64 !== 'string') {
-        throw new Error('Invalid series envelope: missing b64');
-      }
-      const bytes = fromBase64(b64);
-      return decodeArrow(bytes);
+  if (encoding === 'json') {
+    if (!('data' in value)) {
+      throw new Error(`Invalid ${typeTag} envelope: missing data`);
     }
-    if (encoding === 'json') {
-      if (!('data' in (value as object))) {
-        throw new Error('Invalid series envelope: missing data');
-      }
-      return (value as { data: unknown }).data;
-    }
-    throw new Error(`Invalid series envelope: unsupported encoding ${String(encoding)}`);
+    return value.data;
   }
+  throw new Error(`Invalid ${typeTag} envelope: unsupported encoding ${String(encoding)}`);
+}
 
-  if (marker === 'ndarray') {
-    const encoding = (value as { encoding?: unknown }).encoding;
-    const shapeValue = (value as { shape?: unknown }).shape;
-    const shape = isNumberArray(shapeValue) ? shapeValue : undefined;
+const decodeDataframeEnvelope: EnvelopeHandler = (value, decodeArrow) =>
+  decodeArrowOrJsonEnvelope(value, decodeArrow, 'dataframe');
 
-    if (encoding === 'arrow') {
-      const b64 = (value as { b64?: unknown }).b64;
-      if (typeof b64 !== 'string') {
-        throw new Error('Invalid ndarray envelope: missing b64');
-      }
-      const bytes = fromBase64(b64);
-      const decoded = decodeArrow(bytes);
-
-      // Extract values from Arrow table and reshape if needed
-      // Arrow only handles 1D arrays, so we flatten on encode and reshape here
-      // Reshape for: scalars (shape.length === 0) and multi-dim (shape.length > 1)
-      // Skip reshape for: 1D arrays (shape.length === 1) - return as-is
-      if (isPromiseLike(decoded)) {
-        return decoded.then(data => {
-          const values = extractArrowValues(data);
-          if (!values) {
-            return data; // Fallback: return raw data if extraction fails
-          }
-          // Reshape scalars and multi-dimensional arrays, but not 1D
-          if (shape && shape.length !== 1) {
-            return reshapeArray(values, shape);
-          }
-          return values;
-        });
-      }
-      const values = extractArrowValues(decoded);
-      if (!values) {
-        return decoded; // Fallback: return raw data if extraction fails
-      }
-      // Reshape scalars and multi-dimensional arrays, but not 1D
-      if (shape && shape.length !== 1) {
-        return reshapeArray(values, shape);
-      }
-      return values;
-    }
-    if (encoding === 'json') {
-      if (!('data' in (value as object))) {
-        throw new Error('Invalid ndarray envelope: missing data');
-      }
-      return (value as { data: unknown }).data;
-    }
-    throw new Error(`Invalid ndarray envelope: unsupported encoding ${String(encoding)}`);
-  }
+const decodeSeriesEnvelope: EnvelopeHandler = (value, decodeArrow) =>
+  decodeArrowOrJsonEnvelope(value, decodeArrow, 'series');
 
-  if (marker === 'scipy.sparse') {
-    const encoding = (value as { encoding?: unknown }).encoding;
-    if (encoding !== 'json') {
-      throw new Error(`Invalid scipy.sparse envelope: unsupported encoding ${String(encoding)}`);
+const decodeNdarrayEnvelope: EnvelopeHandler = (value, decodeArrow) => {
+  const encoding = value.encoding;
+  const shapeValue = value.shape;
+  const shape = isNumberArray(shapeValue) ? shapeValue : undefined;
+
+  if (encoding === 'arrow') {
+    const b64 = value.b64;
+    if (typeof b64 !== 'string') {
+      throw new Error('Invalid ndarray envelope: missing b64');
     }
-    const format = (value as { format?: unknown }).format;
-    if (format !== 'csr' && format !== 'csc' && format !== 'coo') {
-      throw new Error(`Invalid scipy.sparse envelope: unsupported format ${String(format)}`);
+    const bytes = fromBase64(b64);
+    const decoded = decodeArrow(bytes);
+
+    // Extract values from Arrow table and reshape if needed
+    // Arrow only handles 1D arrays, so we flatten on encode and reshape here
+    // Reshape for: scalars (shape.length === 0) and multi-dim (shape.length > 1)
+    // Skip reshape for: 1D arrays (shape.length === 1) - return as-is
+    if (isPromiseLike(decoded)) {
+      return decoded.then(data => {
+        const values = extractArrowValues(data);
+        if (!values) {
+          return data; // Fallback: return raw data if extraction fails
+        }
+        // Reshape scalars and multi-dimensional arrays, but not 1D
+        if (shape && shape.length !== 1) {
+          return reshapeArray(values, shape);
+        }
+        return values;
+      });
     }
-    const shape = (value as { shape?: unknown }).shape;
-    if (
-      !Array.isArray(shape) ||
-      shape.length !== 2 ||
-      typeof shape[0] !== 'number' ||
-      typeof shape[1] !== 'number'
-    ) {
-      throw new Error('Invalid scipy.sparse envelope: shape must be a 2-item number[]');
+    const values = extractArrowValues(decoded);
+    if (!values) {
+      return decoded; // Fallback: return raw data if extraction fails
     }
-    const data = (value as { data?: unknown }).data;
-    if (!Array.isArray(data)) {
-      throw new Error('Invalid scipy.sparse envelope: data must be an array');
+    // Reshape scalars and multi-dimensional arrays, but not 1D
+    if (shape && shape.length !== 1) {
+      return reshapeArray(values, shape);
     }
-    const dtypeValue = (value as { dtype?: unknown }).dtype;
-    const dtype = typeof dtypeValue === 'string' ? dtypeValue : undefined;
-
-    if (format === 'coo') {
-      const row = (value as { row?: unknown }).row;
-      const col = (value as { col?: unknown }).col;
-      if (!Array.isArray(row) || !Array.isArray(col)) {
-        throw new Error('Invalid scipy.sparse envelope: coo requires row and col arrays');
-      }
-      return {
-        format,
-        shape,
-        data,
-        row,
-        col,
-        dtype,
-      } satisfies SparseMatrix;
+    return values;
+  }
+  if (encoding === 'json') {
+    if (!('data' in value)) {
+      throw new Error('Invalid ndarray envelope: missing data');
     }
+    return value.data;
+  }
+  throw new Error(`Invalid ndarray envelope: unsupported encoding ${String(encoding)}`);
+};
 
-    const indices = (value as { indices?: unknown }).indices;
-    const indptr = (value as { indptr?: unknown }).indptr;
-    if (!Array.isArray(indices) || !Array.isArray(indptr)) {
-      throw new Error('Invalid scipy.sparse envelope: csr/csc requires indices and indptr arrays');
+const decodeScipySparseEnvelope: EnvelopeHandler = value => {
+  const encoding = value.encoding;
+  if (encoding !== 'json') {
+    throw new Error(`Invalid scipy.sparse envelope: unsupported encoding ${String(encoding)}`);
+  }
+  const format = value.format;
+  if (format !== 'csr' && format !== 'csc' && format !== 'coo') {
+    throw new Error(`Invalid scipy.sparse envelope: unsupported format ${String(format)}`);
+  }
+  const shape = value.shape;
+  if (
+    !Array.isArray(shape) ||
+    shape.length !== 2 ||
+    typeof shape[0] !== 'number' ||
+    typeof shape[1] !== 'number'
+  ) {
+    throw new Error('Invalid scipy.sparse envelope: shape must be a 2-item number[]');
+  }
+  const data = value.data;
+  if (!Array.isArray(data)) {
+    throw new Error('Invalid scipy.sparse envelope: data must be an array');
+  }
+  const dtypeValue = value.dtype;
+  const dtype = typeof dtypeValue === 'string' ? dtypeValue : undefined;
+
+  if (format === 'coo') {
+    const row = value.row;
+    const col = value.col;
+    if (!Array.isArray(row) || !Array.isArray(col)) {
+      throw new Error('Invalid scipy.sparse envelope: coo requires row and col arrays');
     }
     return {
       format,
       shape,
       data,
-      indices,
-      indptr,
+      row,
+      col,
       dtype,
     } satisfies SparseMatrix;
   }
 
-  if (marker === 'torch.tensor') {
-    const encoding = (value as { encoding?: unknown }).encoding;
-    if (encoding !== 'ndarray') {
-      throw new Error(`Invalid torch.tensor envelope: unsupported encoding ${String(encoding)}`);
-    }
-    if (!('value' in (value as object))) {
-      throw new Error('Invalid torch.tensor envelope: missing value');
-    }
-    const nested = (value as { value: unknown }).value;
-    if (!isObject(nested) || (nested as { __tywrap__?: unknown }).__tywrap__ !== 'ndarray') {
-      throw new Error('Invalid torch.tensor envelope: value must be an ndarray envelope');
-    }
-    const decoded = recurse(nested);
-    const shapeValue = (value as { shape?: unknown }).shape;
-    const shape = isNumberArray(shapeValue) ? shapeValue : undefined;
-    const dtypeValue = (value as { dtype?: unknown }).dtype;
-    const dtype = typeof dtypeValue === 'string' ? dtypeValue : undefined;
-    const deviceValue = (value as { device?: unknown }).device;
-    const device = typeof deviceValue === 'string' ? deviceValue : undefined;
+  const indices = value.indices;
+  const indptr = value.indptr;
+  if (!Array.isArray(indices) || !Array.isArray(indptr)) {
+    throw new Error('Invalid scipy.sparse envelope: csr/csc requires indices and indptr arrays');
+  }
+  return {
+    format,
+    shape,
+    data,
+    indices,
+    indptr,
+    dtype,
+  } satisfies SparseMatrix;
+};
+
+const decodeTorchTensorEnvelope: EnvelopeHandler = <T>(
+  value: { [k: string]: unknown },
+  _decodeArrow: (bytes: Uint8Array) => MaybePromise<T>,
+  recurse: (value: unknown) => MaybePromise<T | unknown>
+): MaybePromise<T | unknown> => {
+  const encoding = value.encoding;
+  if (encoding !== 'ndarray') {
+    throw new Error(`Invalid torch.tensor envelope: unsupported encoding ${String(encoding)}`);
+  }
+  if (!('value' in value)) {
+    throw new Error('Invalid torch.tensor envelope: missing value');
+  }
+  const nested = value.value;
+  if (!isObject(nested) || (nested as { __tywrap__?: unknown }).__tywrap__ !== 'ndarray') {
+    throw new Error('Invalid torch.tensor envelope: value must be an ndarray envelope');
+  }
+  const decoded = recurse(nested);
+  const shapeValue = value.shape;
+  const shape = isNumberArray(shapeValue) ? shapeValue : undefined;
+  const dtypeValue = value.dtype;
+  const dtype = typeof dtypeValue === 'string' ? dtypeValue : undefined;
+  const deviceValue = value.device;
+  const device = typeof deviceValue === 'string' ? deviceValue : undefined;
 
-    if (isPromiseLike(decoded)) {
-      return decoded.then(data => ({ data, shape, dtype, device })) as Promise<T | unknown>;
-    }
-    return { data: decoded, shape, dtype, device } satisfies TorchTensor;
+  if (isPromiseLike(decoded)) {
+    return decoded.then(data => ({ data, shape, dtype, device })) as Promise<T | unknown>;
   }
+  return { data: decoded, shape, dtype, device } satisfies TorchTensor;
+};
 
-  if (marker === 'sklearn.estimator') {
-    const encoding = (value as { encoding?: unknown }).encoding;
-    if (encoding !== 'json') {
-      throw new Error(
-        `Invalid sklearn.estimator envelope: unsupported encoding ${String(encoding)}`
-      );
-    }
-    const className = (value as { className?: unknown }).className;
-    const module = (value as { module?: unknown }).module;
-    const params = (value as { params?: unknown }).params;
-    if (typeof className !== 'string' || typeof module !== 'string' || !isObject(params)) {
-      throw new Error(
-        'Invalid sklearn.estimator envelope: expected className/module strings + params object'
-      );
-    }
-    const versionValue = (value as { version?: unknown }).version;
-    if (versionValue !== undefined && typeof versionValue !== 'string') {
-      throw new Error('Invalid sklearn.estimator envelope: version must be a string when provided');
-    }
-    const version = typeof versionValue === 'string' ? versionValue : undefined;
-    return {
-      className,
-      module,
-      version,
-      params,
-    } satisfies SklearnEstimator;
+const decodeSklearnEstimatorEnvelope: EnvelopeHandler = value => {
+  const encoding = value.encoding;
+  if (encoding !== 'json') {
+    throw new Error(`Invalid sklearn.estimator envelope: unsupported encoding ${String(encoding)}`);
+  }
+  const className = value.className;
+  const module = value.module;
+  const params = value.params;
+  if (typeof className !== 'string' || typeof module !== 'string' || !isObject(params)) {
+    throw new Error(
+      'Invalid sklearn.estimator envelope: expected className/module strings + params object'
+    );
+  }
+  const versionValue = value.version;
+  if (versionValue !== undefined && typeof versionValue !== 'string') {
+    throw new Error('Invalid sklearn.estimator envelope: version must be a string when provided');
+  }
+  const version = typeof versionValue === 'string' ? versionValue : undefined;
+  return {
+    className,
+    module,
+    version,
+    params,
+  } satisfies SklearnEstimator;
+};
+
+// Why: dispatch over the __tywrap__ typeTag instead of a long if-chain so each type's
+// decode logic lives in one focused handler. The typeTag strings are the on-the-wire keys
+// emitted by the Python bridge and MUST stay byte-identical. A Map keyed by the typeTag
+// avoids prototype-chain lookups when dispatching on attacker-controlled typeTag strings.
+const ENVELOPE_HANDLERS: ReadonlyMap<string, EnvelopeHandler> = new Map([
+  ['dataframe', decodeDataframeEnvelope],
+  ['series', decodeSeriesEnvelope],
+  ['ndarray', decodeNdarrayEnvelope],
+  ['scipy.sparse', decodeScipySparseEnvelope],
+  ['torch.tensor', decodeTorchTensorEnvelope],
+  ['sklearn.estimator', decodeSklearnEstimatorEnvelope],
+]);
+
+function decodeEnvelopeCore<T>(
+  value: unknown,
+  decodeArrow: (bytes: Uint8Array) => MaybePromise<T>,
+  recurse: (value: unknown) => MaybePromise<T | unknown>
+): MaybePromise<T | unknown> {
+  if (!isObject(value)) {
+    return value;
+  }
+  const typeTag = (value as { __tywrap__?: unknown }).__tywrap__;
+  if (typeof typeTag !== 'string') {
+    return value as unknown;
+  }
+
+  const handler = ENVELOPE_HANDLERS.get(typeTag);
+  if (!handler) {
+    return value as unknown;
   }
 
-  return value as unknown;
+  assertCodecVersion(value as { codecVersion?: unknown }, typeTag);
+  return handler(value, decodeArrow, recurse);
 }
 
 function decodeEnvelope<T>(value: unknown, decodeArrow: (bytes: Uint8Array) => T): T | unknown {

package/src/utils/python.ts

@@ -44,30 +44,43 @@ export function getDefaultPythonPath(): string {
   return getPythonExecutableName();
 }
 
+/**
+ * Whether the configured pythonPath is the default interpreter (or unset),
+ * meaning a virtual environment lookup should take precedence.
+ */
+function usesDefaultPython(pythonPath: string | undefined): boolean {
+  return !pythonPath || pythonPath === 'python3' || pythonPath === 'python';
+}
+
+/**
+ * Resolve the Python executable inside a virtual environment, preferring the
+ * Node path module when available and falling back to cross-runtime pathUtils.
+ */
+async function resolveVenvPython(virtualEnv: string, cwd: string): Promise<string> {
+  const binDir = getVenvBinDir();
+  const exe = getVenvPythonExe();
+  const pathMod = await loadNodePathModule();
+
+  if (pathMod) {
+    const venvRoot = pathMod.resolve(cwd, virtualEnv);
+    return pathMod.join(venvRoot, binDir, exe);
+  }
+
+  const venvRoot = isAbsolutePath(virtualEnv)
+    ? pathUtils.join(virtualEnv)
+    : pathUtils.join(cwd, virtualEnv);
+  return pathUtils.join(venvRoot, binDir, exe);
+}
+
 export async function resolvePythonExecutable(options: PythonResolveOptions = {}): Promise<string> {
   const pythonPath = options.pythonPath?.trim();
   const virtualEnv = options.virtualEnv?.trim();
 
-  if (virtualEnv) {
-    const usesDefaultPython = !pythonPath || pythonPath === 'python3' || pythonPath === 'python';
-    if (usesDefaultPython) {
-      const cwd =
-        options.cwd ??
-        (typeof process !== 'undefined' && typeof process.cwd === 'function' ? process.cwd() : '.');
-      const binDir = getVenvBinDir();
-      const exe = getVenvPythonExe();
-      const pathMod = await loadNodePathModule();
-
-      if (pathMod) {
-        const venvRoot = pathMod.resolve(cwd, virtualEnv);
-        return pathMod.join(venvRoot, binDir, exe);
-      }
-
-      const venvRoot = isAbsolutePath(virtualEnv)
-        ? pathUtils.join(virtualEnv)
-        : pathUtils.join(cwd, virtualEnv);
-      return pathUtils.join(venvRoot, binDir, exe);
-    }
+  if (virtualEnv && usesDefaultPython(pythonPath)) {
+    const cwd =
+      options.cwd ??
+      (typeof process !== 'undefined' && typeof process.cwd === 'function' ? process.cwd() : '.');
+    return resolveVenvPython(virtualEnv, cwd);
   }
 
   if (pythonPath) {

package/src/utils/runtime.ts

@@ -229,26 +229,37 @@ async function loadPathModule(): Promise<PathModule | null> {
   return null;
 }
 
+/**
+ * Apply a single path segment to the accumulated normalized segments,
+ * resolving '..' and dropping '.'/empty segments in place.
+ */
+function applyPathSegment(normalized: string[], segment: string, isAbsolute: boolean): void {
+  if (segment === '.' || segment === '') {
+    return; // Skip current directory and empty segments
+  }
+
+  if (segment !== '..') {
+    normalized.push(segment);
+    return;
+  }
+
+  // '..' segment: go up one directory when possible.
+  if (normalized.length > 0 && normalized[normalized.length - 1] !== '..') {
+    normalized.pop();
+  } else if (!isAbsolute) {
+    normalized.push(segment); // Keep '..' if not absolute and at root
+  }
+}
+
 /**
  * Normalize path by stripping '.' and resolving '..' components
  */
 function normalizePath(path: string): string {
   const isAbsolute = path.startsWith('/');
-  const segments = path.split('/');
   const normalized: string[] = [];
 
-  for (const segment of segments) {
-    if (segment === '.' || segment === '') {
-      continue; // Skip current directory and empty segments
-    } else if (segment === '..') {
-      if (normalized.length > 0 && normalized[normalized.length - 1] !== '..') {
-        normalized.pop(); // Go up one directory
-      } else if (!isAbsolute) {
-        normalized.push(segment); // Keep '..' if not absolute and at root
-      }
-    } else {
-      normalized.push(segment);
-    }
+  for (const segment of path.split('/')) {
+    applyPathSegment(normalized, segment, isAbsolute);
   }
 
   const result = normalized.join('/');

package/src/version.ts

@@ -0,0 +1,12 @@
+/**
+ * AUTO-GENERATED — DO NOT EDIT.
+ *
+ * Source: package.json (version field)
+ * Generator: scripts/generate-version.mjs (runs in `npm run build`)
+ *
+ * Single-sources the package version so the public API can re-export it without
+ * importing package.json from outside tsconfig `rootDir`.
+ * Regenerate with: node scripts/generate-version.mjs
+ */
+
+export const VERSION: string = "0.6.1";

package/dist/runtime/http-io.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"http-io.d.ts","sourceRoot":"","sources":["../../src/runtime/http-io.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAQH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAMhD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAEhB,oDAAoD;IACpD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC,mEAAmE;IACnE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,MAAO,YAAW,SAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,EAAE,aAAa;IAclC;;;;;OAKG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;;OAIG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B;;;;OAIG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAMD;;;;;;;;;;;;OAYG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAwGrF;;OAEG;YACW,YAAY;CAO3B"}

package/dist/runtime/http-io.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"http-io.js","sourceRoot":"","sources":["../../src/runtime/http-io.ts"],"names":[],"mappings":"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"}

package/dist/runtime/optimized-node.d.ts

@@ -1,23 +0,0 @@
-/**
- * @deprecated Import from './node.js' instead.
- *
- * Backward-compat shim for older deep imports. NodeBridge is the public API,
- * and it now supports both single-process mode (default) and multi-process
- * pooling via the minProcesses/maxProcesses options.
- *
- * Migration:
- * ```typescript
- * // Before
- * import { OptimizedNodeBridge, ProcessPoolOptions } from './optimized-node.js';
- * const bridge = new OptimizedNodeBridge({ minProcesses: 2, maxProcesses: 4 });
- *
- * // After
- * import { NodeBridge, NodeBridgeOptions } from './node.js';
- * const bridge = new NodeBridge({ minProcesses: 2, maxProcesses: 4 });
- * ```
- *
- * This file is not exposed through the package exports map and is maintained
- * for backward compatibility only.
- */
-export { NodeBridge as OptimizedNodeBridge, type NodeBridgeOptions as ProcessPoolOptions, } from './node.js';
-//# sourceMappingURL=optimized-node.d.ts.map

package/dist/runtime/optimized-node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"optimized-node.d.ts","sourceRoot":"","sources":["../../src/runtime/optimized-node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EACL,UAAU,IAAI,mBAAmB,EACjC,KAAK,iBAAiB,IAAI,kBAAkB,GAC7C,MAAM,WAAW,CAAC"}