@sdd-method/maintain-cli 0.0.0-stage → 0.1.0

package/dist/lib/pack/publish-transform.js

@@ -0,0 +1,233 @@
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { ORIGIN_PREFIX_SRC, originPrefixForNumber, originPrefixForPath, } from "../adr-origin.js";
+export { originPrefixForNumber };
+/**
+ * Publish transform (sdd-method ADR 0183 / 0184). Produces the point-in-time,
+ * producer-agnostic *published* form of method markdown by subtraction from the
+ * canon, and gates the result with a fail-closed deny-class lint.
+ *
+ * The strip is a pure structural transform — it removes marked structures and
+ * never reads meaning, so it cannot misinterpret. The lint runs on the produced
+ * output and proves nothing leaked; it never decides what to strip. Authors
+ * carry the burden of placing evolution / producer content in the structured
+ * places (lineage regions, stripped fields), enforced at author/CI time.
+ *
+ * Enabled only for method-baseline builds (BuildOptions.publishTransform);
+ * adopter-pack builds are unaffected.
+ */
+// Header fields stripped on publish (ADR 0184 — adr-metadata-schema.md).
+const STRIPPED_FIELDS = [
+    "Status History",
+    "Acceptance Rationale",
+    "Supersedes",
+    "Superseded By",
+    "Amends",
+    "Source",
+    "Grounding",
+    "Introduced In",
+];
+const STRIPPED_FIELD_RE = new RegExp(`^\\* \\*\\*(${STRIPPED_FIELDS.join("|")}):\\*\\*`);
+const LINEAGE_START = "<!-- lineage:start -->";
+const LINEAGE_END = "<!-- lineage:end -->";
+// Published-surface deny-classes. Kept in lock-step with the reference gate in
+// sdd-method orchestration/scripts/validate-adr-structure.sh (--publish-lint).
+// A line carrying `pit-ok` is exempt; a file carrying `pit-ok-file` is exempt
+// wholesale (a meta/versioning ADR whose deny-vocabulary IS its subject).
+const DENY_TEMPORAL = [
+    /since retired/i,
+    /previously/i,
+    /formerly/i,
+    /supersed/i,
+    /no longer/i,
+    /pre-federation/i,
+    /used to/i,
+    /bumps? to/i,
+    /sdd-cli [0-9]/i,
+    /\bv[0-9]+\.[0-9]+\.[0-9]+/i,
+];
+const DENY_PRODUCER = [
+    /sdd-method#/i,
+    /sdd-method-gov/i,
+    /sdd-method repo/i,
+    /the method repo/i,
+    /governance repo/i,
+    /synced from (sdd-method|the method)/i,
+    /bootstrap.?procedure/i,
+];
+/** True when the markdown is an ADR with `Status: Accepted`. */
+export function isAccepted(content) {
+    const m = content.match(/^\*\s+\*\*Status:\*\*\s*([A-Za-z]+)/m);
+    return m?.[1] === "Accepted";
+}
+/** Path is an ADR file (under an `adr/` or `platform-adr/` dir), bare or prefixed. */
+export function isAdrPath(relPath) {
+    return new RegExp(`adr\\/${ORIGIN_PREFIX_SRC}ADR \\d`, "i").test(relPath);
+}
+/** Remove lineage regions + stripped-class header fields. Deterministic. */
+export function stripStructures(content) {
+    const out = [];
+    let inLineage = false;
+    for (const line of content.split("\n")) {
+        if (line.includes(LINEAGE_START)) {
+            inLineage = true;
+            continue;
+        }
+        if (line.includes(LINEAGE_END)) {
+            inLineage = false;
+            continue;
+        }
+        if (inLineage)
+            continue;
+        if (STRIPPED_FIELD_RE.test(line))
+            continue;
+        out.push(line);
+    }
+    return out.join("\n");
+}
+/**
+ * Flatten cross-repo references to the flat in-namespace form (M-ADR 0184 §4.3):
+ * `sdd-method#<id>` becomes the canonical prefixed identifier for that number's
+ * band (`sdd-method#0174` → `M-ADR 0174`), never a bare `ADR` (M-ADR 0186 — no
+ * bare ADR on any SDD surface). Numbers outside the assigned bands fall back to
+ * the bare form.
+ */
+export function flattenCrossRefs(content) {
+    return content.replace(/\bsdd-method#(\d{3,4})\b/g, (_m, num) => {
+        const p = originPrefixForNumber(num);
+        return p ? `${p} ${num}` : `ADR ${num}`;
+    });
+}
+/**
+ * Rewrite bare in-namespace `ADR NNNN` refs to their PRODUCER origin prefix by
+ * number band (`0xxx`→`M-ADR`, `9xxx`→`RA-ADR`). Adopter refs (`1000–8999`) are
+ * left bare here — their `P-`/`D-` prefix is scope-derived (M-ADR 0186 §4.3) and
+ * applied by the estate rename from a corpus map, not from the number alone.
+ * Matches the prose form ("ADR 0140") and the URL-encoded link-target form
+ * ("ADR%200140"), separator preserved, so renamed files and their hrefs stay in
+ * lock-step. The `(?<![\w-])` guard leaves an already-prefixed ref untouched
+ * (the `-` before `ADR` fails the lookbehind) — idempotent.
+ */
+export function applyOriginPrefix(content) {
+    return content.replace(/(?<![\w-])ADR(%20| )(\d{3,4})(?!\d)/g, (m, sep, num) => {
+        const p = originPrefixForNumber(num);
+        return p ? `${p}${sep}${num}` : m;
+    });
+}
+/** @deprecated Back-compat alias for `applyOriginPrefix` (producer-band prefixing). */
+export const applyMAdrPrefix = applyOriginPrefix;
+/**
+ * The canonical filename for an ADR: the *basename* `ADR NNNN…` gains its origin
+ * prefix (`M-ADR`/`RA-ADR` by number band, `P-ADR`/`D-ADR` by scope — M-ADR 0186).
+ * The containing directory is never touched, only the leading `ADR ` of the
+ * basename; the directory is what determines an adopter ADR's scope. Returns the
+ * path unchanged when it is not an `ADR NNNN` file or the prefix is undeterminable.
+ * Idempotent: an already-prefixed name is left alone.
+ */
+export function mAdrFilename(relPath) {
+    return relPath.replace(/(^|\/)ADR (\d{3,4})/, (m, pre, num) => {
+        const p = originPrefixForPath(relPath, num);
+        return p ? `${pre}${p} ${num}` : m;
+    });
+}
+/** The full published form of a markdown document. */
+export function transformPublished(content, opts = {}) {
+    let c = stripStructures(content);
+    c = flattenCrossRefs(c);
+    if (opts.mAdrPrefix)
+        c = applyMAdrPrefix(c);
+    return c;
+}
+/** Scan already-published content for deny-class leaks. */
+export function lintPublished(published, relPath) {
+    if (published.includes("pit-ok-file"))
+        return [];
+    const violations = [];
+    const lines = published.split("\n");
+    lines.forEach((line, i) => {
+        if (line.includes("pit-ok"))
+            return;
+        for (const re of DENY_TEMPORAL) {
+            if (re.test(line)) {
+                violations.push({
+                    path: relPath,
+                    cls: "temporal",
+                    pattern: re.source,
+                    line: i + 1,
+                    text: line.slice(0, 140),
+                });
+            }
+        }
+        for (const re of DENY_PRODUCER) {
+            if (re.test(line)) {
+                violations.push({
+                    path: relPath,
+                    cls: "producer",
+                    pattern: re.source,
+                    line: i + 1,
+                    text: line.slice(0, 140),
+                });
+            }
+        }
+    });
+    return violations;
+}
+/**
+ * Apply the publish transform to a staged payload in place: drop non-Accepted
+ * ADRs, transform every markdown file to its published form, and lint the
+ * result. Returns the retained paths + any violations (caller fails closed).
+ */
+export async function applyPublishTransform(payloadRoot, paths, opts = {}) {
+    const keptPaths = [];
+    const droppedPaths = [];
+    const violations = [];
+    for (const p of paths) {
+        if (!p.endsWith(".md")) {
+            // Non-Markdown config/data (registry.yaml, seed lists, schemas): flatten
+            // cross-repo refs so the published config surface is producer-agnostic,
+            // and — under the origin-prefix rename — range-prefix bare in-namespace
+            // ADR refs so the config matches the renamed decision files. No lineage
+            // strip / Accepted filter / file rename applies here. Mirrors the method
+            // baseline builder's yaml/yml/txt handling.
+            if (/\.(ya?ml|txt)$/.test(p)) {
+                const abs = join(payloadRoot, p);
+                const content = await readFile(abs, "utf8");
+                let rewritten = flattenCrossRefs(content);
+                if (opts.mAdrPrefix)
+                    rewritten = applyOriginPrefix(rewritten);
+                if (rewritten !== content)
+                    await writeFile(abs, rewritten);
+            }
+            keptPaths.push(p);
+            continue;
+        }
+        const abs = join(payloadRoot, p);
+        const content = await readFile(abs, "utf8");
+        // Accepted-only: a non-Accepted ADR is not part of "what the method is".
+        if (isAdrPath(p) && !isAccepted(content)) {
+            await rm(abs, { force: true });
+            droppedPaths.push(p);
+            continue;
+        }
+        const published = transformPublished(content, opts);
+        violations.push(...lintPublished(published, p));
+        if (published !== content) {
+            await writeFile(abs, published);
+        }
+        // Under the M-ADR rename, the published *file* is renamed too so the
+        // filename matches its (rewritten) heading. Canon filenames stay `ADR`;
+        // this is published-output only. The renamed path is what flows into
+        // MANAGED_PATHS + checksums, so the lock + sync stay self-consistent.
+        let outPath = p;
+        if (opts.mAdrPrefix && isAdrPath(p)) {
+            const renamed = mAdrFilename(p);
+            if (renamed !== p) {
+                await rename(abs, join(payloadRoot, renamed));
+                outPath = renamed;
+            }
+        }
+        keptPaths.push(outPath);
+    }
+    return { keptPaths, droppedPaths, violations };
+}
+//# sourceMappingURL=publish-transform.js.map

