codictator 0.0.0 → 0.1.3

package/dist/kernel/git.js

@@ -0,0 +1,128 @@
+// SPEC §4.1.1: the real Git port, implemented over the Proc port running
+// `git`, never mutating history. Every failure is CDX-E703 (SPEC §8: git
+// missing or not a git repository); messages name the operation, never file
+// content or command output (SPEC §9.2, CONVENTIONS).
+import { makeError } from "./errors.js";
+import { err, ok } from "./result.js";
+// Git answers quickly or not at all; a hung git never blocks the hook path
+// past its harness timeout (SPEC §9.3).
+const GIT_TIMEOUT_MS = 30_000;
+// Diffs can be large, but an unbounded child can wedge the hook; past the
+// cap the caller retries a narrower range.
+const GIT_MAX_OUTPUT_BYTES = 8 * 1024 * 1024;
+function gitMissingError() {
+    return makeError("CDX-E703", "git executable not found on PATH", "Install git and ensure it is on PATH.");
+}
+function gitOpError(op, reason) {
+    return makeError("CDX-E703", `git ${op} ${reason}`, "Install git and run inside a git repository with git on PATH.");
+}
+function procFailure(op, result) {
+    if (result.timedOut) {
+        return gitOpError(op, "timed out");
+    }
+    if (result.truncated) {
+        return gitOpError(op, "output exceeded the size cap");
+    }
+    if (result.code === -1) {
+        return gitMissingError();
+    }
+    if (result.code !== 0) {
+        return gitOpError(op, "failed");
+    }
+    return undefined;
+}
+export class NodeGit {
+    proc;
+    cwd;
+    constructor(proc, cwd) {
+        this.proc = proc;
+        this.cwd = cwd;
+    }
+    exec(argv) {
+        return this.proc.run(argv, {
+            cwd: this.cwd,
+            env: {},
+            timeoutMs: GIT_TIMEOUT_MS,
+            maxOutputBytes: GIT_MAX_OUTPUT_BYTES,
+        });
+    }
+    async root() {
+        const result = await this.exec(["git", "rev-parse", "--show-toplevel"]);
+        const failure = procFailure("rev-parse", result);
+        if (failure !== undefined) {
+            return err(failure);
+        }
+        return ok(result.stdout.trim());
+    }
+    async head() {
+        const result = await this.exec(["git", "rev-parse", "HEAD"]);
+        const failure = procFailure("rev-parse", result);
+        if (failure !== undefined) {
+            return err(failure);
+        }
+        return ok(result.stdout.trim());
+    }
+    async stagedFiles() {
+        const result = await this.exec(["git", "diff", "--name-only", "--cached"]);
+        const failure = procFailure("staged files", result);
+        if (failure !== undefined) {
+            return err(failure);
+        }
+        const files = result.stdout
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line !== "");
+        files.sort();
+        return ok(files);
+    }
+    async diff(base, head) {
+        const result = await this.exec(["git", "diff", base, head]);
+        const failure = procFailure("diff", result);
+        if (failure !== undefined) {
+            return err(failure);
+        }
+        return ok(result.stdout);
+    }
+    async show(rev, path) {
+        // Assembled off the call: an inline template inside exec( trips the
+        // exec-template pattern (SPEC §6.1), while argv entries never run a shell.
+        const revPath = `${rev}:${path}`;
+        const result = await this.exec(["git", "show", revPath]);
+        const failure = procFailure("show", result);
+        if (failure !== undefined) {
+            return err(failure);
+        }
+        return ok(result.stdout);
+    }
+    async config(key) {
+        const result = await this.exec(["git", "config", "--get", key]);
+        // An unset key exits 1 with no output; like the port fake, unset
+        // text queries answer empty instead of failing.
+        if (result.code === 1 && !result.timedOut && !result.truncated) {
+            return ok("");
+        }
+        const failure = procFailure("config", result);
+        if (failure !== undefined) {
+            return err(failure);
+        }
+        return ok(result.stdout.trim());
+    }
+    async log(range) {
+        // Fixed format: default log output carries locale-dependent dates,
+        // which would break byte-identical replay (CONVENTIONS).
+        const result = await this.exec(["git", "log", "--format=%H %s", range]);
+        const failure = procFailure("log", result);
+        if (failure !== undefined) {
+            return err(failure);
+        }
+        return ok(result.stdout);
+    }
+    async isClean() {
+        const result = await this.exec(["git", "status", "--porcelain"]);
+        const failure = procFailure("status", result);
+        if (failure !== undefined) {
+            return err(failure);
+        }
+        return ok(result.stdout.trim() === "");
+    }
+}

