@nimbus-sh/worker 0.2.0 → 0.2.2

package/scripts/bundle-runtime.mjs

@@ -7,6 +7,13 @@
  *   node scripts/bundle-runtime.mjs clang binji-2020 [--bucket nimbus-runtime-cache]
  *   node scripts/bundle-runtime.mjs python 0.29.4 [--bucket nimbus-runtime-cache]
  *   node scripts/bundle-runtime.mjs --pin-catalog        (read-only; publishes nothing)
+ *   node scripts/bundle-runtime.mjs bash 5.2.37 --npm-package <dir>   (local; no R2)
+ *
+ * `--npm-package` is the SECOND publisher for the same artifacts: it stages
+ * exactly what the R2 path stages, composes the same manifest bytes, and lays
+ * the blobs out under the same content-addressed keys — into a directory that
+ * `npm publish` takes, for the embedders who have npm and no bucket. It reads
+ * nothing from Cloudflare and writes nothing to it. See §--npm-package below.
  *
  * Per `2026-05-10-true-os/plan.md` §2.4:
  *   - Blobs are content-addressed under `blobs/<name>-<version>/<sha256>/<file>`.
@@ -45,10 +52,6 @@ import { tmpdir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 
 const ACCOUNT = process.env.CLOUDFLARE_ACCOUNT_ID;
-if (!ACCOUNT) {
-  console.error('ERROR: CLOUDFLARE_ACCOUNT_ID env var required');
-  process.exit(1);
-}
 // Resolve the wrangler bin from either the package-local or the
 // repo-root node_modules (this script runs from packages/worker but
 // the bin is hoisted to the workspace root).
@@ -62,6 +65,7 @@ const PYODIDE_WORKERD_ADAPTER = JSON.parse(
 
 const USAGE =
   'usage: bundle-runtime.mjs <name> <version> [--bucket <bucket>]\n' +
+  '       bundle-runtime.mjs <name> <version> --npm-package <dir>\n' +
   '       bundle-runtime.mjs --pin-catalog [--bucket <bucket>]';
 
 /** The bucket the deployed Worker's NIMBUS_RUNTIME_CACHE binding points at.
@@ -74,12 +78,25 @@ const rawArgs = process.argv.slice(2);
 const positionalArgs = [];
 let BUCKET = process.env.NIMBUS_RUNTIME_BUCKET || PRODUCTION_BUCKET;
 let PIN_ONLY = false;
+let NPM_OUT_DIR = null;
 for (let i = 0; i < rawArgs.length; i++) {
   const arg = rawArgs[i];
   if (arg === '--pin-catalog') {
     PIN_ONLY = true;
     continue;
   }
+  if (arg === '--npm-package') {
+    NPM_OUT_DIR = rawArgs[++i];
+    if (!NPM_OUT_DIR) {
+      console.error(USAGE);
+      process.exit(2);
+    }
+    continue;
+  }
+  if (arg.startsWith('--npm-package=')) {
+    NPM_OUT_DIR = arg.slice('--npm-package='.length);
+    continue;
+  }
   if (arg === '--bucket') {
     const value = rawArgs[++i];
     if (!value) {
@@ -96,6 +113,12 @@ for (let i = 0; i < rawArgs.length; i++) {
   positionalArgs.push(arg);
 }
 
+// Every mode but `--npm-package` reads or writes R2 through wrangler.
+if (!NPM_OUT_DIR && !ACCOUNT) {
+  console.error('ERROR: CLOUDFLARE_ACCOUNT_ID env var required');
+  process.exit(1);
+}
+
 // `--pin-catalog` regenerates the build-time root of trust from the catalog
 // already in R2. Read-only: it publishes nothing, so it is safe to run at any
 // time, including while another ingest is in flight against a different bucket.
@@ -127,6 +150,15 @@ const SPECS = {
     license: 'Apache-2.0-with-LLVM-exception',
     wasi_namespace: 'wasi_unstable',
     upstream_base: 'https://raw.githubusercontent.com/binji/wasm-clang/master',
+    npm: {
+      name: '@nimbus-sh/runtime-clang',
+      summary: 'clang 8.0.1 and wasm-ld for wasm32-wasi, with a wasi-libc sysroot',
+      // npm demands semver and this runtime's Nimbus version is a channel
+      // name, so the compiler's own version is what the package carries. The
+      // two namespaces stay separate: the manifest still says `binji-2020`,
+      // and that is what the install root under ~/.nimbus/runtimes is named.
+      version: '8.0.1',
+    },
     files: [
       { src: 'clang',       vfs: 'bin/clang',                  mode: 'exec',   runner: 'clang-runner', binName: 'clang' },
       { src: 'lld',         vfs: 'bin/wasm-ld',                mode: 'exec',   runner: 'clang-runner', binName: 'wasm-ld', kind: 'linker' },
@@ -154,6 +186,10 @@ const SPECS = {
     license: 'Ruby+BSD-2-Clause',
     wasi_namespace: 'wasi_snapshot_preview1',
     upstream_base: 'https://registry.npmjs.org/@ruby/3.3-wasm-wasi/-/3.3-wasm-wasi-2.9.3-2.9.4.tgz',
+    npm: {
+      name: '@nimbus-sh/runtime-ruby',
+      summary: 'Ruby 3.3.4 (ruby.wasm) for wasm32-wasi, with its stdlib packed in',
+    },
     tarball_extract: 'package/dist',  // strip this prefix from src paths inside the tarball
     files: [
       // The Ruby wasm — includes Ruby 3.3.x interpreter + stdlib packed
@@ -194,6 +230,10 @@ const SPECS = {
     license: 'GPL-3.0-or-later AND GPL-2.0-only',
     wasi_namespace: 'wasi_snapshot_preview1',
     local_base: '../wasm/bash',
+    npm: {
+      name: '@nimbus-sh/runtime-bash',
+      summary: 'GNU bash 5.2.37 and BusyBox 1.37.0, cross-compiled to wasm32-wasi',
+    },
     files: [
       { src: 'bash.async.wasm',           vfs: 'share/bash/bash.async.wasm' },
       { src: 'coreutils/busybox.wasm',    vfs: 'share/bash/coreutils/busybox.wasm' },
@@ -271,6 +311,10 @@ const SPECS = {
     license: 'PSF-2.0',
     wasi_namespace: 'wasi_snapshot_preview1',
     local_base: '../wasm/python',
+    npm: {
+      name: '@nimbus-sh/runtime-cpython',
+      summary: 'CPython 3.13.14, cross-compiled to wasm32-wasi, with its stdlib',
+    },
     files: [
       { src: 'python.wasm',   vfs: 'share/cpython/python.wasm' },
       // The same interpreter with numpy and markupsafe's C speedups linked in,
@@ -383,6 +427,19 @@ if (!spec) {
   console.error(`known: ${Object.keys(SPECS).join(', ')}`);
   process.exit(2);
 }
+// Checked before anything is staged: which runtimes we publish to npm is a
+// decision, and a spec that has not made it should cost nothing to find out.
+if (NPM_OUT_DIR) {
+  if (!spec.npm) {
+    console.error(`ERROR: ${key} declares no npm package in its spec.`);
+    console.error('       Add an `npm: { name, summary }` entry to publish it that way.');
+    process.exit(2);
+  }
+  if (spec.ingest_only) {
+    console.error(`ERROR: ${key} is ingest_only — it has no manifest to publish.`);
+    process.exit(2);
+  }
+}
 
 const workDir = join(tmpdir(), `bundle-runtime-${RUNTIME}-${VERSION}`);
 rmSync(workDir, { recursive: true, force: true });
@@ -390,8 +447,12 @@ mkdirSync(workDir, { recursive: true });
 
 console.log(`[bundle-runtime] ${RUNTIME} ${VERSION}`);
 console.log(`[bundle-runtime] work dir: ${workDir}`);
-console.log(`[bundle-runtime] bucket:   ${BUCKET}`);
-console.log(`[bundle-runtime] account:  ${ACCOUNT}`);
+if (NPM_OUT_DIR) {
+  console.log(`[bundle-runtime] target:   ${NPM_OUT_DIR} (npm package; R2 is not read or written)`);
+} else {
+  console.log(`[bundle-runtime] bucket:   ${BUCKET}`);
+  console.log(`[bundle-runtime] account:  ${ACCOUNT}`);
+}
 
 // ── 0. Optional repackage step (sysroot-prep wave) ──────────────────
 // Runs BEFORE the fetch loop. Produces one or more local files inside
@@ -480,6 +541,19 @@ if (!spec.ingest_only) {
   console.log(`[bundle-runtime]   LICENSE → ${licenseBytes.length} bytes sha256=${licenseSha256.slice(0, 16)}…`);
 }
 
+const totalMb = (downloaded.reduce((a, f) => a + f.size, 0) / 1024 / 1024).toFixed(2);
+
+// ── --npm-package: the same artifacts, published through npm ────────
+// Everything above this line is the staging the R2 path performs, and
+// everything below it is Cloudflare. A runtime package is the staged blobs
+// under their content-addressed keys plus the manifest that names them, which
+// is the R2 bucket's shape for one runtime, in a directory `npm publish`
+// takes. Nothing here reads or writes R2.
+if (NPM_OUT_DIR) {
+  writeNpmPackage(NPM_OUT_DIR, composeManifest(downloaded, packageRuntimeArtifacts), downloaded);
+  process.exit(0);
+}
+
 // ── 2. Upload each file as a content-addressed blob (deduped) ──────
 // Content path: blobs/<name>-<version>/<sha256>/<src-name>. Multiple
 // manifest entries pointing at identical content share one R2 upload.
@@ -497,8 +571,6 @@ for (const f of downloaded) {
 // ── 3 + 4. Manifest + catalog. Skipped in ingest_only mode (the swap
 // wave composes those at manifest-compose time; this prep pass only
 // stages the upstream blobs).
-const totalMb = (downloaded.reduce((a, f) => a + f.size, 0) / 1024 / 1024).toFixed(2);
-
 if (spec.ingest_only) {
   console.log(`\n[bundle-runtime] DONE (ingest_only)`);
   console.log(`[bundle-runtime] uploaded ${downloaded.length} file(s) (${totalMb} MiB) for ${RUNTIME}@${VERSION}`);
@@ -507,43 +579,8 @@ if (spec.ingest_only) {
   console.log(`[bundle-runtime] catalog:  UNCHANGED (swap wave will flip default)`);
 } else {
   // ── 3. Write the per-version manifest ────────────────────────────
-  const runtimeArtifacts = downloaded
-    .filter((f) => f.transformMetadata)
-    .map((f) => ({
-      path: f.vfs,
-      kind: f.transformMetadata.kind,
-      id: f.transformMetadata.id,
-      source_sha256: f.transformMetadata.source_sha256,
-      sha256: f.sha256,
-    }));
-  runtimeArtifacts.push(...packageRuntimeArtifacts);
-
-  const manifest = {
-    name: RUNTIME,
-    version: VERSION,
-    license: spec.license,
-    wasi_namespace: spec.wasi_namespace || null,
-    files: downloaded.map((f) => ({
-      path: f.vfs,
-      content: f.r2Key,
-      sha256: f.sha256,
-      size: f.size,
-      ...(f.mode ? { mode: f.mode } : {}),
-    })),
-    entrypoints: spec.files
-      .filter((f) => f.runner)
-      .map((f) => ({
-        binName: f.binName,
-        runner: f.runner,
-        args: [],
-        ...(f.kind ? { kind: f.kind } : {}),
-      })),
-    ...(runtimeArtifacts.length ? { runtime_artifacts: runtimeArtifacts } : {}),
-  };
-
   const manifestLocal = join(workDir, 'manifest.json');
-  const manifestText = JSON.stringify(manifest, null, 2);
-  writeFileSync(manifestLocal, manifestText);
+  writeFileSync(manifestLocal, manifestText(composeManifest(downloaded, packageRuntimeArtifacts)));
   // Digest of the exact bytes uploaded below. The catalog carries it so the
   // supervisor can verify a manifest the same way a manifest lets it verify
   // a blob — see the trust-model note in src/runtime/runtime-catalog.ts.
@@ -788,6 +825,201 @@ function pinCatalogFromR2() {
   }
 }
 
+// ── The manifest ─────────────────────────────────────────────────────
+//
+// What a runtime IS: the files it is made of, the digest of each, and the
+// commands they answer. Both publishers compose it here so an embedder who
+// installed the npm package and a session that ran `nimbus install` are
+// holding the same description of the same runtime, byte for byte.
+
+function composeManifest(downloaded, packageRuntimeArtifacts) {
+  const runtimeArtifacts = downloaded
+    .filter((f) => f.transformMetadata)
+    .map((f) => ({
+      path: f.vfs,
+      kind: f.transformMetadata.kind,
+      id: f.transformMetadata.id,
+      source_sha256: f.transformMetadata.source_sha256,
+      sha256: f.sha256,
+    }));
+  runtimeArtifacts.push(...packageRuntimeArtifacts);
+
+  return {
+    name: RUNTIME,
+    version: VERSION,
+    license: spec.license,
+    wasi_namespace: spec.wasi_namespace || null,
+    files: downloaded.map((f) => ({
+      path: f.vfs,
+      content: f.r2Key,
+      sha256: f.sha256,
+      size: f.size,
+      ...(f.mode ? { mode: f.mode } : {}),
+    })),
+    entrypoints: spec.files
+      .filter((f) => f.runner)
+      .map((f) => ({
+        binName: f.binName,
+        runner: f.runner,
+        args: [],
+        ...(f.kind ? { kind: f.kind } : {}),
+      })),
+    ...(runtimeArtifacts.length ? { runtime_artifacts: runtimeArtifacts } : {}),
+  };
+}
+
+function manifestText(manifest) {
+  return JSON.stringify(manifest, null, 2);
+}
+
+// ── --npm-package ────────────────────────────────────────────────────
+
+/**
+ * Write the runtime as a directory `npm publish` accepts.
+ *
+ * The blobs keep the keys the manifest already names — `blobs/<name>-<version>/
+ * <sha256>/<file>`, the R2 object keys — so the manifest needs no npm-specific
+ * rewrite and comes out byte-identical to the one in the bucket. That is the
+ * point rather than a coincidence: `content` is documented as the publisher's
+ * key for a blob, and for this publisher a path inside its own tarball IS that
+ * key. There is one manifest format and one layout, and `readBlob` below is
+ * the whole of what distinguishes the two publishers.
+ */
+function writeNpmPackage(outDir, manifest, downloaded) {
+  rmSync(outDir, { recursive: true, force: true });
+  mkdirSync(outDir, { recursive: true });
+
+  const written = new Set();
+  let unpackedBytes = 0;
+  for (const f of downloaded) {
+    if (written.has(f.r2Key)) continue;
+    written.add(f.r2Key);
+    unpackedBytes += f.size;
+    const dest = join(outDir, f.r2Key);
+    mkdirSync(dirname(dest), { recursive: true });
+    writeFileSync(dest, f.bytes);
+  }
+
+  writeFileSync(join(outDir, 'manifest.json'), manifestText(manifest));
+  writeFileSync(join(outDir, 'LICENSE'), spec.license_text);
+  writeFileSync(join(outDir, 'index.js'), runtimePackageEntry());
+  writeFileSync(join(outDir, 'index.d.ts'), runtimePackageTypes());
+  writeFileSync(join(outDir, 'README.md'), runtimePackageReadme());
+  const npmVersion = spec.npm.version ?? VERSION;
+  writeFileSync(join(outDir, 'package.json'), `${JSON.stringify({
+    name: spec.npm.name,
+    version: npmVersion,
+    description: `${spec.npm.summary}, as a Nimbus runtime package.`,
+    keywords: ['nimbus', 'wasm', 'wasi', 'runtime', RUNTIME],
+    homepage: 'https://github.com/AshishKumar4/Nimbus',
+    // No `directory`: the package is built from the runtime spec and the wasm
+    // build tree, and has no source directory of its own to point at.
+    repository: { type: 'git', url: 'git+https://github.com/AshishKumar4/Nimbus.git' },
+    bugs: 'https://github.com/AshishKumar4/Nimbus/issues',
+    license: spec.license,
+    type: 'module',
+    main: './index.js',
+    types: './index.d.ts',
+    exports: {
+      '.': { types: './index.d.ts', import: './index.js' },
+      './manifest.json': './manifest.json',
+      './package.json': './package.json',
+    },
+    files: ['index.js', 'index.d.ts', 'manifest.json', 'blobs', 'LICENSE', 'README.md'],
+    // The runtime is inert without the half that installs and runs it, and
+    // `index.d.ts` types itself against that package's exports.
+    peerDependencies: { '@nimbus-sh/core': '>=0.2.0' },
+    publishConfig: { access: 'public' },
+  }, null, 2)}\n`);
+
+  console.log(`\n[bundle-runtime] DONE (npm package)`);
+  console.log(`[bundle-runtime] ${spec.npm.name}@${npmVersion} → ${outDir}`);
+  console.log(`[bundle-runtime] ${written.size} blobs, ${(unpackedBytes / 1024 / 1024).toFixed(2)} MiB unpacked`);
+  console.log(`[bundle-runtime] publish with: npm publish ${outDir}`);
+  console.log(`[bundle-runtime] R2: UNTOUCHED (nothing was read from or written to Cloudflare)`);
+}
+
+/**
+ * The package entry point, identical in every runtime package.
+ *
+ * It is the `RuntimePackage` port from `@nimbus-sh/core`: a manifest, and the
+ * bytes it names. Core verifies every blob against the manifest before it
+ * reaches a filesystem, so this side neither hashes nor validates — it reads.
+ */
+function runtimePackageEntry() {
+  return `/**
+ * A Nimbus runtime package: a manifest, and the content-addressed blobs it
+ * names. Pass the default export to \`NimbusWorkspace.create({ runtimes })\`
+ * and the runtime installs into the workspace filesystem, digest-verified,
+ * at the same path \`nimbus install\` uses on Cloudflare.
+ *
+ * Generated by packages/worker/scripts/bundle-runtime.mjs. Do not edit.
+ */
+
+import { readFileSync } from 'node:fs';
+
+const root = new URL('./', import.meta.url);
+
+export const manifest = JSON.parse(readFileSync(new URL('manifest.json', root), 'utf8'));
+
+/** The bytes of one manifest file entry, by the publisher key it carries. */
+export function readBlob(file) {
+  // Copied rather than handed over: readFileSync returns a pooled Buffer for
+  // small files, whose backing ArrayBuffer holds other files' bytes too.
+  return new Uint8Array(readFileSync(new URL(file.content, root)));
+}
+
+export default { manifest, readBlob };
+`;
+}
+
+function runtimePackageTypes() {
+  return `import type { ManifestFile, RuntimeManifest, RuntimePackage } from '@nimbus-sh/core';
+
+export declare const manifest: RuntimeManifest;
+export declare function readBlob(file: ManifestFile): Uint8Array;
+
+declare const runtimePackage: RuntimePackage;
+export default runtimePackage;
+`;
+}
+
+function runtimePackageReadme() {
+  return `# ${spec.npm.name}
+
+${spec.npm.summary}, packaged for [Nimbus](https://github.com/AshishKumar4/Nimbus).
+
+This package is data: the runtime's wasm and support files, content-addressed,
+plus the manifest that describes them. It does nothing on its own —
+[\`@nimbus-sh/core\`](https://www.npmjs.com/package/@nimbus-sh/core) installs it
+into a workspace filesystem and runs it.
+
+\`\`\`bash
+npm install @nimbus-sh/core ${spec.npm.name}
+\`\`\`
+
+\`\`\`js
+import { NimbusWorkspace, localFacetHost } from '@nimbus-sh/core';
+import ${RUNTIME} from '${spec.npm.name}';
+
+const workspace = await NimbusWorkspace.create({
+  sql,                       // your SQLite, through the SqlDatabase port
+  facets: localFacetHost(),
+  runtimes: [${RUNTIME}],
+});
+\`\`\`
+
+Every file is verified against the manifest's SHA-256 before it reaches the
+filesystem. The same bytes are served to Cloudflare deployments from R2 by
+\`nimbus install ${RUNTIME}\`, under the same manifest.
+
+## Licence
+
+${spec.license}. See the bundled \`LICENSE\` for the notice and where to find
+the full text and corresponding source.
+`;
+}
+
 // ── Runtime transforms ───────────────────────────────────────────────
 
 function runtimeBlobKey(src, sha256) {

package/dist/npm/tarball-stream.d.ts

@@ -1,93 +0,0 @@
-/**
- * npm-tarball-stream.ts — pure streaming tar primitives.
- *
- * Extracted from npm-tarball.ts so these helpers can be esbuild-bundled
- * WITHOUT dragging in NpmCache / NpmResolver / SqliteVFS. Consumed by
- * scripts/bundle-facet-workers.mjs which emits a string constant the
- * NimbusLoaderPool uses to inject the tar parser into dynamic workers.
- *
- * Zero dependencies. Works identically on the supervisor and inside a
- * facet isolate. Never buffers the full decompressed tarball — peak
- * transient heap is one file's bytes plus a 512-byte carry.
- */
-/**
- * Maximum size of a single file inside a tarball. Larger entries are skipped.
- *
- * History: 5 MB was too low — it silently dropped `esbuild-wasm/esbuild.wasm`
- * (11.35 MB on v0.24.2), which made Nimbus-in-Nimbus `npm run dev` fail with
- * `No such module "esbuild-wasm/esbuild.wasm"` since the missing file caused
- * esbuild's VFS plugin to mark the import `external`, and workerd's LOADER
- * has no entry for that specifier. 20 MB covers esbuild-wasm with headroom
- * while keeping per-facet peak heap bounded for the streaming extractor.
- */
-export declare const MAX_FILE_BYTES = 20000000;
-/**
- * Read one tar header (USTAR) out of `block`. Returns parsed fields or
- * `null` for an end-of-archive block (all zeros).
- */
-/**
- * Collapse "."/".." segments in a tar entry's package-relative path.
- * Returns the canonical relative path, or '' when the entry escapes its
- * package root (a leading ".." that pops above the root) — the caller
- * treats '' as a no-name entry and skips it. Mirrors the segment logic in
- * w7-frame's canonicalPath so joined write paths are always accepted.
- */
-export declare function canonicalTarName(name: string): string;
-export declare function parseTarHeader(block: Uint8Array): {
-    name: string;
-    size: number;
-    typeFlag: number;
-} | null;
-/**
- * Wrap a `ReadableStream<Uint8Array>` as an async iterable. Workerd and
- * Node both support `Symbol.asyncIterator` on ReadableStream, but we
- * spell the reader loop out so we don't depend on ambient lib typings.
- */
-export declare function readableStreamToAsyncIterable(rs: ReadableStream<Uint8Array>): AsyncGenerator<Uint8Array, void, undefined>;
-/**
- * Reason a tar entry was skipped and never yielded. Surfaced to callers
- * via the optional `onSkip` callback on `streamTarEntries`.
- *
- * - 'too-large': size > MAX_FILE_BYTES. The most common reason Nimbus
- *   cares about — it's what caused esbuild-wasm/esbuild.wasm to vanish
- *   silently in Nimbus-in-Nimbus before the cap was raised.
- * - 'non-regular': typeFlag indicates a symlink / hardlink / directory /
- *   PaxHeader / GNU LongName etc. These aren't files we stage.
- * - 'no-name': header parsed but name was empty (malformed or a PaxHeader
- *   that our parser didn't recognize as non-regular).
- */
-export type TarSkipReason = 'too-large' | 'non-regular' | 'no-name';
-/**
- * Optional skip-observer passed to `streamTarEntries`. Called ONCE per
- * skipped entry, with the declared name (may be empty for 'no-name'
- * skips) and the declared size in bytes.
- *
- * Consumers typically push these into a per-package warnings array so
- * users see what wasn't installed. The callback is synchronous and
- * must not throw — thrown errors are swallowed to keep the extractor
- * best-effort.
- */
-export type TarSkipCallback = (name: string, size: number, reason: TarSkipReason) => void;
-/**
- * Streaming tar extractor.
- *
- * Consumes an async iterable of Uint8Array chunks (the decompressed tar
- * byte stream) and yields one `{ name, data }` entry per regular file,
- * as each file completes.
- *
- * Memory invariant: holds at most one pending file's bytes (≤ MAX_FILE_BYTES)
- * plus a small carry buffer for the tar header being assembled.
- *
- * Skips: symlinks, directories, hardlinks, long-name extensions (PaxHeader),
- * and any file whose declared size exceeds MAX_FILE_BYTES.
- *
- * If `onSkip` is provided, it is invoked for each skipped entry with the
- * name, declared size, and reason code. Callers that need to surface
- * dropped-file warnings to users should pass one; legacy callers that
- * omit the arg still behave exactly as before (silent skip).
- */
-export declare function streamTarEntries(source: AsyncIterable<Uint8Array>, onSkip?: TarSkipCallback): AsyncGenerator<{
-    name: string;
-    data: Uint8Array;
-}, void, undefined>;
-//# sourceMappingURL=tarball-stream.d.ts.map

package/dist/npm/tarball-stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tarball-stream.d.ts","sourceRoot":"","sources":["../../src/npm/tarball-stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,WAAa,CAAC;AAEzC;;;GAGG;AACH;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAWrD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA+BzG;AAED;;;;GAIG;AACH,wBAAuB,6BAA6B,CAClD,EAAE,EAAE,cAAc,CAAC,UAAU,CAAC,GAC7B,cAAc,CAAC,UAAU,EAAE,IAAI,EAAE,SAAS,CAAC,CAW7C;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,CAAC;AAEpE;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,GAAG,CAC5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,KAClB,IAAI,CAAC;AAEV;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAuB,gBAAgB,CACrC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,EACjC,MAAM,CAAC,EAAE,eAAe,GACvB,cAAc,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,EAAE,IAAI,EAAE,SAAS,CAAC,CA6GrE"}