codictator 0.1.2 → 0.2.0

package/dist/cli/setup.js

@@ -0,0 +1,143 @@
+// SPEC §4.19.6: one-shot adoption. Flags mirror init (§4.19.2); the run
+// is the init path (or regen over an existing config) plus install, hooks
+// and verify, ending at the extension handoff (§4.20.1). Every step
+// delegates to the existing init, guardrail and verify handlers; no step
+// logic is duplicated here.
+import { ENGINE_VERSION } from "../features/config/index.js";
+import { err, ok } from "../kernel/index.js";
+import { configureHooksPath, handleRegen, writeHookFiles, } from "./guardrail.js";
+import { parseInitFlags } from "./init.js";
+import { defaultHarnesses, initPreamble, runInitSequence, } from "./init-plan.js";
+import { handleVerify } from "./inspect.js";
+import { setupGitignoreStep } from "./setup-gitignore.js";
+import { hasEffectivePacks, SETUP_EXTENSION_ID, SETUP_EXTENSION_INSTALL, setupHandoffLines, } from "./setup-handoff.js";
+import { setupInstallHere, setupInstallLayout } from "./setup-install.js";
+import { fail, MIN_NODE_MAJOR, nodeMajor, nodeTooOldMessage, printHuman, printJson, readStateText, usageError, } from "./shared.js";
+export const SETUP_USAGE = "usage: codictator setup [--harness <id> ...] [--profile <app|library|cli|service>] [--pack <id> ...] [--tool <role>=<command>@<pin> ...] [--repair]";
+// SPEC §4.19.6 step 1: the Node floor, the human gate and the repo root.
+async function setupPreflight(req) {
+    const version = req.nodeVersion ?? process.version;
+    if (nodeMajor(version) < MIN_NODE_MAJOR) {
+        return fail("CDX-E002", nodeTooOldMessage(version), "Install a newer Node, then retry the tool call.", req.json);
+    }
+    return initPreamble(req);
+}
+// SPEC §4.19.6 step 2: the adoption path. An existing config without
+// --repair re-renders from config; otherwise the init path runs.
+async function setupRegenPath(req, steps) {
+    const regen = await handleRegen({ ...req, args: [] });
+    if (!regen.ok) {
+        return regen;
+    }
+    steps.push({ step: "init", ok: true, detail: { mode: "regen" } });
+    printHuman("setup: guardrails regenerated from the existing config", req.quiet);
+    return ok(0);
+}
+async function setupInitPath(req, root, flags, steps) {
+    const engineVersion = req.engineVersion ?? ENGINE_VERSION;
+    const sequenced = await runInitSequence(root, req, flags, defaultHarnesses(flags), engineVersion);
+    if (!sequenced.ok) {
+        return sequenced;
+    }
+    steps.push({
+        step: "init",
+        ok: true,
+        detail: {
+            mode: flags.repair ? "repair" : "fresh",
+            files: sequenced.value.written.map((entry) => entry.path),
+        },
+    });
+    printHuman("setup: guardrails written from the init path", req.quiet);
+    return ok(0);
+}
+async function setupAdopt(req, root, flags, steps) {
+    const existing = await readStateText(root, ".codictator/config.json");
+    if (existing !== undefined && !flags.repair) {
+        return setupRegenPath(req, steps);
+    }
+    return setupInitPath(req, root, flags, steps);
+}
+// SPEC §4.19.6 step 6: hooks via the install-hooks writers.
+async function setupHooksStep(req, root, steps) {
+    const written = await writeHookFiles(root);
+    if (!written.ok) {
+        return fail("CDX-E903", written.error.message, written.error.remediation, req.json);
+    }
+    await configureHooksPath(root, req);
+    steps.push({ step: "hooks", ok: true });
+    printHuman("setup: hooks installed", req.quiet);
+    return ok(0);
+}
+// SPEC §4.19.6 step 7: the first evaluation over the adopted repo. A
+// blocking verdict stops the run with verify's own mapping (exit 1).
+async function setupVerifyStep(req, steps) {
+    const verdict = await handleVerify({ ...req, args: [] });
+    if (!verdict.ok || verdict.value !== 0) {
+        return verdict;
+    }
+    steps.push({ step: "verify", ok: true });
+    return ok(0);
+}
+// SPEC §4.19.6 step 8 + §4.20.1: the views connect once a config exists;
+// the human installs the extension with the printed command.
+function setupHandoff(req, root, steps, emptyPacks) {
+    steps.push({
+        step: "handoff",
+        ok: true,
+        detail: { extension: SETUP_EXTENSION_ID },
+    });
+    if (req.json) {
+        printJson({
+            setup: true,
+            root,
+            steps,
+            extension: { id: SETUP_EXTENSION_ID, install: SETUP_EXTENSION_INSTALL },
+        });
+    }
+    else {
+        for (const line of setupHandoffLines(emptyPacks)) {
+            printHuman(line, req.quiet);
+        }
+    }
+    return ok(0);
+}
+// SPEC §4.19.6: the eight adoption steps in order; a step failure stops
+// the run with that step's §8.2 mapping.
+export async function handleSetup(req) {
+    const flags = parseInitFlags(req.args);
+    if (flags === undefined) {
+        return usageError(SETUP_USAGE);
+    }
+    const preflight = await setupPreflight(req);
+    if (typeof preflight !== "string") {
+        return preflight;
+    }
+    const root = preflight;
+    const steps = [{ step: "preflight", ok: true }];
+    const adopted = await setupAdopt(req, root, flags, steps);
+    if (!adopted.ok) {
+        return adopted;
+    }
+    const ignored = await setupGitignoreStep(req, root, steps);
+    if (!ignored.ok) {
+        return ignored;
+    }
+    const layout = await setupInstallLayout(req, root, steps);
+    if (!layout.ok) {
+        return err(layout.error);
+    }
+    const installed = await setupInstallHere(req, root, layout.value, steps);
+    if (!installed.ok) {
+        return installed;
+    }
+    const hooked = await setupHooksStep(req, root, steps);
+    if (!hooked.ok) {
+        return hooked;
+    }
+    const verified = await setupVerifyStep(req, steps);
+    if (!verified.ok) {
+        return verified;
+    }
+    const emptyPacks = !(await hasEffectivePacks(root, flags));
+    return setupHandoff(req, root, steps, emptyPacks);
+}