package/dist/kernel/glob.d.ts

@@ -0,0 +1 @@
+export declare function globMatch(pattern: string, path: string): boolean;

package/dist/kernel/glob.js

@@ -0,0 +1,178 @@
+// SPEC §4.1.2: globMatch supports *, **, ?, {a,b} and [...]. Matching is
+// case-sensitive except on Windows and macOS default volumes, where the
+// repo's case is canonical and both sides fold before comparing.
+const REGEXP_SPECIALS = new Set([
+    ".",
+    "^",
+    "$",
+    "+",
+    "(",
+    ")",
+    "|",
+    "\\",
+    "*",
+    "?",
+    "{",
+    "}",
+    "[",
+    "]",
+]);
+function foldCase(text) {
+    if (process.platform === "win32" || process.platform === "darwin") {
+        return text.toLowerCase();
+    }
+    return text;
+}
+function emitLiteral(source, char) {
+    if (REGEXP_SPECIALS.has(char)) {
+        source.push("\\");
+    }
+    source.push(char);
+}
+// Parses {a,b} with nesting; returns the alternation source and the index
+// just past }. Undefined when no closing brace exists (literal { then).
+function parseBraces(pattern, start) {
+    let index = start;
+    const parts = [];
+    let current = [];
+    while (index < pattern.length) {
+        const char = pattern.charAt(index);
+        if (char === "\\" && index + 1 < pattern.length) {
+            emitLiteral(current, pattern.charAt(index + 1));
+            index += 2;
+            continue;
+        }
+        if (char === "{") {
+            const nested = parseBraces(pattern, index + 1);
+            if (nested === undefined) {
+                emitLiteral(current, char);
+                index += 1;
+                continue;
+            }
+            current.push(nested.source);
+            index = nested.next;
+            continue;
+        }
+        if (char === "}") {
+            parts.push(current.join(""));
+            return { source: `(?:${parts.join("|")})`, next: index + 1 };
+        }
+        if (char === ",") {
+            parts.push(current.join(""));
+            current = [];
+            index += 1;
+            continue;
+        }
+        if (char === "*" || char === "?" || char === "[") {
+            const nested = emitGlob(pattern, index);
+            current.push(nested.source);
+            index = nested.next;
+            continue;
+        }
+        emitLiteral(current, char);
+        index += 1;
+    }
+    return undefined;
+}
+// Parses [...] classes; leading ! becomes a regex negation. Undefined when
+// no closing bracket exists (literal [ then).
+function parseClass(pattern, start) {
+    let index = start + 1;
+    let body = "";
+    if (pattern.charAt(index) === "!") {
+        body += "^";
+        index += 1;
+    }
+    else if (pattern.charAt(index) === "^") {
+        body += "\\^";
+        index += 1;
+    }
+    if (pattern.charAt(index) === "]") {
+        body += "\\]";
+        index += 1;
+    }
+    while (index < pattern.length && pattern.charAt(index) !== "]") {
+        const char = pattern.charAt(index);
+        if (char === "\\" && index + 1 < pattern.length) {
+            body += `\\${pattern.charAt(index + 1)}`;
+            index += 2;
+            continue;
+        }
+        body += char;
+        index += 1;
+    }
+    if (index >= pattern.length) {
+        return undefined;
+    }
+    return { source: `[${body}]`, next: index + 1 };
+}
+function emitGlob(pattern, start) {
+    const char = pattern.charAt(start);
+    if (char === "*") {
+        let index = start;
+        while (pattern.charAt(index) === "*") {
+            index += 1;
+        }
+        const doubled = index - start >= 2;
+        if (doubled) {
+            if (pattern.charAt(index) === "/") {
+                return { source: "(?:.*/)?", next: index + 1 };
+            }
+            return { source: ".*", next: index };
+        }
+        return { source: "[^/]*", next: index };
+    }
+    if (char === "?") {
+        return { source: "[^/]", next: start + 1 };
+    }
+    if (char === "{") {
+        const braces = parseBraces(pattern, start + 1);
+        if (braces !== undefined) {
+            return braces;
+        }
+        return { source: "\\{", next: start + 1 };
+    }
+    if (char === "[") {
+        const cls = parseClass(pattern, start);
+        if (cls !== undefined) {
+            return cls;
+        }
+        return { source: "\\[", next: start + 1 };
+    }
+    return { source: `\\${char}`, next: start + 1 };
+}
+function globToRegExp(pattern) {
+    let core = pattern;
+    let suffix = "";
+    if (core === "**") {
+        return /^.*$/;
+    }
+    if (core.endsWith("/**")) {
+        core = core.slice(0, -3);
+        suffix = "(?:/.*)?";
+    }
+    const source = ["^"];
+    let index = 0;
+    while (index < core.length) {
+        const char = core.charAt(index);
+        if (char === "\\" && index + 1 < core.length) {
+            emitLiteral(source, core.charAt(index + 1));
+            index += 2;
+            continue;
+        }
+        if (char === "*" || char === "?" || char === "{" || char === "[") {
+            const emitted = emitGlob(core, index);
+            source.push(emitted.source);
+            index = emitted.next;
+            continue;
+        }
+        emitLiteral(source, char);
+        index += 1;
+    }
+    source.push(suffix);
+    source.push("$");
+    return new RegExp(source.join(""));
+}
+export function globMatch(pattern, path) {
+    return globToRegExp(foldCase(pattern)).test(foldCase(path));
+}

