rigline 1.0.0-alpha.11 → 1.0.0-alpha.13

package/README.md

@@ -10,8 +10,9 @@ rather than a breakage to chase.
 
 **This modifies files belonging to Anthropic's extension, on your machine, and that is your call to
 make.** [Anthropic compliance](https://github.com/Rigline/Rigline/blob/main/docs/anthropic-compliance.md)
-is a straight account of what Rigline does and does not do — no credentials, no network calls, no
-rerouting of Claude usage, no redistribution — and how we read Anthropic's terms. `rigline restore`
+is a straight account of what Rigline does to that extension and what it does not — no credentials,
+no network calls from the panel, no rerouting of Claude usage, no redistribution — and how we read
+Anthropic's terms. `rigline restore`
 puts every install back to Anthropic's own bytes and needs nothing but Node.
 
 ## Install
@@ -21,7 +22,8 @@ puts every install back to Anthropic's own bytes and needs nothing but Node.
 
 The first command you run fetches the engine, [`@rigline/core`](https://www.npmjs.com/package/@rigline/core),
 into `~/.rigline/engine` and runs it from there. It takes a few seconds and needs the registry;
-after that nothing reaches the network unless you ask it to. If that directory is ever in a bad
+after that nothing reaches the network unless you ask it to, or install the companion below, which
+asks the registry for a newer engine each time a window starts. If that directory is ever in a bad
 state, delete it and run any command again.
 
 `install` finds every installed version of the extension, harvests it, bakes the discovered plugins
@@ -39,12 +41,15 @@ directory until *Developer: Reload Window*.
     rigline vscode-setup
 
 If running `install` after every update is a chore, this installs a companion extension that does it
-for you — into every VS Code found on your `PATH`, Insiders, VSCodium, Cursor and Windsurf included,
-from a VSIX that ships inside the engine. Nothing is downloaded, and the companion moves when the
-engine does. It injects as it goes, so it is a step *instead of* `install` rather than after it.
+for you — into VS Code, found on your `PATH`, from a VSIX that ships inside the engine. Nothing is
+downloaded, and the companion moves when the engine does. It injects as it goes, so it is a step
+*instead of* `install` rather than after it.
 
 From then on it watches for the extension update and re-injects behind it, so there is nothing to
-remember after one.
+remember after one. It goes into every VS Code profile that has Claude Code, and into any profile
+that gets Claude Code later; the `companion` settings in
+[`~/.rigline/config.yaml`](https://github.com/Rigline/Rigline/blob/main/docs/config.md) keep it out
+of the profiles you name.
 
 **Decline it and lose nothing.** `install` remains complete on its own, and is the right answer if
 you would rather not add an extension, cannot install one, or simply prefer running the thing
@@ -83,10 +88,11 @@ going back is one command.
 
 ## How it is put together
 
-`rigline` is a small retrieval layer. It fetches bytes — a plugin tarball, the engine — checks them,
-and hands them over; `@rigline/core` does everything else and answers every verb above. The split is
-not decoration: a process cannot replace the package it is running out of, so whatever performs an
-update has to sit above the thing being updated.
+`rigline` is a small retrieval layer. It installs the engine and runs it, and `@rigline/core` answers
+every verb above, fetching plugins included. The split is not decoration: a process cannot replace
+the package it is running out of, so `update` moves the engine from here and then hands the rest to
+it. Nothing updates `rigline` itself, so when the engine you have is newer, `rigline` says so and
+names the command.
 
 **It belongs in no project's dependencies.** If you are writing plugins, your workspace declares
 `@rigline/core` and runs `rigline-engine`; `npm create rigline-plugin` scaffolds it that way. A

package/dist/commands.js

@@ -0,0 +1,61 @@
+import { ENGINE_PACKAGE, engineDir, ensureEngine, formatEngineUpdate, handOffProblem, newerWrapper, readEngineState, riglineHome, updateEngine, wrapperVersion, } from "./engine.js";
+import { UserError } from "./errors.js";
+export function splitUpdateArgs(args) {
+    let tag;
+    let now = false;
+    const forward = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--") {
+            forward.push(...args.slice(i));
+            break;
+        }
+        if (arg === "--tag" || arg.startsWith("--tag=")) {
+            tag = arg === "--tag" ? args[++i] : arg.slice("--tag=".length);
+            if (tag === undefined || tag === "")
+                throw new UserError("--tag needs a dist-tag");
+            continue;
+        }
+        if (arg === "--now")
+            now = true;
+        forward.push(arg);
+    }
+    return { ...(tag === undefined ? {} : { tag }), now, forward };
+}
+export async function updateCommand(args, options = {}) {
+    const { tag, now, forward } = splitUpdateArgs(args);
+    const given = {
+        ...options,
+        registry: { ...options.registry, ignoreReleaseAge: now },
+    };
+    const moved = await updateEngine({ ...given, ...(tag === undefined ? {} : { tag }) });
+    console.log(formatEngineUpdate(moved, options.home ?? riglineHome()));
+    const engine = await ensureEngine(given);
+    const wrapper = options.version ?? wrapperVersion();
+    const problem = handOffProblem(wrapper, engine.version);
+    if (problem !== null)
+        throw new UserError(problem);
+    notice(engine.version, wrapper);
+    const code = await engine.run(["update", ...forward]);
+    return moved.outcome === "failed" ? 1 : code;
+}
+export function notice(engine, wrapper = wrapperVersion()) {
+    const line = newerWrapper(wrapper, engine);
+    if (line !== null)
+        console.error(line);
+}
+export function versionCommand() {
+    const prefix = engineDir();
+    const state = readEngineState(prefix);
+    const wrapper = wrapperVersion();
+    console.log(`rigline ${wrapper}`);
+    console.log(state.kind === "none"
+        ? `engine: none in ${prefix} — the next command installs one`
+        : `engine: ${ENGINE_PACKAGE} ${state.version} in ${prefix}` +
+            (state.kind === "unusable" ? ` (unusable: ${state.why})` : ""));
+    const newer = state.kind === "none" ? null : newerWrapper(wrapper, state.version);
+    if (newer !== null)
+        console.log(newer);
+    return 0;
+}
+//# sourceMappingURL=commands.js.map

package/dist/engine.js

@@ -61,6 +61,61 @@ export function majorProblem(wrapper, engine) {
     return (`rigline ${ours}.x cannot run engine ${theirs}.x (${ENGINE_PACKAGE} ${engine}). ` +
         "Run npm i -g rigline@latest.");
 }
+export function compareVersions(a, b) {
+    const x = parseVersion(a);
+    const y = parseVersion(b);
+    if (x === null || y === null)
+        return null;
+    for (let i = 0; i < 3; i++) {
+        const diff = x.release[i] - y.release[i];
+        if (diff !== 0)
+            return diff;
+    }
+    if (x.pre.length === 0 || y.pre.length === 0)
+        return y.pre.length - x.pre.length;
+    for (let i = 0; i < Math.max(x.pre.length, y.pre.length); i++) {
+        const p = x.pre[i];
+        const q = y.pre[i];
+        if (p === undefined)
+            return -1;
+        if (q === undefined)
+            return 1;
+        if (p === q)
+            continue;
+        const pNumeric = /^\d+$/.test(p);
+        const qNumeric = /^\d+$/.test(q);
+        if (pNumeric && qNumeric)
+            return Number(p) - Number(q);
+        if (pNumeric !== qNumeric)
+            return pNumeric ? -1 : 1;
+        return p < q ? -1 : 1;
+    }
+    return 0;
+}
+function parseVersion(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+    if (match === null)
+        return null;
+    return {
+        release: [Number(match[1]), Number(match[2]), Number(match[3])],
+        pre: match[4] === undefined ? [] : match[4].split("."),
+    };
+}
+export function newerWrapper(wrapper, engine) {
+    const order = compareVersions(engine, wrapper);
+    if (order === null || order <= 0)
+        return null;
+    return `rigline ${engine} is out, and this is ${wrapper}: npm i -g rigline@${engine}`;
+}
+const LAST_WITHOUT_UPDATE = "1.0.0-alpha.12";
+export function handOffProblem(wrapper, engine) {
+    const behind = compareVersions(engine, wrapper);
+    const old = compareVersions(engine, LAST_WITHOUT_UPDATE);
+    if (behind === null || old === null || behind >= 0 || old > 0)
+        return null;
+    return (`${ENGINE_PACKAGE} ${engine} does no update of its own, so no plugin was updated. ` +
+        `Run rigline update again once the engine has moved past ${LAST_WITHOUT_UPDATE}.`);
+}
 export function findNpmCli(execPath = process.execPath, exists = existsSync) {
     const here = dirname(execPath);
     const candidates = [
@@ -88,7 +143,7 @@ export function engineInstallArgv(options) {
         ...options.specs,
     ];
 }
-const nodeSpawn = (command, args, options) => spawn(command, [...args], { stdio: [...options.stdio] });
+const nodeSpawn = (command, args, options) => spawn(command, [...args], { stdio: [...options.stdio], windowsHide: true });
 export async function ensureEngine(options = {}) {
     const prefix = engineDir(options.home ?? riglineHome());
     const version = options.version ?? wrapperVersion();
@@ -108,7 +163,7 @@ export async function ensureEngine(options = {}) {
     const problem = majorProblem(version, resolved.version);
     if (problem !== null)
         throw new UserError(problem);
-    console.log(`rigline: installing the engine, ${ENGINE_PACKAGE} ${resolved.version}`);
+    console.error(`rigline: installing the engine, ${ENGINE_PACKAGE} ${resolved.version}`);
     await installEngine(prefix, `${ENGINE_PACKAGE}@${resolved.version}`, options);
     const installed = readEngineState(prefix);
     if (installed.kind !== "ready") {
@@ -145,23 +200,11 @@ function engineAt(state, options) {
             child.on("error", fail);
             child.on("close", (code) => done(code ?? 1));
         }),
-        json: async (argv) => {
-            const run = await capture(node, [state.entry, ...argv], spawnImpl, "inherit");
-            if (run.code !== 0) {
-                throw new UserError(`the engine exited ${run.code} for \`${argv.join(" ")}\``);
-            }
-            try {
-                return JSON.parse(run.output);
-            }
-            catch {
-                throw new UserError(`the engine answered \`${argv.join(" ")}\` with something that is not JSON`);
-            }
-        },
     };
 }
-async function capture(command, argv, spawnImpl = nodeSpawn, stderr = "pipe") {
+async function capture(command, argv, spawnImpl = nodeSpawn) {
     return await new Promise((done, fail) => {
-        const child = spawnImpl(command, argv, { stdio: ["ignore", "pipe", stderr] });
+        const child = spawnImpl(command, argv, { stdio: ["ignore", "pipe", "pipe"] });
         let output = "";
         child.stdout?.setEncoding("utf8");
         child.stdout?.on("data", (chunk) => {
@@ -198,6 +241,7 @@ export async function updateEngine(options = {}) {
         return {
             outcome: "failed",
             ...(installed === null ? {} : { from: installed }),
+            to: resolved.version,
             reason: problem,
         };
     }

package/dist/index.js

@@ -1,84 +1,18 @@
 #!/usr/bin/env node
-import { parseArgs } from "node:util";
-import { ENGINE_PACKAGE, engineDir, ensureEngine, formatEngineUpdate, readEngineState, updateEngine, wrapperVersion, } from "./engine.js";
+import { notice, updateCommand, versionCommand } from "./commands.js";
+import { ensureEngine } from "./engine.js";
 import { UserError } from "./errors.js";
-import { addFromNpm, formatUpdates, updatePlugins } from "./remote.js";
-function isPathSpec(spec) {
-    if (spec.startsWith("@"))
-        return false;
-    return spec.startsWith(".") || spec.includes("/") || spec.includes("\\");
-}
-async function addCommand(args) {
-    const { values, positionals } = parseArgs({
-        args,
-        options: { now: { type: "boolean", default: false } },
-        allowPositionals: true,
-    });
-    if (positionals.length !== 1) {
-        throw new UserError("add needs exactly one plugin directory or npm package");
-    }
-    const spec = positionals[0];
-    const engine = await ensureEngine();
-    if (isPathSpec(spec))
-        return await engine.run(["add", spec]);
-    return await addFromNpm({
-        spec,
-        engine: engine.run,
-        registry: { ignoreReleaseAge: values.now },
-    });
-}
-async function listed(engine) {
-    const answer = await engine.json(["list", "--json"]);
-    if (!Array.isArray(answer))
-        throw new UserError("the engine's plugin list was not a list");
-    return answer;
-}
-async function updateCommand(args) {
-    const { values, positionals } = parseArgs({
-        args,
-        options: { now: { type: "boolean", default: false }, tag: { type: "string" } },
-        allowPositionals: true,
-    });
-    const registry = { ignoreReleaseAge: values.now };
-    const engineUpdate = await updateEngine({ registry, ...(values.tag ? { tag: values.tag } : {}) });
-    console.log(formatEngineUpdate(engineUpdate));
-    const engine = await ensureEngine({ registry });
-    const updates = await updatePlugins({
-        listed: await listed(engine),
-        engine: engine.run,
-        ...(positionals.length > 0 ? { names: positionals } : {}),
-        registry,
-    });
-    let injected = 0;
-    if (engineUpdate.outcome === "moved" || engineUpdate.outcome === "installed") {
-        injected = await engine.run(["install"]);
-    }
-    console.log(formatUpdates(updates));
-    const failed = updates.some((u) => u.outcome === "failed") || engineUpdate.outcome === "failed";
-    return failed || injected !== 0 ? 1 : 0;
-}
-function versionCommand() {
-    const prefix = engineDir();
-    const state = readEngineState(prefix);
-    console.log(`rigline ${wrapperVersion()}`);
-    console.log(state.kind === "none"
-        ? `engine: none in ${prefix} — the next command installs one`
-        : `engine: ${ENGINE_PACKAGE} ${state.version} in ${prefix}` +
-            (state.kind === "unusable" ? ` (unusable: ${state.why})` : ""));
-    return 0;
-}
 async function main(argv) {
     const [command, ...rest] = argv;
     switch (command) {
         case "--version":
         case "-v":
             return versionCommand();
-        case "add":
-            return await addCommand(rest);
         case "update":
             return await updateCommand(rest);
         default: {
             const engine = await ensureEngine();
+            notice(engine.version);
             return await engine.run(argv);
         }
     }

package/dist/lock.js

@@ -1,4 +1,4 @@
-import { closeSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { closeSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
 import { UserError } from "./errors.js";
 const STALE_MS = 60_000;
@@ -31,12 +31,18 @@ function readHolder(path) {
         return null;
     }
 }
-export function isStale(holder, now, staleMs, isAlive) {
-    if (holder === null)
-        return true;
-    const since = Date.parse(holder.since);
+function writtenAt(path) {
+    try {
+        return statSync(path).mtimeMs;
+    }
+    catch {
+        return Number.NaN;
+    }
+}
+export function isStale(holder, fileTime, now, staleMs, isAlive) {
+    const since = holder === null ? fileTime : Date.parse(holder.since);
     const old = Number.isNaN(since) || now - since >= staleMs;
-    return old && !isAlive(holder.pid);
+    return old && (holder === null || !isAlive(holder.pid));
 }
 export class HomeLockedError extends UserError {
     holder;
@@ -69,7 +75,7 @@ export async function withHomeLock(options, work) {
             if (error.code !== "EEXIST")
                 throw error;
             const held = readHolder(path);
-            if (isStale(held, now(), staleMs, isAlive)) {
+            if (isStale(held, writtenAt(path), now(), staleMs, isAlive)) {
                 rmSync(path, { force: true });
                 continue;
             }

package/dist/registry.js

@@ -1,21 +1,6 @@
-import { createHash } from "node:crypto";
 import { UserError } from "./errors.js";
 export const DEFAULT_REGISTRY = "https://registry.npmjs.org";
 export const MINIMUM_RELEASE_AGE_MINUTES = 1440;
-export function parsePluginSpec(spec) {
-    const at = spec.lastIndexOf("@");
-    const scoped = spec.startsWith("@");
-    if (at <= 0 || (scoped && at === 0)) {
-        return { name: spec, version: null, tag: null };
-    }
-    const name = spec.slice(0, at);
-    const rest = spec.slice(at + 1);
-    if (rest.length === 0)
-        return { name, version: null, tag: null };
-    return /^\d+\.\d+\.\d+(?:[-+].*)?$/.test(rest)
-        ? { name, version: rest, tag: null }
-        : { name, version: null, tag: rest };
-}
 export async function resolveVersion(spec, options = {}) {
     const packument = await fetchPackument(spec.name, options);
     const tag = spec.version === null ? (spec.tag ?? "latest") : null;
@@ -41,33 +26,6 @@ export async function resolveVersion(spec, options = {}) {
         ageMinutes,
     };
 }
-export async function fetchTarball(resolved, options = {}) {
-    const response = await request(resolved.tarball, options);
-    const bytes = Buffer.from(await response.arrayBuffer());
-    const problem = integrityProblem(bytes, resolved.integrity);
-    if (problem !== null) {
-        throw new UserError(`${resolved.name}@${resolved.version} from ${resolved.tarball} ${problem}. ` +
-            "Nothing was written.");
-    }
-    return bytes;
-}
-export function integrityProblem(bytes, integrity) {
-    const dash = integrity.indexOf("-");
-    if (dash <= 0)
-        return `has an integrity string this cannot read ("${integrity}")`;
-    const algorithm = integrity.slice(0, dash);
-    const expected = integrity.slice(dash + 1);
-    let actual;
-    try {
-        actual = createHash(algorithm).update(bytes).digest("base64");
-    }
-    catch {
-        return `names a digest this cannot compute ("${algorithm}")`;
-    }
-    return actual === expected
-        ? null
-        : `does not match its recorded integrity (${algorithm}-${actual} against ${integrity})`;
-}
 export function releaseAgeProblem(resolved, options = {}) {
     if (options.ignoreReleaseAge)
         return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rigline",
-  "version": "1.0.0-alpha.11",
+  "version": "1.0.0-alpha.13",
   "description": "Install, update and develop plugins for the Claude Code VS Code extension",
   "keywords": [
     "rigline",

package/dist/remote.js

@@ -1,132 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { UserError } from "./errors.js";
-import { fetchTarball, parsePluginSpec, releaseAgeProblem, resolveVersion, } from "./registry.js";
-import { readPackageTarball } from "./tarball.js";
-export async function addFromNpm(options) {
-    const resolved = await resolveVersion(parsePluginSpec(options.spec), options.registry);
-    const withheld = releaseAgeProblem(resolved, options.registry);
-    if (withheld !== null)
-        throw new UserError(withheld);
-    return await stageAndAdd(resolved, options);
-}
-async function stageAndAdd(resolved, options) {
-    const label = `${resolved.name}@${resolved.version}`;
-    const files = readPackageTarball(await fetchTarball(resolved, options.registry), label);
-    const staged = mkdtempSync(join(tmpdir(), "rigline-add-"));
-    try {
-        for (const file of files) {
-            const target = join(staged, file.path);
-            mkdirSync(dirname(target), { recursive: true });
-            writeFileSync(target, file.bytes);
-        }
-        const source = {
-            kind: "npm",
-            name: resolved.name,
-            version: resolved.version,
-            tag: resolved.tag,
-            integrity: resolved.integrity,
-            addedAt: (options.now?.() ?? new Date()).toISOString(),
-        };
-        return await options.engine(["add", staged, "--source", JSON.stringify(source)]);
-    }
-    finally {
-        rmSync(staged, { recursive: true, force: true });
-    }
-}
-export async function updatePlugins(options) {
-    const managed = options.listed.filter((plugin) => plugin.managed);
-    const byName = new Map(managed.map((plugin) => [plugin.name, plugin]));
-    const names = options.names ?? managed.map((plugin) => plugin.name);
-    const updates = [];
-    for (const name of names) {
-        const plugin = byName.get(name);
-        if (plugin === undefined) {
-            updates.push({ name, outcome: "failed", reason: "not installed by rigline" });
-            continue;
-        }
-        const source = plugin.source;
-        if (source === null) {
-            updates.push({ name, outcome: "unmanaged" });
-            continue;
-        }
-        if (source.kind === "path") {
-            updates.push({
-                name,
-                outcome: "local",
-                reason: typeof source.from === "string" ? source.from : "a directory",
-            });
-            continue;
-        }
-        if (source.kind !== "npm") {
-            updates.push({ name, outcome: "unmanaged", reason: `source kind "${source.kind}"` });
-            continue;
-        }
-        if (source.name === undefined || source.version === undefined) {
-            updates.push({ name, outcome: "failed", reason: "its npm source is incomplete" });
-            continue;
-        }
-        if (source.tag === null || source.tag === undefined) {
-            updates.push({ name, outcome: "pinned", from: source.version });
-            continue;
-        }
-        updates.push(await updateOne(name, { name: source.name, version: source.version, tag: source.tag }, options));
-    }
-    return updates;
-}
-async function updateOne(name, source, options) {
-    try {
-        const resolved = await resolveVersion({ name: source.name, version: null, tag: source.tag }, options.registry);
-        if (resolved.version === source.version) {
-            return { name, outcome: "current", from: source.version };
-        }
-        const withheld = releaseAgeProblem(resolved, options.registry);
-        if (withheld !== null) {
-            return {
-                name,
-                outcome: "withheld",
-                from: source.version,
-                to: resolved.version,
-                reason: withheld,
-            };
-        }
-        const code = await stageAndAdd(resolved, options);
-        if (code !== 0) {
-            return { name, outcome: "failed", from: source.version, reason: `the engine exited ${code}` };
-        }
-        return { name, outcome: "updated", from: source.version, to: resolved.version };
-    }
-    catch (error) {
-        return {
-            name,
-            outcome: "failed",
-            from: source.version,
-            reason: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-export function formatUpdates(updates) {
-    if (updates.length === 0)
-        return "no plugins to update — the bundled ones move with the engine";
-    return updates.map(updateLine).join("\n");
-}
-function updateLine(update) {
-    switch (update.outcome) {
-        case "updated":
-            return `${update.name}: ${update.from} -> ${update.to}`;
-        case "current":
-            return `${update.name}: ${update.from}, which is what its tag resolves to`;
-        case "pinned":
-            return `${update.name}: pinned to ${update.from}; add it again to move it`;
-        case "local":
-            return `${update.name}: added from ${update.reason}; run rigline add again to refresh it`;
-        case "unmanaged":
-            return `${update.name}: placed by hand, so there is nowhere to fetch a newer one from`;
-        case "withheld":
-            return `${update.name}: staying on ${update.from} — ${update.reason}`;
-        default:
-            return `${update.name}: FAILED — ${update.reason}`;
-    }
-}
-//# sourceMappingURL=remote.js.map

package/dist/tarball.js

@@ -1,125 +0,0 @@
-import { gunzipSync } from "node:zlib";
-import { UserError } from "./errors.js";
-const BLOCK = 512;
-const TYPE_FILE = 0x30;
-const TYPE_FILE_LEGACY = 0x00;
-const TYPE_DIRECTORY = 0x35;
-const TYPE_PAX_ENTRY = 0x78;
-const TYPE_PAX_GLOBAL = 0x67;
-const MAX_ENTRIES = 2000;
-const MAX_FILE_BYTES = 16 * 1024 * 1024;
-const MAX_TOTAL_BYTES = 64 * 1024 * 1024;
-export function readPackageTarball(gzipped, label) {
-    let tar;
-    try {
-        tar = gunzipSync(gzipped);
-    }
-    catch (error) {
-        throw new UserError(`${label} is not a gzipped tarball: ${error.message}`);
-    }
-    const members = [];
-    let total = 0;
-    let offset = 0;
-    while (offset + BLOCK <= tar.length) {
-        const header = tar.subarray(offset, offset + BLOCK);
-        if (isEndOfArchive(header))
-            break;
-        offset += BLOCK;
-        const name = readHeaderName(header, label);
-        const size = readOctal(header, 124, 12, `${label}: entry "${name}" has an unreadable size`);
-        const type = header[156] ?? 0;
-        const body = tar.subarray(offset, offset + size);
-        offset += Math.ceil(size / BLOCK) * BLOCK;
-        if (type === TYPE_PAX_ENTRY || type === TYPE_PAX_GLOBAL)
-            continue;
-        if (type === TYPE_DIRECTORY)
-            continue;
-        if (type !== TYPE_FILE && type !== TYPE_FILE_LEGACY) {
-            throw new UserError(`${label} carries "${name}", which is not a regular file (tar type ` +
-                `"${String.fromCharCode(type)}"). A plugin is files; nothing here unpacks a link, a ` +
-                "device or an archive member of any other kind.");
-        }
-        if (size > MAX_FILE_BYTES) {
-            throw new UserError(`${label}: "${name}" is ${size} bytes, over the ${MAX_FILE_BYTES} cap`);
-        }
-        total += size;
-        if (total > MAX_TOTAL_BYTES || members.length >= MAX_ENTRIES) {
-            throw new UserError(`${label} unpacks to more than ${MAX_ENTRIES} files or ${MAX_TOTAL_BYTES} bytes`);
-        }
-        if (body.length < size) {
-            throw new UserError(`${label} ends inside "${name}", so it is truncated`);
-        }
-        const path = safePath(name, label);
-        if (path === null)
-            continue;
-        members.push({ path, bytes: Buffer.from(body) });
-    }
-    return strip(members, label);
-}
-function strip(members, label) {
-    const first = members[0];
-    if (first === undefined) {
-        throw new UserError(`${label} has no files in it`);
-    }
-    const root = first.path.split("/")[0];
-    const files = [];
-    const seen = new Set();
-    for (const member of members) {
-        const segments = member.path.split("/");
-        if (segments[0] !== root) {
-            throw new UserError(`${label} carries "${member.path}", which is outside "${root}/"; every member of a ` +
-                "published tarball sits under one directory, and this one has two");
-        }
-        const path = segments.slice(1).join("/");
-        if (path.length === 0)
-            continue;
-        if (seen.has(path)) {
-            throw new UserError(`${label} carries "${path}" twice`);
-        }
-        seen.add(path);
-        files.push({ path, bytes: member.bytes });
-    }
-    if (files.length === 0) {
-        throw new UserError(`${label} has nothing under "${root}/"`);
-    }
-    return files;
-}
-function isEndOfArchive(header) {
-    for (const byte of header) {
-        if (byte !== 0)
-            return false;
-    }
-    return true;
-}
-function readHeaderName(header, label) {
-    const name = readString(header, 0, 100);
-    const prefix = readString(header, 345, 155);
-    if (name.length === 0) {
-        throw new UserError(`${label} carries an entry with no name`);
-    }
-    return prefix.length > 0 ? `${prefix}/${name}` : name;
-}
-function readString(header, at, length) {
-    const field = header.subarray(at, at + length);
-    const end = field.indexOf(0);
-    return field.subarray(0, end === -1 ? field.length : end).toString("utf8");
-}
-function readOctal(header, at, length, problem) {
-    const text = readString(header, at, length).trim();
-    const value = text.length === 0 ? 0 : Number.parseInt(text, 8);
-    if (!Number.isSafeInteger(value) || value < 0)
-        throw new UserError(problem);
-    return value;
-}
-function safePath(name, label) {
-    const path = name.replace(/\\/g, "/").replace(/\/+$/, "");
-    if (path.length === 0)
-        return null;
-    const segments = path.split("/");
-    if (name.startsWith("/") ||
-        segments.some((segment) => segment === "" || segment === "." || segment === ".." || /^[a-zA-Z]:/.test(segment))) {
-        throw new UserError(`${label} carries "${name}", which does not stay inside the directory it unpacks into`);
-    }
-    return path;
-}
-//# sourceMappingURL=tarball.js.map