@mosetta/tar 0.0.0-stage → 0.0.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mosetta contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,4 @@
-# Temporary Holding Version
+# @mosetta/tar
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A small tar reader and writer (ustar) with no dependencies — how builds and releases travel between
+a publisher, a platform's API and its build container.

package/package.json

@@ -1,6 +1,16 @@
 {
   "name": "@mosetta/tar",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.10",
+  "license": "MIT",
+  "description": "Portable tar and gzip with no dependencies: a ustar/pax/GNU-longname reader, a deterministic ustar writer, and gzip over Web streams. Runs unchanged in node, workerd and the browser.",
+  "type": "module",
+  "files": [
+    "src"
+  ],
+  "exports": {
+    ".": "./src/tar.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/src/tar.d.mts

@@ -0,0 +1,18 @@
+// Types for the tar module: this package ships plain JS on purpose (it runs untranspiled in
+// isolates and in node), so its types live beside it — a consumer must not have to declare
+// them again. They used to be an ambient shim inside @mosetta/server, invisible to everyone else.
+
+export interface ITarEntry {
+  name: string;
+  data: Uint8Array;
+}
+
+export function parseTar(bytes: Uint8Array): ITarEntry[];
+
+// The producers allocate their own buffer — the narrow `ArrayBuffer` parameter keeps the result
+// usable everywhere a BodyInit is expected (a plain `Uint8Array` is `ArrayBufferLike` and is not).
+export function writeTar(entries: ITarEntry[]): Uint8Array<ArrayBuffer>;
+
+export function gzip(bytes: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+
+export function gunzip(bytes: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;

package/src/tar.mjs

@@ -0,0 +1,127 @@
+/**
+ * Tar with no dependencies and no node (build-action): exactly the slice of the format the
+ * build body needs — read GitHub/registry archives and assemble the outer container.
+ *
+ * Reader: ustar (including the prefix field), pax `path=` headers (how GitHub and modern tar
+ * write long names) and GNU longname 'L'. Directories and special files are skipped — the tree
+ * is derived from file names. Writer: ustar with long-name splitting into prefix and a ZERO
+ * mtime — the archive is deterministic by content.
+ *
+ * Compression — standard Web streams (`CompressionStream`/`DecompressionStream`, present in
+ * both workerd and node): no runtime compilation and no native modules by construction.
+ */
+
+const BLOCK = 512;
+const td = new TextDecoder();
+const te = new TextEncoder();
+
+function str(bytes, off, len) {
+  let end = off;
+  const max = off + len;
+  while (end < max && bytes[end] !== 0) end++;
+  return td.decode(bytes.subarray(off, end));
+}
+
+function octal(bytes, off, len) {
+  const s = str(bytes, off, len).trim();
+  return s ? parseInt(s, 8) : 0;
+}
+
+/** File entries of the archive: [{ name, data: Uint8Array }]. */
+export function parseTar(bytes) {
+  const entries = [];
+  let pos = 0;
+  let longName = null; // name from a pax/'L' entry — applies to the NEXT entry
+  while (pos + BLOCK <= bytes.length) {
+    const block = bytes.subarray(pos, pos + BLOCK);
+    if (block.every((b) => b === 0)) break;
+    const size = octal(bytes, pos + 124, 12);
+    const type = String.fromCharCode(bytes[pos + 156] || 0x30);
+    let name = str(bytes, pos, 100);
+    const prefix = str(bytes, pos + 345, 155);
+    if (prefix) name = `${prefix}/${name}`;
+    const data = bytes.subarray(pos + BLOCK, pos + BLOCK + size);
+    pos += BLOCK + Math.ceil(size / BLOCK) * BLOCK;
+    if (type === 'L') {
+      longName = td.decode(data).replace(/\0+$/, '');
+      continue;
+    }
+    if (type === 'x' || type === 'g') {
+      const m = /(?:^|\n)\d+ path=([^\n]*)\n/.exec(td.decode(data));
+      if (type === 'x' && m) longName = m[1];
+      continue;
+    }
+    if (longName) {
+      name = longName;
+      longName = null;
+    }
+    if (type === '0') entries.push({ name, data });
+  }
+  return entries;
+}
+
+function headerFor(name, size) {
+  const h = new Uint8Array(BLOCK);
+  let base = name;
+  let prefix = '';
+  if (te.encode(name).length > 100) {
+    // ustar split: the last slash where the tail fits into 100 and the head into 155
+    const parts = name.split('/');
+    for (let i = 1; i < parts.length; i++) {
+      const head = parts.slice(0, i).join('/');
+      const tail = parts.slice(i).join('/');
+      if (te.encode(tail).length <= 100 && te.encode(head).length <= 155) {
+        prefix = head;
+        base = tail;
+      }
+    }
+    if (!prefix) throw new Error(`name does not fit into ustar: ${name}`);
+  }
+  const put = (s, off) => h.set(te.encode(s), off);
+  put(base, 0);
+  put('0000644\0', 100);
+  put('0000000\0', 108);
+  put('0000000\0', 116);
+  put(`${size.toString(8).padStart(11, '0')}\0`, 124);
+  put('00000000000\0', 136); // mtime = 0: archive determinism
+  put('        ', 148); // the checksum is computed with spaces in its place
+  put('0', 156);
+  put('ustar\0' + '00', 257);
+  put(prefix, 345);
+  let sum = 0;
+  for (const b of h) sum += b;
+  put(`${sum.toString(8).padStart(6, '0')}\0 `, 148);
+  return h;
+}
+
+/** Assemble an archive from [{ name, data: Uint8Array }]. */
+export function writeTar(entries) {
+  const parts = [];
+  for (const { name, data } of entries) {
+    parts.push(headerFor(name, data.length), data);
+    const pad = (BLOCK - (data.length % BLOCK)) % BLOCK;
+    if (pad) parts.push(new Uint8Array(pad));
+  }
+  parts.push(new Uint8Array(BLOCK * 2));
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const out = new Uint8Array(total);
+  let pos = 0;
+  for (const p of parts) {
+    out.set(p, pos);
+    pos += p.length;
+  }
+  return out;
+}
+
+async function pipe(bytes, stream) {
+  const res = new Response(new Blob([bytes]).stream().pipeThrough(stream));
+  return new Uint8Array(await res.arrayBuffer());
+}
+
+export function gunzip(bytes) {
+  return pipe(bytes, new DecompressionStream('gzip'));
+}
+
+export function gzip(bytes) {
+  return pipe(bytes, new CompressionStream('gzip'));
+}