package/dist/kernel/hash.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeText(text: string): string;
+export declare function sha256Hex(bytes: Uint8Array): string;
+export declare function sha256Text(text: string): string;

package/dist/kernel/hash.js

@@ -0,0 +1,12 @@
+// SPEC §4.1.2: CRLF and CR become LF before hashing, so Git's autocrlf
+// cannot fake drift (§4.14). Every content hash in §7 normalizes first.
+import { createHash } from "node:crypto";
+export function normalizeText(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+export function sha256Hex(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+export function sha256Text(text) {
+    return sha256Hex(new TextEncoder().encode(normalizeText(text)));
+}

package/dist/kernel/host.d.ts

@@ -0,0 +1,3 @@
+import { type Result } from "./result.ts";
+export declare function writeHostText(absolutePath: string, content: string): Promise<Result<void>>;
+export declare function readHostText(absolutePath: string): Promise<Result<string>>;

package/dist/kernel/host.js

@@ -0,0 +1,48 @@
+// SPEC §4.15.1 + §4.14.4: kernel-owned reads and writes of absolute host
+// paths. The confined Fs port (§4.1.1) cannot reach files outside the repo
+// and the OS temp dir, like the CI event payload (GITHUB_EVENT_PATH) or the
+// COMMIT_EDITMSG file git hands the commit-msg hook (absolute, and outside
+// the worktree root in a linked worktree); this keeps that OS access in the
+// kernel (§3.3). Callers pass only git- or CI-owned paths, never agent input.
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { encodingError, ioError, outsideError, readFailure, } from "./fs-errors.js";
+import { err, ok } from "./result.js";
+// Relative paths fail CDX-E701; unwritable paths fail CDX-E903, so
+// callers degrade the same way as Fs.write.
+export async function writeHostText(absolutePath, content) {
+    if (!path.isAbsolute(absolutePath)) {
+        return err(outsideError());
+    }
+    try {
+        await fsp.writeFile(absolutePath, content, "utf8");
+        return ok(undefined);
+    }
+    catch (cause) {
+        return err(ioError("write", absolutePath, cause));
+    }
+}
+// Relative paths fail CDX-E701; missing, unreadable or non-UTF-8 files
+// fail CDX-E903 like Fs.readText, so callers degrade the same way.
+export async function readHostText(absolutePath) {
+    if (!path.isAbsolute(absolutePath)) {
+        return err(outsideError());
+    }
+    const loaded = await fsp.readFile(absolutePath).then((data) => ok(new Uint8Array(data.buffer, data.byteOffset, data.byteLength)), (cause) => readFailure(absolutePath, cause));
+    if (!loaded.ok) {
+        return err(loaded.error);
+    }
+    const bytes = loaded.value;
+    const body = bytes.length >= 3 &&
+        bytes[0] === 0xef &&
+        bytes[1] === 0xbb &&
+        bytes[2] === 0xbf
+        ? bytes.subarray(3)
+        : bytes;
+    try {
+        return ok(new TextDecoder("utf-8", { fatal: true }).decode(body));
+    }
+    catch {
+        return err(encodingError(absolutePath));
+    }
+}

package/dist/kernel/index.d.ts

@@ -0,0 +1,115 @@
+import type { Instant } from "./contracts.ts";
+import type { Result } from "./result.ts";
+export { SystemClock } from "./clock.ts";
+export { readTomlKeys, readYamlKeys } from "./config-keys.ts";
+export type { CheckContext, Decision, Enforcer, Finding, Instant, Pack, PackManifest, PackRule, PackRuleParam, Scope, Trigger, } from "./contracts.ts";
+export { TRIGGERS } from "./contracts.ts";
+export { isEntryModule } from "./entry.ts";
+export { NodeEnv } from "./env.ts";
+export type { CdxError } from "./errors.ts";
+export { makeError } from "./errors.ts";
+export type { NodeFsOptions } from "./fs.ts";
+export { NodeFs } from "./fs.ts";
+export type { ConfinedPath } from "./fs-confine.ts";
+export { Confiner, confinePath } from "./fs-confine.ts";
+export { encodingError, ioError, notFoundError, outsideError, readFailure, } from "./fs-errors.ts";
+export { NodeGit } from "./git.ts";
+export { globMatch } from "./glob.ts";
+export { normalizeText, sha256Hex, sha256Text } from "./hash.ts";
+export { readHostText, writeHostText } from "./host.ts";
+export { parseJson, stableLineStringify, stableStringify } from "./json.ts";
+export type { NodeNetOptions } from "./net.ts";
+export { NET_ALLOWLIST, NET_MAX_BODY_BYTES, NET_MAX_REDIRECTS, NodeNet, netHostAllowed, rejectNetUrl, } from "./net.ts";
+export { isGitDirPath, toRepoPath } from "./path.ts";
+export { checkPattern } from "./pattern.ts";
+export { buildProcEnv, NodeProc, PROC_ENV_ALLOWLIST } from "./proc.ts";
+export type { LossyText } from "./read-cache.ts";
+export { cachedLossyText } from "./read-cache.ts";
+export { redactSecrets } from "./redact.ts";
+export { pathExists, resolveRepoRoot } from "./repo-root.ts";
+export type { Result } from "./result.ts";
+export { err, ok } from "./result.ts";
+export { validateSchema } from "./schema.ts";
+export { DEFAULT_FIXTURE_GLOBS, isFixturePath, isSecretReadPath, } from "./secret-paths.ts";
+export type { ShellAnalysis, ShellPipeline, SimpleCommand } from "./shell.ts";
+export { isProtectedPath, matchBypassCommand, scanBypassRawText, } from "./shell-bypass.ts";
+export type { ShellViolation, ShellViolationClass } from "./shell-deny.ts";
+export { matchDangerousShell } from "./shell-deny.ts";
+export { analyseShell } from "./shell-scan.ts";
+export { readStdinText } from "./stdin.ts";
+export type { TestCaseResult } from "./test-report.ts";
+export { readTestReport } from "./test-report.ts";
+export { installedEngineVersion } from "./version.ts";
+export interface FsStat {
+    readonly isFile: boolean;
+    readonly isDirectory: boolean;
+    readonly size: number;
+}
+export interface Fs {
+    readonly read: (path: string) => Promise<Result<Uint8Array>>;
+    readonly readText: (path: string) => Promise<Result<string>>;
+    readonly write: (path: string, content: Uint8Array) => Promise<Result<void>>;
+    readonly append: (path: string, content: Uint8Array) => Promise<Result<void>>;
+    readonly stat: (path: string) => Promise<Result<FsStat>>;
+    readonly list: (dir: string) => Promise<Result<Array<string>>>;
+    readonly glob: (pattern: string, dir: string) => Promise<Result<Array<string>>>;
+    readonly exists: (path: string) => Promise<Result<boolean>>;
+    readonly realpath: (path: string) => Promise<Result<string>>;
+    readonly remove: (path: string) => Promise<Result<void>>;
+}
+export interface ProcResult {
+    readonly code: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly timedOut: boolean;
+    readonly truncated: boolean;
+}
+export interface ProcOptions {
+    readonly cwd: string;
+    readonly env: Readonly<Record<string, string>>;
+    readonly stdin?: string;
+    readonly timeoutMs: number;
+    readonly maxOutputBytes: number;
+}
+export interface Proc {
+    readonly run: (argv: ReadonlyArray<string>, options: ProcOptions) => Promise<ProcResult>;
+}
+export interface NetRequest {
+    readonly method: string;
+    readonly url: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body?: string;
+    readonly timeoutMs: number;
+}
+export interface NetResponse {
+    readonly status: number;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: string;
+}
+export interface Net {
+    readonly request: (req: NetRequest) => Promise<Result<NetResponse>>;
+}
+export interface Clock {
+    readonly now: () => Instant;
+}
+export interface Git {
+    readonly root: () => Promise<Result<string>>;
+    readonly head: () => Promise<Result<string>>;
+    readonly stagedFiles: () => Promise<Result<Array<string>>>;
+    readonly diff: (base: string, head: string) => Promise<Result<string>>;
+    readonly show: (rev: string, path: string) => Promise<Result<string>>;
+    readonly config: (key: string) => Promise<Result<string>>;
+    readonly log: (range: string) => Promise<Result<string>>;
+    readonly isClean: () => Promise<Result<boolean>>;
+}
+export interface Env {
+    readonly get: (name: string) => string | undefined;
+}
+export interface Ports {
+    readonly fs: Fs;
+    readonly proc: Proc;
+    readonly net: Net;
+    readonly clock: Clock;
+    readonly git: Git;
+    readonly env: Env;
+}

package/dist/kernel/index.js

@@ -0,0 +1,33 @@
+// SPEC §4.1: the only module that touches the operating system, the network
+// or the clock (§3.3). Everything else receives ports by injection, which
+// makes every other module testable without I/O.
+export { SystemClock } from "./clock.js";
+export { readTomlKeys, readYamlKeys } from "./config-keys.js";
+export { TRIGGERS } from "./contracts.js";
+export { isEntryModule } from "./entry.js";
+export { NodeEnv } from "./env.js";
+export { makeError } from "./errors.js";
+export { NodeFs } from "./fs.js";
+export { Confiner, confinePath } from "./fs-confine.js";
+export { encodingError, ioError, notFoundError, outsideError, readFailure, } from "./fs-errors.js";
+export { NodeGit } from "./git.js";
+export { globMatch } from "./glob.js";
+export { normalizeText, sha256Hex, sha256Text } from "./hash.js";
+export { readHostText, writeHostText } from "./host.js";
+export { parseJson, stableLineStringify, stableStringify } from "./json.js";
+export { NET_ALLOWLIST, NET_MAX_BODY_BYTES, NET_MAX_REDIRECTS, NodeNet, netHostAllowed, rejectNetUrl, } from "./net.js";
+export { isGitDirPath, toRepoPath } from "./path.js";
+export { checkPattern } from "./pattern.js";
+export { buildProcEnv, NodeProc, PROC_ENV_ALLOWLIST } from "./proc.js";
+export { cachedLossyText } from "./read-cache.js";
+export { redactSecrets } from "./redact.js";
+export { pathExists, resolveRepoRoot } from "./repo-root.js";
+export { err, ok } from "./result.js";
+export { validateSchema } from "./schema.js";
+export { DEFAULT_FIXTURE_GLOBS, isFixturePath, isSecretReadPath, } from "./secret-paths.js";
+export { isProtectedPath, matchBypassCommand, scanBypassRawText, } from "./shell-bypass.js";
+export { matchDangerousShell } from "./shell-deny.js";
+export { analyseShell } from "./shell-scan.js";
+export { readStdinText } from "./stdin.js";
+export { readTestReport } from "./test-report.js";
+export { installedEngineVersion } from "./version.js";

package/dist/kernel/json.d.ts

@@ -0,0 +1,4 @@
+import { type Result } from "./result.ts";
+export declare function parseJson(text: string): Result<unknown>;
+export declare function stableStringify(value: unknown): string;
+export declare function stableLineStringify(value: unknown): string;

package/dist/kernel/json.js

@@ -0,0 +1,68 @@
+// SPEC §4.1.2: the only JSON.parse call in the codebase. Malformed input
+// is a Result error naming line and column, never a throw (EC-9). Generated
+// files go through stableStringify so regeneration is byte-identical (EC-7).
+import { makeError } from "./errors.js";
+import { err, ok } from "./result.js";
+function errorPosition(error) {
+    if (error instanceof SyntaxError) {
+        const match = /at position (\d+)/.exec(error.message);
+        const raw = match?.[1];
+        if (raw !== undefined) {
+            const parsed = Number.parseInt(raw, 10);
+            if (Number.isSafeInteger(parsed)) {
+                return parsed;
+            }
+        }
+    }
+    return undefined;
+}
+function offsetToLineColumn(text, offset) {
+    const clamped = Math.max(0, Math.min(offset, text.length));
+    let line = 1;
+    let column = 1;
+    for (let index = 0; index < clamped; index += 1) {
+        if (text.charAt(index) === "\n") {
+            line += 1;
+            column = 1;
+        }
+        else {
+            column += 1;
+        }
+    }
+    return { line, column };
+}
+export function parseJson(text) {
+    try {
+        return ok(JSON.parse(text));
+    }
+    catch (error) {
+        const at = errorPosition(error) ?? text.length;
+        const location = offsetToLineColumn(text, at);
+        return err(makeError("CDX-E101", `invalid JSON at line ${location.line}, column ${location.column}`, "Fix the JSON syntax at the reported line and column, then retry."));
+    }
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sortedJson(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortedJson);
+    }
+    if (isJsonObject(value)) {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            sorted[key] = sortedJson(value[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+export function stableStringify(value) {
+    return `${JSON.stringify(sortedJson(value), undefined, 2)}\n`;
+}
+// SPEC §4.18.1: the event log needs canonical single-line JSON (one object
+// per line), while generated files use the pretty stableStringify (§4.1.2).
+// Keys sort identically, so both forms hash the same content.
+export function stableLineStringify(value) {
+    return `${JSON.stringify(sortedJson(value))}\n`;
+}

package/dist/kernel/net-allow.d.ts

@@ -0,0 +1,8 @@
+import { type CdxError } from "./errors.ts";
+export declare const NET_ALLOWLIST: ReadonlyArray<string>;
+export interface NodeNetOptions {
+    readonly extraHosts?: ReadonlyArray<string>;
+}
+export declare function netHostAllowed(host: string, extraHosts?: ReadonlyArray<string>): boolean;
+export declare function netError(message: string, remediation: string): CdxError;
+export declare function rejectNetUrl(url: string, extraHosts?: ReadonlyArray<string>): CdxError | undefined;

package/dist/kernel/net-allow.js

@@ -0,0 +1,45 @@
+// SPEC §9.2: the static network allowlist verdict. Configured registry
+// hosts, a detected GitHub Enterprise host and the generator LLM host
+// arrive as extra hosts on NodeNet, never here. Only the hostname reaches
+// an error message; the full URL can carry secrets in its query.
+import { makeError } from "./errors.js";
+export const NET_ALLOWLIST = [
+    "api.github.com",
+    "api.nuget.org",
+    "api.osv.dev",
+    "builds.dotnet.microsoft.com",
+    "nodejs.org",
+    "pypi.org",
+    "registry.npmjs.org",
+    "www.python.org",
+];
+export function netHostAllowed(host, extraHosts = []) {
+    const wanted = host.toLowerCase();
+    for (const allowed of [...NET_ALLOWLIST, ...extraHosts]) {
+        if (allowed.toLowerCase() === wanted) {
+            return true;
+        }
+    }
+    return false;
+}
+export function netError(message, remediation) {
+    return makeError("CDX-E702", message, remediation);
+}
+// The allowlist verdict shared by the real port and its fake: undefined
+// means the URL may be fetched.
+export function rejectNetUrl(url, extraHosts = []) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return netError("network url is not an absolute url", "Use an absolute https URL on the network allowlist (SPEC §9.2).");
+    }
+    if (parsed.protocol !== "https:") {
+        return netError(`network host ${parsed.hostname} needs https`, "Use an https URL; plain http is never fetched.");
+    }
+    if (!netHostAllowed(parsed.hostname, extraHosts)) {
+        return netError(`network host ${parsed.hostname} is not on the allowlist`, "Use a host on the network allowlist (SPEC §9.2), or add a registry host via config.network.registries.");
+    }
+    return undefined;
+}

package/dist/kernel/net-fetch.d.ts

@@ -0,0 +1,5 @@
+import type { NetResponse } from "./index.ts";
+import { type Result } from "./result.ts";
+export declare const NET_MAX_BODY_BYTES: number;
+export declare const NET_MAX_REDIRECTS = 5;
+export declare function fetchOnce(current: URL, method: string, headers: Readonly<Record<string, string>>, body: string | undefined, timeoutMs: number, redirects: number, extraHosts: ReadonlyArray<string>, resolve: (result: Result<NetResponse>) => void): void;