package/dist/cli/task-advance.js

@@ -87,31 +87,31 @@ async function taskMutate(req, root, sub) {
     }
     return taskClose(req, root, id);
 }
-// SPEC §4.19.2 + §4.12: task lifecycle reads and writes; only ack is
-// human-only, and only it clears an escalation.
-export async function handleTask(req) {
-    const root = await needTaskRoot(req);
-    if (typeof root !== "string") {
-        return root;
-    }
-    const sub = req.args[0] ?? "";
-    if (sub === "new") {
-        return taskNew(req, root);
-    }
-    if (sub === "show") {
-        return taskShow(req, root);
-    }
+const SINGLE_SUBCOMMANDS = {
+    new: (req, root) => taskNew(req, root),
+    show: (req, root) => taskShow(req, root),
+    checkpoint: (req, root) => taskCheckpoint(req, root),
+};
+async function runTaskSub(req, root, sub) {
     if (sub === "phase" && req.args[1] === "next") {
         return taskPhaseNext(req, root);
     }
-    if (sub === "checkpoint") {
-        return taskCheckpoint(req, root);
+    const single = SINGLE_SUBCOMMANDS[sub];
+    if (single !== undefined) {
+        return single(req, root);
     }
     if (sub === "ack" || sub === "amend" || sub === "close") {
         return taskMutate(req, root, sub);
     }
     return usageError("usage: codictator task <new|show|amend|phase next|checkpoint|close|ack> ...");
 }
+export async function handleTask(req) {
+    const root = await needTaskRoot(req);
+    if (typeof root !== "string") {
+        return root;
+    }
+    return runTaskSub(req, root, req.args[0] ?? "");
+}
 async function taskShow(req, root) {
     const ids = await listTaskIds(root);
     if (req.args.length === 1) {

package/dist/features/adapters/claude-shaped.d.ts

@@ -1,3 +1,4 @@
 import type { Result } from "../../kernel/index.ts";
 import type { HookEvent, ToolKind } from "./contract.ts";
+export declare function readString(record: Record<string, unknown>, keys: ReadonlyArray<string>): string | undefined;
 export declare function parseClaudeShapedEvent(harness: string, event: string, raw: unknown, table: Readonly<Record<string, ToolKind>>): Result<HookEvent>;

package/dist/features/adapters/claude-shaped.js

@@ -4,10 +4,9 @@
 // leaks (§9.2).
 import { err, makeError, ok } from "../../kernel/index.js";
 import { normalizeToolName } from "./contract.js";
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readString(record, keys) {
+// SPEC §4.5.3: first non-empty string under any of the keys. Shared with
+// the sibling adapters, so the field readers never drift apart.
+export function readString(record, keys) {
     for (const key of keys) {
         const value = record[key];
         if (typeof value === "string" && value.length > 0) {
@@ -16,6 +15,9 @@ function readString(record, keys) {
     }
     return undefined;
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function readToolInput(raw) {
     for (const key of ["tool_input", "toolInput", "input", "args"]) {
         const value = raw[key];
@@ -42,34 +44,30 @@ function collectPaths(input) {
     }
     return [...found].sort();
 }
+// SPEC §4.5.3: event names map to triggers through one table, so adding a
+// harness alias is a row, not a branch.
+const CLAUDE_EVENT_TABLE = {
+    PreToolUse: "pre-tool",
+    "tool.pre.write": "pre-tool",
+    "tool.pre.shell": "pre-tool",
+    "tool.pre.read": "pre-tool",
+    "tool.pre.search": "pre-tool",
+    "tool.pre.other": "pre-tool",
+    PostToolUse: "post-tool",
+    "tool.post.write": "post-tool",
+    Stop: "post-tool",
+    stop: "post-tool",
+    SessionStart: "startup",
+    "session.start": "startup",
+    SubagentStart: "startup",
+    "subagent.start": "startup",
+    UserPromptSubmit: "prompt",
+    "prompt.submit": "prompt",
+    PostCompact: "compact",
+    "compact.post": "compact",
+};
 function mapClaudeEvent(event) {
-    switch (event) {
-        case "PreToolUse":
-        case "tool.pre.write":
-        case "tool.pre.shell":
-        case "tool.pre.read":
-        case "tool.pre.search":
-        case "tool.pre.other":
-            return "pre-tool";
-        case "PostToolUse":
-        case "tool.post.write":
-        case "Stop":
-        case "stop":
-            return "post-tool";
-        case "SessionStart":
-        case "session.start":
-        case "SubagentStart":
-        case "subagent.start":
-            return "startup";
-        case "UserPromptSubmit":
-        case "prompt.submit":
-            return "prompt";
-        case "PostCompact":
-        case "compact.post":
-            return "compact";
-        default:
-            return undefined;
-    }
+    return CLAUDE_EVENT_TABLE[event];
 }
 function blockError(harness, detail) {
     return makeError("CDX-E303", `unparseable ${harness} hook payload: ${detail}`, "Check the harness hook configuration, then retry the tool call.");

package/dist/features/adapters/copilot.js

@@ -1,4 +1,9 @@
+// SPEC §4.5.4: the GitHub Copilot adapter (CLI, cloud agent, VS Code
+// agent). Parse, reply and staticBlock are pure; hookIoVerified stays false
+// until a first-party capture lands (§4.5.7), and the hooks-file schema
+// below follows the SPEC row verbatim for the same reason.
 import { err, makeError, ok, stableStringify } from "../../kernel/index.js";
+import { readString } from "./claude-shaped.js";
 import { normalizeToolName } from "./contract.js";
 import { COPILOT_CAPABILITIES } from "./copilot-capabilities.js";
 // SPEC §4.5.4 with §4.5.5: hook entries carry timeoutSec; the runtime budget
@@ -31,40 +36,28 @@ const COPILOT_TOOL_TABLE = {
 export function normalizeCopilotToolName(name) {
     return normalizeToolName(COPILOT_TOOL_TABLE, name);
 }
+// SPEC §4.5.4: event names map to triggers through one table, so adding a
+// harness alias is a row, not a branch.
+const COPILOT_EVENT_TABLE = {
+    preToolUse: "pre-tool",
+    "tool.pre.write": "pre-tool",
+    "tool.pre.shell": "pre-tool",
+    "tool.pre.read": "pre-tool",
+    "tool.pre.search": "pre-tool",
+    "tool.pre.other": "pre-tool",
+    postToolUse: "post-tool",
+    "tool.post.write": "post-tool",
+    sessionStart: "startup",
+    "session.start": "startup",
+    userPromptSubmitted: "prompt",
+    "prompt.submit": "prompt",
+};
 function mapCopilotEvent(event) {
-    switch (event) {
-        case "preToolUse":
-        case "tool.pre.write":
-        case "tool.pre.shell":
-        case "tool.pre.read":
-        case "tool.pre.search":
-        case "tool.pre.other":
-            return "pre-tool";
-        case "postToolUse":
-        case "tool.post.write":
-            return "post-tool";
-        case "sessionStart":
-        case "session.start":
-            return "startup";
-        case "userPromptSubmitted":
-        case "prompt.submit":
-            return "prompt";
-        default:
-            return undefined;
-    }
+    return COPILOT_EVENT_TABLE[event];
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readString(record, keys) {
-    for (const key of keys) {
-        const value = record[key];
-        if (typeof value === "string" && value.length > 0) {
-            return value;
-        }
-    }
-    return undefined;
-}
 function blockError(detail) {
     return makeError("CDX-E303", `unparseable copilot hook payload: ${detail}`, "Check the harness hook configuration, then retry the tool call.");
 }

package/dist/features/audit/append.js

@@ -87,18 +87,23 @@ function fitLine(event, now, id) {
         return err(e801("append event", "a single event without a message exceeds 64 KB"));
     }
     const empty = stableLineStringify(withOptionals(base, event, ""));
-    let allowance = MAX_LINE_BYTES - byteLength(empty) - 2;
+    const allowance = MAX_LINE_BYTES - byteLength(empty) - 2;
+    return truncateToFit(base, event, message, allowance);
+}
+// Halve the budget until the marked message fits, else fail closed.
+function truncateToFit(base, event, message, allowance) {
+    let budget = allowance;
     for (let round = 0; round < 32; round += 1) {
-        if (allowance < 0) {
+        if (budget < 0) {
             return err(e801("append event", "the message cannot be truncated to fit 64 KB"));
         }
-        const kept = truncateUtf8(message, allowance);
+        const kept = truncateUtf8(message, budget);
         const omitted = byteLength(message) - byteLength(kept);
         const candidate = stableLineStringify(withOptionals(base, event, `${kept}[truncated ${omitted} bytes]`));
         if (byteLength(candidate) <= MAX_LINE_BYTES) {
             return ok(candidate);
         }
-        allowance = Math.floor(allowance / 2);
+        budget = Math.floor(budget / 2);
     }
     return err(e801("append event", "the message cannot be truncated to fit 64 KB"));
 }

package/dist/features/audit/surfaces.js

@@ -27,6 +27,20 @@ function helpersLine(helpers) {
     });
     return `helpers: ${parts.join(", ")}`;
 }
+// SPEC §4.18.3: trailing status rows with their fallbacks, so the screen
+// builder stays a straight-line assembly.
+function tailStatusLines(input) {
+    return [
+        `task: ${input.task ?? "none active"}`,
+        `waivers: ${input.waivers ?? "none in force"}`,
+        `ratchet: ${input.ratchet ?? "no baseline history"}`,
+        `deps: ${input.deps ?? "freshness unknown"}`,
+        `integrity: ${input.integrity ?? "unverified"}`,
+        `escalations: ${input.escalations ?? "none open"}`,
+        `remediation: ${input.remediation ?? "no plan"}`,
+        `events: ${input.events} observed, ${input.corrupt} corrupt${input.gap ? "; gap in coverage, log was deleted mid-session" : ""}`,
+    ];
+}
 // SPEC §4.18.3: one screen with engine, packs, harness states, helper
 // tools, task, waivers, ratchet, deps, integrity, escalations and
 // remediation progress.
@@ -43,14 +57,7 @@ export function buildStatusText(input) {
         lines.push(`- ${harness.harness}: ${harness.state} (${harness.layers})`);
     }
     lines.push(helpersLine(input.helpers));
-    lines.push(`task: ${input.task ?? "none active"}`);
-    lines.push(`waivers: ${input.waivers ?? "none in force"}`);
-    lines.push(`ratchet: ${input.ratchet ?? "no baseline history"}`);
-    lines.push(`deps: ${input.deps ?? "freshness unknown"}`);
-    lines.push(`integrity: ${input.integrity ?? "unverified"}`);
-    lines.push(`escalations: ${input.escalations ?? "none open"}`);
-    lines.push(`remediation: ${input.remediation ?? "no plan"}`);
-    lines.push(`events: ${input.events} observed, ${input.corrupt} corrupt${input.gap ? "; gap in coverage, log was deleted mid-session" : ""}`);
+    lines.push(...tailStatusLines(input));
     return lines.join("\n");
 }
 // SPEC §4.18.3: the same status as data for the extension (--json).

package/dist/features/ci/protection.js

@@ -13,25 +13,46 @@ function block(ruleId, message, remediation) {
 }
 // SPEC §4.15.2: reported not required → block; unreadable → advise (PRD
 // §11.1). The same read feeds core/branch-protection below.
-export function evaluateProtection(read) {
-    if (read === undefined || !read.readable) {
-        return [
-            advise("core/ci-required-check", "cannot confirm the verify check is required: branch protection is unreadable", "Grant the workflow read access to rulesets/branch protection, or confirm the required check by hand (EC-1, EC-6)."),
-            advise("core/branch-protection", "cannot confirm force-push, deletion and squash settings: branch protection is unreadable", "Grant the workflow read access to the repo settings and rulesets, or confirm them by hand (§4.15.2)."),
-        ];
-    }
-    const findings = [];
+function unreadableFindings() {
+    return [
+        advise("core/ci-required-check", "cannot confirm the verify check is required: branch protection is unreadable", "Grant the workflow read access to rulesets/branch protection, or confirm the required check by hand (EC-1, EC-6)."),
+        advise("core/branch-protection", "cannot confirm force-push, deletion and squash settings: branch protection is unreadable", "Grant the workflow read access to the repo settings and rulesets, or confirm them by hand (§4.15.2)."),
+    ];
+}
+function requiredCheckFinding(read) {
     if (read.verifyRequired !== true) {
-        findings.push(block("core/ci-required-check", "the verify check is not a required check on the default branch", "Add verify to the required checks of the branch ruleset (§4.15 EC-7)."));
+        return block("core/ci-required-check", "the verify check is not a required check on the default branch", "Add verify to the required checks of the branch ruleset (§4.15 EC-7).");
     }
+    return undefined;
+}
+function squashFinding(read) {
     const squashExcluded = read.allowSquashMerge === false ||
         (read.rulesetMergeMethods !== undefined &&
             !read.rulesetMergeMethods.includes("squash"));
     if (!squashExcluded) {
-        findings.push(block("core/branch-protection", "squash merging is allowed and no ruleset excludes it", "Set allow_squash_merge to false and exclude squash from the ruleset allowed_merge_methods (§4.9.3, EC-11, S33)."));
+        return block("core/branch-protection", "squash merging is allowed and no ruleset excludes it", "Set allow_squash_merge to false and exclude squash from the ruleset allowed_merge_methods (§4.9.3, EC-11, S33).");
     }
+    return undefined;
+}
+function hardeningFinding(read) {
     if (read.forcePushBlocked !== true || read.deletionBlocked !== true) {
-        findings.push(block("core/branch-protection", "force-push or deletion is not blocked on the default branch", "Block force-pushes and deletions on the default branch in settings and rulesets (§4.15.2)."));
+        return block("core/branch-protection", "force-push or deletion is not blocked on the default branch", "Block force-pushes and deletions on the default branch in settings and rulesets (§4.15.2).");
+    }
+    return undefined;
+}
+export function evaluateProtection(read) {
+    if (read === undefined || !read.readable) {
+        return unreadableFindings();
+    }
+    const findings = [];
+    for (const maybe of [
+        requiredCheckFinding(read),
+        squashFinding(read),
+        hardeningFinding(read),
+    ]) {
+        if (maybe !== undefined) {
+            findings.push(maybe);
+        }
     }
     return findings;
 }
@@ -51,10 +72,13 @@ export function resolveBaseRef(input) {
         input.before !== zero) {
         return ok(input.before);
     }
+    return ok(baseFromDefault(input));
+}
+function baseFromDefault(input) {
     if (input.eventName === "push") {
-        return ok(`merge-base(${input.defaultBranch ?? "main"},HEAD)`);
+        return `merge-base(${input.defaultBranch ?? "main"},HEAD)`;
     }
-    return ok(input.pullBaseSha ?? `merge-base(${input.defaultBranch ?? "main"},HEAD)`);
+    return (input.pullBaseSha ?? `merge-base(${input.defaultBranch ?? "main"},HEAD)`);
 }
 function usesRef(uses) {
     const at = uses.indexOf("@");

package/dist/features/deps/npm.js

@@ -17,10 +17,45 @@ function stripWorkspacePrefix(range) {
     }
     return undefined;
 }
+function classifyWorkspaceRange(workspace) {
+    return EXACT_PIN.test(workspace) ? "workspace-exact" : "workspace-range";
+}
+function classifyAliasRange(range) {
+    const at = range.lastIndexOf("@");
+    const version = at < 4 ? "" : range.slice(at + 1);
+    return EXACT_PIN.test(version) ? "alias-exact" : "alias-range";
+}
+function isGitRange(range) {
+    return (range.startsWith("git+") ||
+        range.startsWith("git://") ||
+        range.startsWith("github:"));
+}
+function classifyGitRange(range) {
+    const hash = range.split("#")[1] ?? "";
+    return FULL_SHA.test(hash) ? "git-sha" : "git-unpinned";
+}
+function isTagName(range) {
+    return (range === "*" ||
+        range === "latest" ||
+        range === "" ||
+        /^[a-zA-Z][0-9A-Za-z.-]*$/.test(range));
+}
+function classifyBareRange(range) {
+    if (isGitRange(range)) {
+        return classifyGitRange(range);
+    }
+    if (range.startsWith("http://") || range.startsWith("https://")) {
+        return "tarball-url";
+    }
+    if (EXACT_PIN.test(range)) {
+        return "exact";
+    }
+    return isTagName(range) ? "tag" : "range";
+}
 export function classifyNpmRange(range) {
     const workspace = stripWorkspacePrefix(range);
     if (workspace !== undefined) {
-        return EXACT_PIN.test(workspace) ? "workspace-exact" : "workspace-range";
+        return classifyWorkspaceRange(workspace);
     }
     if (range.startsWith("file:")) {
         return "file";
@@ -28,30 +63,10 @@ export function classifyNpmRange(range) {
     if (range.startsWith("link:")) {
         return "link";
     }
-    if (range.startsWith("npm:")) {
-        const at = range.lastIndexOf("@");
-        const version = at < 4 ? "" : range.slice(at + 1);
-        return EXACT_PIN.test(version) ? "alias-exact" : "alias-range";
-    }
-    if (range.startsWith("git+") ||
-        range.startsWith("git://") ||
-        range.startsWith("github:")) {
-        const hash = range.split("#")[1] ?? "";
-        return FULL_SHA.test(hash) ? "git-sha" : "git-unpinned";
-    }
-    if (range.startsWith("http://") || range.startsWith("https://")) {
-        return "tarball-url";
-    }
-    if (EXACT_PIN.test(range)) {
-        return "exact";
-    }
-    if (range === "*" ||
-        range === "latest" ||
-        range === "" ||
-        /^[a-zA-Z][0-9A-Za-z.-]*$/.test(range)) {
-        return "tag";
+    if (range.startsWith(`${NPM_ECOSYSTEM}:`)) {
+        return classifyAliasRange(range);
     }
-    return "range";
+    return classifyBareRange(range);
 }
 // SPEC §4.8.5: ranges, tags, *, latest and unpinned git/alias/workspace
 // forms block core/dep-exact-pin. In-repo file:/link: forms, full-SHA git

package/dist/features/deps/registry.js

@@ -9,50 +9,61 @@ export const NPM_REGISTRY_BASE_URL = "https://registry.npmjs.org";
 export const REGISTRY_TIMEOUT_MS = 30_000;
 export const SNAPSHOT_MAX_AGE_MS = 24 * 86_400_000;
 export const SNAPSHOT_CACHE_PATH = ".codictator/cache/registry/npm.json";
-function narrowPackument(name, value) {
-    const empty = {
-        name,
-        unpublished: true,
-        times: {},
-        versions: {},
-    };
-    if (!isJsonRecord(value)) {
-        return empty;
-    }
+function isPublishTime(version, published) {
+    return (version !== "created" &&
+        version !== "modified" &&
+        typeof published === "string");
+}
+function narrowTimeTable(value) {
     const times = {};
     const timeTable = recordField(value, "time");
-    if (timeTable !== undefined) {
-        for (const [version, published] of Object.entries(timeTable)) {
-            if (version !== "created" &&
-                version !== "modified" &&
-                typeof published === "string") {
-                times[version] = published;
-            }
+    if (timeTable === undefined) {
+        return times;
+    }
+    for (const [version, published] of Object.entries(timeTable)) {
+        if (isPublishTime(version, published)) {
+            times[version] = published;
         }
     }
+    return times;
+}
+function narrowVersionDetail(detail) {
+    if (!isJsonRecord(detail)) {
+        return undefined;
+    }
+    const enginesTable = recordField(detail, "engines");
+    return {
+        deprecated: typeof field(detail, "deprecated") === "string" ||
+            field(detail, "deprecated") === true,
+        license: stringField(detail, "license"),
+        engines: enginesTable === undefined
+            ? undefined
+            : stringField(enginesTable, "node"),
+    };
+}
+function narrowVersionTable(value) {
     const versions = {};
     const versionTable = recordField(value, "versions");
-    if (versionTable !== undefined) {
-        for (const [version, detail] of Object.entries(versionTable)) {
-            if (!isJsonRecord(detail)) {
-                continue;
-            }
-            const enginesTable = recordField(detail, "engines");
-            const engines = enginesTable === undefined
-                ? undefined
-                : stringField(enginesTable, "node");
-            versions[version] = {
-                deprecated: typeof field(detail, "deprecated") === "string" ||
-                    field(detail, "deprecated") === true,
-                license: stringField(detail, "license"),
-                engines,
-            };
+    if (versionTable === undefined) {
+        return versions;
+    }
+    for (const [version, detail] of Object.entries(versionTable)) {
+        const narrowed = narrowVersionDetail(detail);
+        if (narrowed !== undefined) {
+            versions[version] = narrowed;
         }
     }
+    return versions;
+}
+function narrowPackument(name, value) {
+    if (!isJsonRecord(value)) {
+        return { name, unpublished: true, times: {}, versions: {} };
+    }
+    const versions = narrowVersionTable(value);
     if (Object.keys(versions).length === 0) {
-        return empty;
+        return { name, unpublished: true, times: {}, versions: {} };
     }
-    return { name, unpublished: false, times, versions };
+    return { name, unpublished: false, times: narrowTimeTable(value), versions };
 }
 // SPEC §4.8.2: the full document (the abbreviated form lacks `time`).
 // A 404 is unpublished (EC-4), not a transport failure.