package/dist/lib/pack/reference-closure.js

@@ -0,0 +1,125 @@
+/**
+ * Reference-closure reporter — M-ADR 0151 §4.6.
+ *
+ * A context pack ships a SUBSET of its producer's corpus, so payload
+ * documents may reference files the pack does not carry. Policy: a link
+ * resolves in the repository that OWNS the document; a distributed copy
+ * referencing the wider corpus is informational. This reporter makes the
+ * property VISIBLE at cut time — the pack declares "ships N references
+ * that resolve only in the producer" instead of a consumer discovering it
+ * by resolving the whole corpus after distribution.
+ *
+ * Reporting-only, by design: the deliberate asymmetry with method-baseline
+ * bundles, whose seed lists ship whole corpora and therefore carry closure
+ * ENFORCEMENT (validate-link-closure.sh). A subset cannot satisfy closure
+ * without ceasing to be a subset.
+ *
+ * Parser hardening comes from the estate that measured this problem — the
+ * four traps their link audit hit are this module's controls: markdown
+ * targets containing SPACES (unencoded paths must not truncate at the first
+ * space), targets containing PARENTHESES (balance them; "…(ReBAC).md" broke
+ * every naive regex), URL-ENCODED targets (%20, %3A… decode before
+ * resolving), and never scanning outside the payload set (no cache dirs —
+ * guaranteed here by construction, since only staged payload paths are read).
+ */
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { posix } from "node:path";
+/**
+ * Extract markdown link targets from one document. Handles `[text](target)`
+ * and `![alt](target)` with BALANCED parentheses inside the target, the
+ * `](<target>)` angle form, and `](target "title")` suffixes.
+ */
+export function extractLinkTargets(content) {
+    const targets = [];
+    let i = 0;
+    for (;;) {
+        const at = content.indexOf("](", i);
+        if (at === -1)
+            break;
+        let j = at + 2;
+        let target;
+        if (content[j] === "<") {
+            const close = content.indexOf(">", j + 1);
+            if (close === -1)
+                break;
+            target = content.slice(j + 1, close);
+            i = close + 1;
+        }
+        else {
+            let depth = 1;
+            const start = j;
+            while (j < content.length && depth > 0) {
+                const c = content[j];
+                if (c === "(")
+                    depth += 1;
+                else if (c === ")")
+                    depth -= 1;
+                if (depth > 0)
+                    j += 1;
+            }
+            if (depth !== 0)
+                break;
+            target = content.slice(start, j);
+            i = j + 1;
+        }
+        // Strip a `"title"` suffix (markdown allows `](url "title")`).
+        const title = target.match(/^(.*\S)\s+"[^"]*"$/s);
+        if (title)
+            target = title[1];
+        targets.push(target.trim());
+    }
+    return targets;
+}
+function decodeTarget(raw) {
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        return undefined; // malformed escape — count as unresolvable via caller
+    }
+}
+/**
+ * Resolve every markdown link in the payload's .md files against the
+ * payload's own file set.
+ */
+export async function checkReferenceClosure(payloadRoot, payloadPaths) {
+    const inPayload = new Set(payloadPaths.map((p) => posix.normalize(p)));
+    let total = 0;
+    let unresolvable = 0;
+    const misses = new Set();
+    for (const p of payloadPaths) {
+        if (!p.endsWith(".md"))
+            continue;
+        const content = await readFile(join(payloadRoot, p), "utf-8");
+        const dir = posix.dirname(p);
+        for (const rawTarget of extractLinkTargets(content)) {
+            // External and non-file targets are out of scope.
+            if (/^[a-z][a-z0-9+.-]*:/i.test(rawTarget))
+                continue; // http:, mailto:, …
+            const withoutAnchor = rawTarget.split("#")[0];
+            if (withoutAnchor === "")
+                continue; // pure anchor
+            const decoded = decodeTarget(withoutAnchor);
+            total += 1;
+            if (decoded === undefined) {
+                unresolvable += 1;
+                misses.add(rawTarget);
+                continue;
+            }
+            const resolved = decoded.startsWith("/")
+                ? posix.normalize(decoded.slice(1))
+                : posix.normalize(posix.join(dir, decoded));
+            if (!inPayload.has(resolved)) {
+                unresolvable += 1;
+                misses.add(resolved);
+            }
+        }
+    }
+    return {
+        totalReferences: total,
+        unresolvable,
+        unresolvableTargets: [...misses].sort(),
+    };
+}
+//# sourceMappingURL=reference-closure.js.map

