@sdd-method/verify-cli 0.1.0

package/dist/lib/validate/dispatch.js

@@ -0,0 +1,218 @@
+import { checkBundleCoherence } from "./bundle-coherence.js";
+// Validators that accept --app-root / --repo-root flags work fine from the
+// bundled location because they override their internal ROOT_DIR via the
+// flag. Validators without that flag (adr-structure, runway-classification,
+// spec-lifecycle) compute ROOT_DIR as SCRIPT_DIR/../.. — so we must run the
+// copy that sync placed inside the target repo, not the bundled sdd-cli copy.
+const APP_VALIDATORS = [
+    {
+        name: "app-docs",
+        source: { kind: "bundled", script: "validate-app-docs.sh" },
+        build: (ctx) => ({ status: "run", args: ["--app-root", ctx.targetRepo] }),
+    },
+    {
+        name: "app-dependencies",
+        source: { kind: "bundled", script: "validate-app-dependencies.sh" },
+        // NO LONGER SKIPS WITHOUT --platform-root. It used to, and the consequence was
+        // that the validator had never executed: measured across 22/22 forward-estate
+        // app repos it skipped every time, because nothing passes --platform-root, and
+        // the suite printed "All validators passed" over the skip.
+        //
+        // Only the resolution halves of checks 2 and 3 need a platform surface. The
+        // stability vocabulary, "is a service_id declared", and "does a locked
+        // dependency name a contract_path" are all answerable in the app repo alone,
+        // and they are the more basic defects. The script now runs those and reports
+        // the resolutions it could not perform, with their denominator — a partial run
+        // that never claims the gate is met (M-ADR 0200 §4.3).
+        build: (ctx) => ({
+            status: "run",
+            args: [
+                "--app-root",
+                ctx.targetRepo,
+                ...(ctx.platformRoot ? ["--platform-root", ctx.platformRoot] : []),
+            ],
+        }),
+    },
+    {
+        name: "adr-structure",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-adr-structure.sh",
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    {
+        name: "spec-lifecycle",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-spec-lifecycle.sh",
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    {
+        name: "no-bare-adr",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-no-bare-adr.sh",
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    {
+        name: "bundle-coherence",
+        source: {
+            kind: "native",
+            run: async (ctx) => checkBundleCoherence(ctx.targetRepo),
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    // Note: validate-runway-classification is intentionally NOT in the app set.
+    // It requires platform-level files (docs/platform/feature-tree.md,
+    // architecture-runway-index.md) that app repos don't own. Per ADR 0089,
+    // the reduced app suite is app-specific validators + shared foundations,
+    // not platform validators.
+];
+const INTEGRATION_VALIDATORS = [
+    {
+        name: "integration-docs",
+        source: { kind: "bundled", script: "validate-integration-docs.sh" },
+        build: (ctx) => ({ status: "run", args: ["--repo-root", ctx.targetRepo] }),
+    },
+    {
+        name: "adr-structure",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-adr-structure.sh",
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    {
+        name: "spec-lifecycle",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-spec-lifecycle.sh",
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    {
+        name: "no-bare-adr",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-no-bare-adr.sh",
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    {
+        name: "bundle-coherence",
+        source: {
+            kind: "native",
+            run: async (ctx) => checkBundleCoherence(ctx.targetRepo),
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+];
+const PLATFORM_VALIDATORS = [
+    {
+        name: "traceability",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-traceability.sh",
+        },
+        build: () => ({ status: "run", args: ["all"] }),
+    },
+    {
+        name: "runway-classification",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-runway-classification.sh",
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    {
+        name: "adr-structure",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-adr-structure.sh",
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    {
+        name: "spec-lifecycle",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-spec-lifecycle.sh",
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    {
+        name: "no-bare-adr",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-no-bare-adr.sh",
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    {
+        name: "corpus-consistency",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-corpus-consistency.sh",
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    {
+        name: "config",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-config.sh",
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    {
+        name: "gate-readiness",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-gate-readiness.sh",
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    {
+        name: "bundle-coherence",
+        source: {
+            kind: "native",
+            run: async (ctx) => checkBundleCoherence(ctx.targetRepo),
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
+    // Optional: the upstream validate-docs.sh dispatcher covers the 6
+    // conditional validators (backward-compatibility, deprecation-runway,
+    // migration-completeness, ddd-artifacts, glossary-alignment,
+    // intent-quality-readiness) and self-skips when their inputs (BASELINE.md,
+    // gate-registry files) aren't present. Invoked via --validator docs-all.
+    {
+        name: "docs-all",
+        source: {
+            kind: "target-repo",
+            relPath: "orchestration/scripts/validate-docs.sh",
+        },
+        build: () => ({ status: "run", args: ["all"] }),
+        optional: true,
+    },
+];
+export function validatorsForProfile(profile) {
+    if (profile === "platform")
+        return PLATFORM_VALIDATORS;
+    return profile === "application" ? APP_VALIDATORS : INTEGRATION_VALIDATORS;
+}
+export function selectValidators(profile, filter) {
+    const all = validatorsForProfile(profile);
+    if (!filter)
+        return all.filter((v) => v.optional !== true);
+    const matched = all.find((v) => v.name === filter);
+    if (!matched) {
+        throw new Error(`Unknown validator "${filter}" for ${profile} profile. Available: ${all
+            .map((v) => v.name)
+            .join(", ")}`);
+    }
+    return [matched];
+}
+//# sourceMappingURL=dispatch.js.map

package/dist/lib/validate/index.js

@@ -0,0 +1,88 @@
+import { profileFromRepoKind, readRepoKind } from "../repo-kind.js";
+import { aggregateResults } from "./aggregate.js";
+import { selectValidators } from "./dispatch.js";
+import { runValidator } from "./runner.js";
+const SECTION_RULE = "═".repeat(59);
+export async function runValidate(opts, stdout = (line) => process.stdout.write(line)) {
+    const repoKind = await readRepoKind(opts.targetRepo);
+    if (repoKind === null) {
+        stdout(fail(`Not an SDD repo: no .sdd-repo-kind marker in ${opts.targetRepo}`));
+        return { exitCode: 1, summary: emptySummary() };
+    }
+    const profile = profileFromRepoKind(repoKind);
+    stdout(section(`Validate (${profile})`));
+    let validators;
+    try {
+        validators = selectValidators(profile, opts.validator);
+    }
+    catch (err) {
+        stdout(fail(err.message));
+        return { exitCode: 1, summary: emptySummary() };
+    }
+    const results = [];
+    for (const cfg of validators) {
+        stdout(info(`Running ${cfg.name}`));
+        const result = await runValidator(cfg, {
+            targetRepo: opts.targetRepo,
+            ...(opts.platformRoot ? { platformRoot: opts.platformRoot } : {}),
+        });
+        results.push(result);
+        if (result.status === "skip") {
+            stdout(skip(`${cfg.name}: skipped — ${result.reason}`));
+            continue;
+        }
+        if (result.stdout)
+            stdout(result.stdout);
+        if (result.stderr)
+            stdout(result.stderr);
+        if (result.exitCode === 0)
+            stdout(pass(`${cfg.name}: ok`));
+        else
+            stdout(fail(`${cfg.name}: exit ${result.exitCode}`));
+    }
+    const summary = aggregateResults(results, { strict: opts.strict });
+    stdout(info(`Summary: passed=${summary.passed} failed=${summary.failed} skipped=${summary.skipped} warned=${summary.warned}${opts.strict ? " (strict)" : ""}`));
+    stdout(verdict(summary, validators.length));
+    return { exitCode: summary.exitCode, summary };
+}
+// Every verdict states its denominator. A skipped validator did not run, so it
+// cannot be covered by a green verdict: "all passed" with one skipped and "all
+// passed" with none were previously the same line (M-ADR 0200 §4.3). The
+// exit code is deliberately unchanged — the defect is the claim, not the
+// gating; whether an unexecutable validator should FAIL is the open design
+// question (post-3.0.0-followons.md A2), not this one.
+function verdict(summary, selected) {
+    if (summary.exitCode !== 0)
+        return fail("One or more validators failed");
+    const ran = summary.passed + summary.failed;
+    if (summary.skipped === 0)
+        return pass("All validators passed");
+    if (ran === 0) {
+        return warn(`0 of ${selected} validators ran — all ${summary.skipped} skipped. ` +
+            `This is an absence of evidence, not a pass.`);
+    }
+    return warn(`${ran} of ${selected} validators passed — ${summary.skipped} skipped, ` +
+        `and a skipped validator is not covered by this verdict.`);
+}
+function section(title) {
+    return `\n${SECTION_RULE}\n  ${title}\n${SECTION_RULE}\n\n`;
+}
+function info(msg) {
+    return `[INFO] ${msg}\n`;
+}
+function pass(msg) {
+    return `[PASS] ${msg}\n`;
+}
+function fail(msg) {
+    return `[FAIL] ${msg}\n`;
+}
+function skip(msg) {
+    return `[SKIP] ${msg}\n`;
+}
+function warn(msg) {
+    return `[WARN] ${msg}\n`;
+}
+function emptySummary() {
+    return { exitCode: 1, passed: 0, failed: 0, skipped: 0, warned: 0 };
+}
+//# sourceMappingURL=index.js.map

package/dist/lib/validate/runner.js

@@ -0,0 +1,85 @@
+import { execFile as execFileCb } from "node:child_process";
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { resolveBundledScript } from "../scripts.js";
+const execFile = promisify(execFileCb);
+export async function runValidator(cfg, ctx) {
+    const built = cfg.build(ctx);
+    if (built.status === "skip") {
+        return {
+            name: cfg.name,
+            scriptPath: null,
+            status: "skip",
+            reason: built.reason,
+        };
+    }
+    if (cfg.source.kind === "native") {
+        const r = await cfg.source.run(ctx);
+        if (r.skipped !== undefined) {
+            return {
+                name: cfg.name,
+                scriptPath: "(native)",
+                status: "skip",
+                reason: r.skipped,
+            };
+        }
+        return {
+            name: cfg.name,
+            scriptPath: "(native)",
+            status: "run",
+            exitCode: r.exitCode,
+            stdout: r.stdout,
+            stderr: "",
+        };
+    }
+    const resolved = await resolveScriptPath(cfg.source, ctx);
+    if (!resolved.exists) {
+        return {
+            name: cfg.name,
+            scriptPath: resolved.path,
+            status: "skip",
+            reason: `script not found in target repo (${resolved.path}); expected sync to have placed it there`,
+        };
+    }
+    try {
+        const { stdout, stderr } = await execFile("bash", [resolved.path, ...built.args], {
+            cwd: ctx.targetRepo,
+            encoding: "utf8",
+            maxBuffer: 16 * 1024 * 1024,
+        });
+        return {
+            name: cfg.name,
+            scriptPath: resolved.path,
+            status: "run",
+            exitCode: 0,
+            stdout,
+            stderr,
+        };
+    }
+    catch (err) {
+        const e = err;
+        return {
+            name: cfg.name,
+            scriptPath: resolved.path,
+            status: "run",
+            exitCode: typeof e.code === "number" ? e.code : 1,
+            stdout: e.stdout ?? "",
+            stderr: e.stderr ?? "",
+        };
+    }
+}
+async function resolveScriptPath(source, ctx) {
+    if (source.kind === "bundled") {
+        return { exists: true, path: resolveBundledScript(source.script) };
+    }
+    const path = join(ctx.targetRepo, source.relPath);
+    try {
+        await access(path);
+        return { exists: true, path };
+    }
+    catch {
+        return { exists: false, path };
+    }
+}
+//# sourceMappingURL=runner.js.map

package/dist/verbs/catalogue-verify.js

@@ -0,0 +1,114 @@
+// The read-only `catalogue` subcommands — validate (incl. --coverage), impact,
+// baseline-check, version — split from `catalogue.ts` so a program can register
+// them without importing the catalogue BUILD path. The verify-only CLI ships
+// these and must not ship code that writes the derived model (M-ADR 0212 §4.3b).
+// `registerCatalogue` calls each at its original position, so sdd-cli's
+// `catalogue` surface and help order are unchanged.
+//
+// ⚠ Import each run* from its own module, NEVER from `../lib/catalogue/index.js`:
+// that barrel re-exports the build and aggregate paths, and one convenience
+// import from it would silently put authoring code back into the verify package.
+import { runBaselineCheck } from "../lib/catalogue/baseline-check.js";
+import { runCatalogueCoverage } from "../lib/catalogue/coverage-run.js";
+import { runCatalogueImpact } from "../lib/catalogue/impact-run.js";
+import { runCatalogueValidate } from "../lib/catalogue/validate.js";
+import { runCatalogueVersion } from "../lib/catalogue/version.js";
+export function registerCatalogueValidate(catalogue) {
+    catalogue
+        .command("validate")
+        .description("Re-run column-shape + FK validation against existing catalogues/ (no rebuild)")
+        .option("--sdd-path <path>", "Path to the SDD repo root (defaults to cwd)")
+        .option("--strict", "Treat findings as failures")
+        .option("--coverage", "Coverage mode: run the engine coverage predicates instead (same lines the gate scripts printed; exit 0 — gating stays the baseline's job)")
+        .option("--tier <tier>", "Coverage tier, explicit never inferred (member | aggregate; default member)")
+        .option("--catalogues-dir <dir>", "Coverage mode: catalogues directory relative to the SDD root (default catalogues)")
+        .action(async (opts) => {
+        if (opts.coverage === true) {
+            if (opts.tier !== undefined &&
+                opts.tier !== "member" &&
+                opts.tier !== "aggregate") {
+                process.stderr.write(`--tier must be 'member' or 'aggregate' (got: ${opts.tier})\n`);
+                process.exit(2);
+            }
+            const result = await runCatalogueCoverage({
+                ...(opts.sddPath !== undefined ? { sddPath: opts.sddPath } : {}),
+                ...(opts.cataloguesDir !== undefined
+                    ? { cataloguesDir: opts.cataloguesDir }
+                    : {}),
+                ...(opts.tier !== undefined
+                    ? { tier: opts.tier }
+                    : {}),
+            }, (s) => process.stdout.write(s));
+            if (result.exitCode !== 0)
+                process.exit(result.exitCode);
+            return;
+        }
+        const result = await runCatalogueValidate({
+            ...(opts.sddPath !== undefined ? { sddPath: opts.sddPath } : {}),
+            ...(opts.strict !== undefined ? { strict: opts.strict } : {}),
+        }, (s) => process.stdout.write(s));
+        if (result.exitCode !== 0)
+            process.exit(result.exitCode);
+    });
+}
+export function registerCatalogueImpact(catalogue) {
+    catalogue
+        .command("impact")
+        .description("Change-impact closure of a node (M-ADR 0206): each relationship is traversed per its declared impact-flow from the rubric-coverage-map — dependency edges reach their consumers, membership edges propagate part-to-whole only, xref/lineage records are inert — computed by recursive SQL on the embedded engine, with the co-directionality invariant asserted on every run")
+        .requiredOption("--of <node-id>", 'Node to compute impact of, in the projection\'s "<catalogue>/<id>" form (e.g. contracts/orders-api)')
+        .option("--sdd-path <path>", "Path to the SDD repo root (defaults to cwd)")
+        .option("--catalogues-dir <dir>", "Catalogues directory relative to the SDD root (default catalogues)")
+        .option("--tier <tier>", "Tier, explicit never inferred (member | aggregate; default member)")
+        .action(async (opts) => {
+        if (opts.tier !== undefined &&
+            opts.tier !== "member" &&
+            opts.tier !== "aggregate") {
+            process.stderr.write(`--tier must be 'member' or 'aggregate' (got: ${opts.tier})\n`);
+            process.exit(2);
+        }
+        const result = await runCatalogueImpact({
+            of: opts.of,
+            ...(opts.sddPath !== undefined ? { sddPath: opts.sddPath } : {}),
+            ...(opts.cataloguesDir !== undefined
+                ? { cataloguesDir: opts.cataloguesDir }
+                : {}),
+            ...(opts.tier !== undefined
+                ? { tier: opts.tier }
+                : {}),
+        }, (s) => process.stdout.write(s));
+        if (result.exitCode !== 0)
+            process.exit(result.exitCode);
+    });
+}
+export function registerCatalogueBaselineCheck(catalogue) {
+    catalogue
+        .command("baseline-check")
+        .description("Compare emitted findings against the repo's findings baseline BY IDENTITY (M-ADR 0132 §9) — a reworded finding reports as reworded, not as one closed and one new")
+        .option("--sdd-path <path>", "Path to the SDD repo root (defaults to cwd)")
+        .option("--findings <path>", "File of findings to compare (defaults to stdin, so it composes with `catalogue validate --coverage`)")
+        .option("--baseline <path>", "Baseline file (defaults to <sdd-path>/orchestration/catalogue-findings-baseline.txt)")
+        .action(async (opts) => {
+        const result = await runBaselineCheck({
+            ...(opts.sddPath !== undefined ? { sddPath: opts.sddPath } : {}),
+            ...(opts.findings !== undefined ? { findings: opts.findings } : {}),
+            ...(opts.baseline !== undefined ? { baseline: opts.baseline } : {}),
+            stdin: async () => {
+                const chunks = [];
+                for await (const c of process.stdin)
+                    chunks.push(Buffer.from(c));
+                return Buffer.concat(chunks).toString("utf-8");
+            },
+        }, (s) => process.stdout.write(s));
+        if (result.exitCode !== 0)
+            process.exit(result.exitCode);
+    });
+}
+export function registerCatalogueVersion(catalogue) {
+    catalogue
+        .command("version")
+        .description("Print the catalogue schema version + sdd-cli version pin")
+        .action(async () => {
+        await runCatalogueVersion((s) => process.stdout.write(s));
+    });
+}
+//# sourceMappingURL=catalogue-verify.js.map

package/dist/verbs/list.js

@@ -0,0 +1,45 @@
+import { runList } from "../lib/list/index.js";
+const VALID_PROFILES = [
+    "platform",
+    "application",
+    "integration",
+];
+export function registerList(program) {
+    program
+        .command("list")
+        .description("Enumerate SDD repositories discoverable in the current workspace, including adopter pack provenance (ADR 0151)")
+        .option("--profile <profile>", "filter by profile: platform | application | integration")
+        .option("--workspace-root <path>", "workspace directory to walk (repeatable; defaults to cwd)", collectRoots, [])
+        .option("--format <format>", "output format: text | json", "text")
+        .option("--verbose", "show managed_path counts per bundle (text format)")
+        .action(async (opts) => {
+        const profileFilter = parseProfile(opts.profile);
+        const format = parseFormat(opts.format);
+        const { exitCode } = await runList({
+            workspaceRoots: opts.workspaceRoot ?? [],
+            format,
+            verbose: opts.verbose === true,
+            ...(profileFilter ? { profileFilter } : {}),
+        }, (s) => process.stdout.write(s));
+        if (exitCode !== 0)
+            process.exit(exitCode);
+    });
+}
+function collectRoots(value, prior) {
+    prior.push(value);
+    return prior;
+}
+function parseProfile(value) {
+    if (value === undefined)
+        return undefined;
+    if (!VALID_PROFILES.includes(value)) {
+        throw new Error(`Unknown --profile "${value}". Expected one of: ${VALID_PROFILES.join(", ")}`);
+    }
+    return value;
+}
+function parseFormat(value) {
+    if (value === "text" || value === "json")
+        return value;
+    throw new Error(`Unknown --format "${value}". Expected "text" or "json".`);
+}
+//# sourceMappingURL=list.js.map

package/dist/verbs/pack-validate.js

@@ -0,0 +1,17 @@
+// `pack validate` registration, split from `pack.ts` so a program can register
+// it without importing `runPackBuild` — the verify-only CLI must not ship the
+// code that writes a pack (M-ADR 0212 §4.3b). `registerPack` calls this, so
+// sdd-cli's `pack` surface and help order are unchanged.
+import { runPackValidate } from "../lib/pack/validate.js";
+export function registerPackValidate(pack) {
+    pack
+        .command("validate")
+        .description("Validate a context-pack seed file against the canonical schema. Fast feedback for authoring.")
+        .requiredOption("--seed <path>", "path to the seed file (orchestration/distribution/{name}-seed.yaml)")
+        .action(async (opts) => {
+        const { exitCode } = await runPackValidate({ seedPath: opts.seed });
+        if (exitCode !== 0)
+            process.exit(exitCode);
+    });
+}
+//# sourceMappingURL=pack-validate.js.map

package/dist/verbs/path-option.js

@@ -0,0 +1,25 @@
+import { resolve } from "node:path";
+/**
+ * Commander parse-arg coercion for an option naming a DIRECTORY ON DISK.
+ *
+ * Resolves the operand to an absolute path ONCE, at the option boundary, before
+ * any verb sees it. That placement is the fix, not a detail: B6 was a relative
+ * `--target-repo` that resolved far enough to succeed at the first read and
+ * then failed at every later one.
+ *
+ * `validate` read `.sdd-repo-kind` relative to the process cwd — which WORKS,
+ * so the run announced the correct profile and dispatched the full validator
+ * set — then handed the same unresolved string to bash validators running from
+ * a different working directory, which reported `App root not found` and exit
+ * 127. A healthy repo came back `passed=0 failed=5`, so the operator saw a
+ * broken REPO rather than a bad ARGUMENT. Repairing those messages would have
+ * been the wrong fix; the path is what is wrong, and it is wrong exactly once.
+ *
+ * Resolving at the boundary also means a verb cannot forget: there is no
+ * per-consumer `resolve()` to omit, and a new consumer of the option inherits
+ * an absolute path by construction.
+ */
+export function resolvePathOption(value) {
+    return resolve(value);
+}
+//# sourceMappingURL=path-option.js.map

package/dist/verbs/validate.js

@@ -0,0 +1,22 @@
+import { runValidate } from "../lib/validate/index.js";
+import { resolvePathOption } from "./path-option.js";
+export function registerValidate(program) {
+    program
+        .command("validate")
+        .description("Run the method-level validation suite for this SDD repository")
+        .option("--target-repo <dir>", "target SDD repo", resolvePathOption, process.cwd())
+        .option("--platform-root <dir>", "path to the sdd-method (or platform) repo, required for app-dependencies", resolvePathOption)
+        .option("--validator <name>", "run only the named validator")
+        .option("--strict", "treat warnings as failures")
+        .action(async (opts) => {
+        const { exitCode } = await runValidate({
+            targetRepo: opts.targetRepo,
+            ...(opts.platformRoot ? { platformRoot: opts.platformRoot } : {}),
+            ...(opts.validator ? { validator: opts.validator } : {}),
+            strict: opts.strict === true,
+        });
+        if (exitCode !== 0)
+            process.exit(exitCode);
+    });
+}
+//# sourceMappingURL=validate.js.map

package/dist/verify-bin.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { runVerify } from "./verify-program.js";
+runVerify(process.argv.slice(2)).catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`sdd-verify: ${message}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=verify-bin.js.map