package/dist/lib/pack/schema.js

@@ -0,0 +1,121 @@
+import { z } from "zod";
+/**
+ * Zod schema for adopter pack seeds. Mirrors
+ * docs/method/foundations/schemas/context-pack-seed-schema.yaml.
+ *
+ * Used by `sdd-cli pack validate` for fast feedback during authoring.
+ * The structural parse in seed.ts already enforces presence of required
+ * fields; this schema layer adds value-shape checks (semver patterns,
+ * known forward-base bundle names, non-empty managed_paths).
+ */
+const SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
+const VERSIONED_RANGE_PATTERN = /^(\^|~|>=)?v?\d+\.\d+\.\d+$/;
+// Exported so the canonical-schema conformance test can assert this vocabulary
+// matches context-pack-seed-schema.yaml's `forward_base.bundle` enum. The two had
+// drifted (canonical carried three values, this four) with nothing to detect it.
+export const KNOWN_FORWARD_BASES = [
+    "app-baseline",
+    "integration-baseline",
+    "platform-baseline",
+    "reverse-baseline",
+];
+export const PackSeedSchema = z.object({
+    version: z
+        .string()
+        .regex(SEMVER_PATTERN, "version must be semver (X.Y.Z)"),
+    scope: z
+        .string()
+        .regex(/^[a-z0-9-]+$/, "scope must be lower-kebab-case slug"),
+    // Optional per ADR 0176 §4.6: absent = profile-agnostic pack.
+    forwardBase: z
+        .object({
+        bundle: z.enum(KNOWN_FORWARD_BASES),
+        minimumVersion: z
+            .string()
+            .regex(/^v\d+\.\d+\.\d+$/, "forward_base.minimum_version must be vX.Y.Z"),
+        sourceRepo: z.string().min(1),
+    })
+        .optional(),
+    // Vendor-base pack pin (M-ADR 0175, seed schema 1.2.0). Present only on a
+    // vendor-base pack: names the vendor and the vendor version whose documented
+    // truth this pack's content encodes.
+    //
+    // The point of a PACK-LEVEL pin is that a consuming SDD does not restate it. A
+    // consumer pins the pack exactly (its bundles-list entry + sha256) and the
+    // vendor version it inherits is DERIVED from here. Recording it consumer-side
+    // as well would be a second source of truth that can silently disagree, and the
+    // pack is authoritative for its own vendor pin.
+    //
+    // `vendorVersion` is free-form by design: it carries either a formal vendor
+    // version or the anchor schema's `<vendor>-docs@YYYY-MM-DD` snapshot form, and
+    // vendors' own version strings are not the method's to constrain.
+    vendorBase: z
+        .object({
+        vendor: z
+            .string()
+            .regex(/^[a-z][a-z0-9-]*$/, "vendor_base.vendor must be a lower-kebab-case slug"),
+        vendorVersion: z.string().min(1, "vendor_base.vendor_version must be non-empty"),
+    })
+        .optional(),
+    minimumSddCliVersion: z
+        .string()
+        .regex(SEMVER_PATTERN, "minimum_sdd_cli_version must be semver (X.Y.Z)"),
+    description: z.string().min(1),
+    include: z.array(z.string()).optional(),
+    managedPaths: z
+        .array(z.string().min(1))
+        .min(1, "managed_paths must have at least one entry"),
+    forbiddenPaths: z.array(z.string()).optional(),
+    // ADR 0176 §4.3: scaffold-source path prefixes; each must cover at
+    // least one managed_paths entry (checked in the superRefine below).
+    scaffoldSourcePaths: z.array(z.string().min(1)).optional(),
+    requiresPack: z
+        .object({
+        name: z.string().min(1),
+        version: z
+            .string()
+            .regex(VERSIONED_RANGE_PATTERN, "requires_pack.version must be a semver range (e.g. ^v1.2.0)"),
+    })
+        .optional(),
+    sourcePath: z.string(),
+});
+const PackSeedSchemaRefined = PackSeedSchema.superRefine((seed, ctx) => {
+    // A vendor-base pack is PROFILE-AGNOSTIC (M-ADR 0176 §4.6, M-ADR 0175): its
+    // content is vendor-defined, so it layers over any baseline and must not pin
+    // one. Declaring both is a contradiction the producer should hear at validate
+    // time rather than discover when a consumer on a different baseline cannot
+    // apply it.
+    if (seed.vendorBase && seed.forwardBase) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["forwardBase"],
+            message: "a vendor_base pack is profile-agnostic and must omit forward_base " +
+                "(M-ADR 0176 §4.6); remove forward_base, or remove vendor_base if this " +
+                "is not a vendor-base pack",
+        });
+    }
+    if (!seed.scaffoldSourcePaths)
+        return;
+    for (const [i, prefix] of seed.scaffoldSourcePaths.entries()) {
+        const covers = seed.managedPaths.some((mp) => mp.startsWith(prefix));
+        if (!covers) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["scaffoldSourcePaths", i],
+                message: `scaffold_source_paths entry "${prefix}" matches no managed_paths entry`,
+            });
+        }
+    }
+});
+export function validateSeed(seed) {
+    const result = PackSeedSchemaRefined.safeParse(seed);
+    if (result.success) {
+        return { ok: true, errors: [] };
+    }
+    const errors = result.error.issues.map((issue) => ({
+        field: issue.path.join("."),
+        message: issue.message,
+    }));
+    return { ok: false, errors };
+}
+//# sourceMappingURL=schema.js.map

package/dist/lib/pack/seed.js

@@ -0,0 +1,182 @@
+import { readFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+/**
+ * Adopter pack seed file. Per ADR 0151 + context-pack-seed-schema.yaml.
+ *
+ * Loaded by `sdd-cli pack build` and `sdd-cli pack validate` from
+ * `orchestration/distribution/{pack-name}-seed.yaml` in adopter repos.
+ *
+ * Includes are resolved before validation: the merged seed presents
+ * all `include`'d managed_paths + forbidden_paths concatenated with
+ * the host seed's own.
+ */
+/**
+ * Authored seed keys, snake_case → the camelCase field they map to.
+ *
+ * THE SINGLE SOURCE OF TRUTH for "what may appear in a seed file". It lived only
+ * inside the canonical-conformance test, which meant the loader had no idea what a
+ * valid key set was — so an unrecognised key was dropped by the hand-mapping below
+ * without a word. An adopter following a schema that documents a field their sdd-cli
+ * predates got a clean validation and a silent no-op: the same failure M-ADR 0175's
+ * history records for `packaging`, and the same one fixed for `.sdd/sdd-manifest.yaml`
+ * in 0.110.1 — but by a different mechanism, which is why that fix did not cover this.
+ *
+ * The conformance test now imports this rather than declaring its own copy. Two
+ * hand-maintained lists of the same facts is how the lifecycle expectation drifted.
+ */
+export const SEED_KEY_TO_FIELD = {
+    version: "version",
+    scope: "scope",
+    forward_base: "forwardBase",
+    vendor_base: "vendorBase",
+    minimum_sdd_cli_version: "minimumSddCliVersion",
+    description: "description",
+    include: "include",
+    managed_paths: "managedPaths",
+    forbidden_paths: "forbiddenPaths",
+    scaffold_source_paths: "scaffoldSourcePaths",
+    requires_pack: "requiresPack",
+};
+/**
+ * Top-level keys in a seed file that this build does not recognise.
+ *
+ * Deliberately TOP-LEVEL only, stated as a limit rather than left implied: nested
+ * blocks (`forward_base`, `vendor_base`, `requires_pack`) are hand-mapped field by
+ * field too, so an unknown key inside one is still dropped silently today.
+ */
+export function unknownSeedKeys(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return [];
+    return Object.keys(raw)
+        .filter((k) => !(k in SEED_KEY_TO_FIELD))
+        .sort();
+}
+/**
+ * Load a seed file from disk, resolve its `include:` directives,
+ * and return a merged PackSeed. Throws if any include cannot be read
+ * or if circular includes are detected.
+ *
+ * NOTE: This does not validate the seed structure — only parses YAML
+ * and assembles the typed shape. Use `validateSeed` (separate module)
+ * for schema enforcement.
+ */
+export async function loadSeed(seedPath) {
+    const absPath = isAbsolute(seedPath) ? seedPath : resolve(seedPath);
+    const visited = new Set();
+    return loadSeedRecursive(absPath, visited);
+}
+async function loadSeedRecursive(absPath, visited) {
+    if (visited.has(absPath)) {
+        throw new Error(`Circular include detected at ${absPath}`);
+    }
+    visited.add(absPath);
+    let raw;
+    try {
+        raw = await readFile(absPath, "utf8");
+    }
+    catch (err) {
+        throw new Error(`Cannot read seed file ${absPath}: ${err.message}`);
+    }
+    const parsed = parseYaml(raw);
+    if (parsed === null || typeof parsed !== "object") {
+        throw new Error(`Seed file ${absPath} is not a YAML object`);
+    }
+    const baseDir = dirname(absPath);
+    const includes = Array.isArray(parsed.include) ? parsed.include : [];
+    const includedManaged = [];
+    const includedForbidden = [];
+    const includedUnknown = [];
+    for (const inc of includes) {
+        if (typeof inc !== "string") {
+            throw new Error(`Non-string include entry in ${absPath}: ${String(inc)}`);
+        }
+        const incPath = isAbsolute(inc) ? inc : resolve(baseDir, inc);
+        const includedSeed = await loadSeedRecursive(incPath, visited);
+        includedManaged.push(...includedSeed.managedPaths);
+        if (includedSeed.forbiddenPaths) {
+            includedForbidden.push(...includedSeed.forbiddenPaths);
+        }
+        if (includedSeed.unknownKeys)
+            includedUnknown.push(...includedSeed.unknownKeys);
+    }
+    // Unknown keys from this file, plus everything its includes reported. An included
+    // seed's stray key is as silently dropped as the root's, so the queue is unioned.
+    const ownUnknown = unknownSeedKeys(parsed);
+    const own = parsed;
+    const managedPaths = [
+        ...includedManaged,
+        ...asStringArray(own.managed_paths, "managed_paths", absPath),
+    ];
+    const forbiddenPaths = includedForbidden.length > 0 || Array.isArray(own.forbidden_paths)
+        ? [
+            ...includedForbidden,
+            ...asStringArray(own.forbidden_paths, "forbidden_paths", absPath, true),
+        ]
+        : undefined;
+    const scaffoldSourcePaths = Array.isArray(own.scaffold_source_paths)
+        ? asStringArray(own.scaffold_source_paths, "scaffold_source_paths", absPath, true)
+        : undefined;
+    const seed = {
+        version: asString(own.version, "version", absPath),
+        scope: asString(own.scope, "scope", absPath),
+        // forward_base optional per ADR 0176 §4.6 (profile-agnostic packs omit it)
+        ...(own.forward_base && {
+            forwardBase: {
+                bundle: asString(own.forward_base.bundle, "forward_base.bundle", absPath),
+                minimumVersion: asString(own.forward_base.minimum_version, "forward_base.minimum_version", absPath),
+                sourceRepo: own.forward_base.source_repo
+                    ? asString(own.forward_base.source_repo, "forward_base.source_repo", absPath)
+                    : "sdd-method",
+            },
+        }),
+        // vendor_base present only on a vendor-base pack (M-ADR 0175); the
+        // profile-agnostic/forward_base contradiction is caught in validateSeed.
+        ...(own.vendor_base && {
+            vendorBase: {
+                vendor: asString(own.vendor_base.vendor, "vendor_base.vendor", absPath),
+                vendorVersion: asString(own.vendor_base.vendor_version, "vendor_base.vendor_version", absPath),
+            },
+        }),
+        minimumSddCliVersion: asString(own.minimum_sdd_cli_version, "minimum_sdd_cli_version", absPath),
+        description: asString(own.description, "description", absPath),
+        managedPaths,
+        sourcePath: absPath,
+        ...(ownUnknown.length + includedUnknown.length > 0
+            ? { unknownKeys: [...new Set([...includedUnknown, ...ownUnknown])].sort() }
+            : {}),
+        ...(includes.length > 0 && { include: includes }),
+        ...(forbiddenPaths && { forbiddenPaths }),
+        ...(scaffoldSourcePaths && scaffoldSourcePaths.length > 0 && { scaffoldSourcePaths }),
+        ...(own.requires_pack && {
+            requiresPack: {
+                name: asString(own.requires_pack.name, "requires_pack.name", absPath),
+                version: asString(own.requires_pack.version, "requires_pack.version", absPath),
+            },
+        }),
+    };
+    return seed;
+}
+function asString(value, field, file) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`Seed field "${field}" must be a non-empty string in ${file}`);
+    }
+    return value;
+}
+function asStringArray(value, field, file, allowEmpty = false) {
+    if (value === undefined || value === null) {
+        if (allowEmpty)
+            return [];
+        throw new Error(`Seed field "${field}" is required in ${file}`);
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`Seed field "${field}" must be a list in ${file}`);
+    }
+    for (const entry of value) {
+        if (typeof entry !== "string") {
+            throw new Error(`Seed field "${field}" entries must be strings in ${file}`);
+        }
+    }
+    return value;
+}
+//# sourceMappingURL=seed.js.map