@sdd-method/maintain-cli 0.0.0-stage → 0.1.0-rc.0

package/dist/lib/sync/bundle-cache.js

@@ -0,0 +1,109 @@
+import { appendFile, copyFile, mkdir, readFile, readdir, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+/**
+ * Consumer-side bundle cache (ADR 0176 §4.2).
+ *
+ * Every consumed non-forward-base bundle is extracted to
+ * `<targetRepo>/.sdd/bundle-cache/<bundleName>@<version>/` — the
+ * resolution substrate for `sdd-cli scaffold domain --archetype` and
+ * the staging source for materialise-mode paths. The cache directory
+ * is gitignored (ensured at sync time).
+ *
+ * Cache layout per bundle: the bundle's payload tree, verbatim (so
+ * registry.yaml and scaffold-source files sit at their shipped paths).
+ * Stale versions of the same bundle name are pruned on refresh.
+ */
+export const BUNDLE_CACHE_REL = ".sdd/bundle-cache";
+/**
+ * The registry file name (ADR 0176 §4.1) — always cache-only. A bundle may
+ * ship its registry at the payload root or nested (a multi-bundle producer
+ * repo keeps one registry per bundle subtree, e.g. a vertical overlay's
+ * `verticals/fleet/registry.yaml`, because the producer-layout rule forbids
+ * path mapping and the root name can only be claimed once).
+ */
+export const REGISTRY_FILE = "registry.yaml";
+/**
+ * The application-archetype vocabulary file name (M-ADR 0191 §4.2) — always
+ * cache-only, like the registry. Carries the seedless classification
+ * vocabulary a bundle contributes (resolution data, not adopter-editable
+ * content). May sit at the payload root (core layer) or nested (a vertical
+ * overlay's `verticals/<v>/application-archetypes.yaml`), same as the
+ * registry.
+ */
+export const VOCAB_FILE = "application-archetypes.yaml";
+/**
+ * Split a bundle's managed paths into the set to materialise into the
+ * repo tree vs the set that stays cache-only (ADR 0176 §4.3):
+ * scaffold-source-prefixed paths, registry files, and the archetype
+ * vocabulary file are cache-only.
+ */
+export function splitConsumptionModes(managedPaths, scaffoldSourcePaths) {
+    const prefixes = scaffoldSourcePaths ?? [];
+    const materialise = [];
+    const cacheOnly = [];
+    for (const p of managedPaths) {
+        const isScaffoldSource = prefixes.some((prefix) => p.startsWith(prefix));
+        const isRegistry = p === REGISTRY_FILE || p.endsWith(`/${REGISTRY_FILE}`);
+        const isVocab = p === VOCAB_FILE || p.endsWith(`/${VOCAB_FILE}`);
+        if (isScaffoldSource || isRegistry || isVocab) {
+            cacheOnly.push(p);
+        }
+        else {
+            materialise.push(p);
+        }
+    }
+    return { materialise, cacheOnly };
+}
+/**
+ * Extract a bundle's payload into the cache, replacing any previously
+ * cached version of the same bundle name (one cached version per
+ * bundle — the lock pins exactly one).
+ */
+export async function cacheBundle(input) {
+    const cacheRoot = join(input.targetRepo, BUNDLE_CACHE_REL);
+    await prunePreviousVersions(cacheRoot, input.bundleName);
+    const dest = join(cacheRoot, `${input.bundleName}@${input.bundleVersion}`);
+    for (const p of input.managedPaths) {
+        const src = join(input.payloadDir, p);
+        const dst = join(dest, p);
+        await mkdir(dirname(dst), { recursive: true });
+        await copyFile(src, dst);
+    }
+    return dest;
+}
+async function prunePreviousVersions(cacheRoot, bundleName) {
+    let entries;
+    try {
+        entries = await readdir(cacheRoot, { withFileTypes: true });
+    }
+    catch {
+        return; // no cache yet
+    }
+    for (const e of entries) {
+        if (e.isDirectory() && e.name.startsWith(`${bundleName}@`)) {
+            await rm(join(cacheRoot, e.name), { recursive: true, force: true });
+        }
+    }
+}
+/**
+ * Ensure the consumer's .gitignore excludes the bundle cache. Appends
+ * a marked line when absent; leaves adopter content untouched otherwise.
+ */
+export async function ensureCacheGitignored(targetRepo) {
+    const giPath = join(targetRepo, ".gitignore");
+    const line = `${BUNDLE_CACHE_REL}/`;
+    let existing = "";
+    try {
+        existing = await readFile(giPath, "utf8");
+    }
+    catch {
+        // no .gitignore yet — create one below
+    }
+    if (existing.split("\n").some((l) => l.trim() === line || l.trim() === BUNDLE_CACHE_REL)) {
+        return false;
+    }
+    const prefixNewline = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    await appendFile(giPath, `${prefixNewline}# sdd-cli bundle cache (ADR 0176) — extracted bundle payloads, not source\n${line}\n`);
+    return true;
+}
+//# sourceMappingURL=bundle-cache.js.map

package/dist/lib/sync/bundle-source.js

@@ -0,0 +1,61 @@
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+function isUrl(s) {
+    return /^https?:\/\//i.test(s);
+}
+async function sha256File(path) {
+    const buf = await readFile(path);
+    return createHash("sha256").update(buf).digest("hex");
+}
+/** Verify a tarball's sha256 against a pin; throw on mismatch. */
+export async function verifySha256(localPath, expected) {
+    const actual = await sha256File(localPath);
+    if (actual.toLowerCase() !== expected.toLowerCase()) {
+        throw new Error(`bundle_sha256 mismatch for ${basename(localPath)}: ` +
+            `expected ${expected}, got ${actual}`);
+    }
+}
+/**
+ * Fetch a remote bundle to a temp file. Uses the global `fetch` (Node 18+).
+ * Exported for tests that stub the fetcher.
+ */
+export async function fetchToTemp(url, fetchImpl = fetch) {
+    const res = await fetchImpl(url);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch bundle ${url}: HTTP ${res.status}`);
+    }
+    const buf = Buffer.from(await res.arrayBuffer());
+    const dir = await mkdtemp(join(tmpdir(), "sdd-cli-bundle-src-"));
+    const dest = join(dir, basename(new URL(url).pathname) || "bundle.tar.gz");
+    await writeFile(dest, buf);
+    return dest;
+}
+/**
+ * Materialise a config bundle entry to a verified local tarball path.
+ * Callers MUST invoke the returned `cleanup` after the sync completes.
+ */
+export async function materialiseBundle(entry, fetchImpl = fetch) {
+    if (isUrl(entry.source)) {
+        const localPath = await fetchToTemp(entry.source, fetchImpl);
+        const cleanup = async () => {
+            await rm(localPath, { force: true });
+            await rm(join(localPath, ".."), { recursive: true, force: true });
+        };
+        try {
+            if (entry.sha256)
+                await verifySha256(localPath, entry.sha256);
+        }
+        catch (err) {
+            await cleanup();
+            throw err;
+        }
+        return { localPath, cleanup };
+    }
+    // Local source: verify in place, no temp resources to release.
+    if (entry.sha256)
+        await verifySha256(entry.source, entry.sha256);
+    return { localPath: entry.source, cleanup: async () => { } };
+}
+//# sourceMappingURL=bundle-source.js.map

package/dist/lib/sync/config.js

@@ -0,0 +1,72 @@
+import { readFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+function isUrl(s) {
+    return /^https?:\/\//i.test(s);
+}
+export async function loadSyncConfig(configPath) {
+    const absPath = isAbsolute(configPath) ? configPath : resolve(configPath);
+    let raw;
+    try {
+        raw = await readFile(absPath, "utf8");
+    }
+    catch (err) {
+        throw new Error(`Cannot read sync config ${absPath}: ${err.message}`);
+    }
+    const parsed = parseYaml(raw);
+    if (parsed === null || typeof parsed !== "object") {
+        throw new Error(`Sync config ${absPath} is not a YAML object`);
+    }
+    const version = typeof parsed.version === "string" ? parsed.version : undefined;
+    if (!version) {
+        throw new Error(`Sync config ${absPath} missing required field: version`);
+    }
+    if (!Array.isArray(parsed.bundles)) {
+        throw new Error(`Sync config ${absPath} field "bundles" must be a list`);
+    }
+    if (parsed.bundles.length === 0) {
+        throw new Error(`Sync config ${absPath} field "bundles" must not be empty`);
+    }
+    const configDir = dirname(absPath);
+    const bundleSource = typeof parsed.bundle_source === "string" ? parsed.bundle_source : undefined;
+    // Pre-resolve the base for name/version resolution: a URL stays as-is;
+    // a local dir is resolved relative to the config file.
+    const resolvedBase = bundleSource === undefined
+        ? undefined
+        : isUrl(bundleSource) || isAbsolute(bundleSource)
+            ? bundleSource
+            : resolve(configDir, bundleSource);
+    const bundles = [];
+    for (const [i, entry] of parsed.bundles.entries()) {
+        const rawBundle = entry;
+        const src = typeof rawBundle.source === "string" ? rawBundle.source : undefined;
+        const name = typeof rawBundle.name === "string" ? rawBundle.name : undefined;
+        const ver = typeof rawBundle.version === "string" ? rawBundle.version : undefined;
+        const sha256 = typeof rawBundle.sha256 === "string" ? rawBundle.sha256 : undefined;
+        let source;
+        if (src) {
+            // Explicit source: a URL stays as-is; a path is resolved against the
+            // config dir (absolute paths pass through).
+            source = isUrl(src) || isAbsolute(src) ? src : resolve(configDir, src);
+        }
+        else if (name && ver) {
+            if (resolvedBase === undefined) {
+                throw new Error(`Sync config ${absPath} bundles[${i}] uses name+version but no ` +
+                    `top-level "bundle_source" base is set to resolve it against.`);
+            }
+            const rel = `${name}/${name}-${ver}.tar.gz`;
+            source = isUrl(resolvedBase)
+                ? `${resolvedBase.replace(/\/$/, "")}/${rel}`
+                : resolve(resolvedBase, name, `${name}-${ver}.tar.gz`);
+        }
+        else {
+            throw new Error(`Sync config ${absPath} bundles[${i}] missing required field: source ` +
+                `(or a name+version pair resolved against bundle_source)`);
+        }
+        bundles.push(sha256 === undefined ? { source } : { source, sha256 });
+    }
+    return bundleSource === undefined
+        ? { version, bundles }
+        : { version, bundleSource, bundles };
+}
+//# sourceMappingURL=config.js.map

package/dist/lib/sync/copilot-hooks-merge.js

@@ -0,0 +1,108 @@
+/**
+ * `.github/hooks/*.json` merge pass during `sdd-cli sync` when the
+ * adopter opted into `--agent-harness github-copilot-cli`.
+ *
+ * Method-managed event entries are sentinel-tagged via their
+ * `command.bash` / `command.powershell` strings. Adopter-added events
+ * in the same `events[]` array survive sync. Drift inside a method-
+ * managed event refuses without `--allow-overwrite`, symmetric to the
+ * Claude Code settings-merge path.
+ */
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { buildMethodManagedCopilotHooks, detectCopilotHookDrift, upsertCopilotHookFile, } from "../hooks-seed/copilot.js";
+export async function syncMethodManagedCopilotHooks(opts) {
+    const surface = buildMethodManagedCopilotHooks();
+    const entries = Object.entries(surface);
+    // First pass: detect drift across all files. If any drifted file
+    // would be refused (no --allow-overwrite), we refuse the whole
+    // merge without writing — same all-or-nothing posture as the
+    // Claude Code settings merge.
+    const reads = [];
+    for (const [portableClass, { filePath, events }] of entries) {
+        const absPath = join(opts.targetRepo, filePath);
+        const existing = await readHookFile(absPath);
+        const drifted = detectCopilotHookDrift(existing, events);
+        reads.push({
+            portableClass,
+            relPath: filePath,
+            absPath,
+            existing,
+            owned: events,
+            drifted,
+        });
+    }
+    const driftedFiles = reads.filter((r) => r.drifted).map((r) => r.relPath);
+    if (driftedFiles.length > 0 && !opts.allowOverwrite) {
+        return {
+            files: reads.map((r) => ({
+                relPath: r.relPath,
+                portableClass: r.portableClass,
+                drifted: r.drifted,
+                wrote: false,
+            })),
+            driftedRefused: driftedFiles,
+            refused: true,
+        };
+    }
+    if (opts.checkOnly) {
+        return {
+            files: reads.map((r) => ({
+                relPath: r.relPath,
+                portableClass: r.portableClass,
+                drifted: r.drifted,
+                wrote: false,
+            })),
+            driftedRefused: [],
+            refused: false,
+        };
+    }
+    // Second pass: upsert + write.
+    const fileResults = [];
+    for (const r of reads) {
+        const merge = upsertCopilotHookFile(r.existing, r.owned);
+        let wrote = false;
+        if (merge.changed || r.existing === null) {
+            await mkdir(dirname(r.absPath), { recursive: true });
+            await writeFile(r.absPath, JSON.stringify(merge.file, null, 2) + "\n", "utf8");
+            wrote = true;
+        }
+        fileResults.push({
+            relPath: r.relPath,
+            portableClass: r.portableClass,
+            drifted: r.drifted,
+            wrote,
+        });
+    }
+    return { files: fileResults, driftedRefused: [], refused: false };
+}
+async function readHookFile(absPath) {
+    if (!(await fileExists(absPath)))
+        return null;
+    const raw = await readFile(absPath, "utf8");
+    if (raw.trim().length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const obj = parsed;
+            if (Array.isArray(obj["events"])) {
+                return obj;
+            }
+        }
+    }
+    catch {
+        /* fall through — treat malformed as empty so the next write reseats it */
+    }
+    return null;
+}
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=copilot-hooks-merge.js.map

package/dist/lib/sync/diff.js

@@ -0,0 +1,251 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+export const PROTECTED_PREFIXES = ["content/"];
+/** True when every conflict is provably untouched since the last sync. */
+export function allPristine(c) {
+    return (c.pristine.length > 0 &&
+        c.edited.length === 0 &&
+        c.unclassifiable.length === 0);
+}
+/**
+ * Classify each conflicting path against the digests the previous sync recorded.
+ *
+ * Compares the file ON DISK to the digest of what was last APPLIED — not to the
+ * incoming payload, which `findConflicts` has already established differs. A
+ * match therefore means "untouched since the last sync", which is precisely the
+ * question `--allow-overwrite` should have been asking.
+ */
+export async function classifyConflicts(conflicts, targetRepo, priorDigests) {
+    const pristine = [];
+    const edited = [];
+    const unclassifiable = [];
+    for (const p of conflicts) {
+        const recorded = priorDigests?.[p];
+        if (!recorded) {
+            unclassifiable.push(p);
+            continue;
+        }
+        let actual;
+        try {
+            actual = sha256Buffer(await readFile(join(targetRepo, p)));
+        }
+        catch (err) {
+            // Unreadable is not "pristine". Anything we cannot hash is undecidable.
+            if (err.code === "ENOENT")
+                continue;
+            unclassifiable.push(p);
+            continue;
+        }
+        if (actual === recorded)
+            pristine.push(p);
+        else
+            edited.push(p);
+    }
+    return { pristine, edited, unclassifiable };
+}
+/** sha256 of each path's content under `root`, keyed by path — what a sync records. */
+export async function digestManagedPaths(paths, root) {
+    const digests = {};
+    for (const p of paths) {
+        try {
+            digests[p] = sha256Buffer(await readFile(join(root, p)));
+        }
+        catch (err) {
+            // A path with no readable file records no digest, rather than a wrong one.
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+    }
+    return digests;
+}
+function sha256Buffer(buf) {
+    return createHash("sha256").update(buf).digest("hex");
+}
+export function findProtectedPaths(paths) {
+    return paths.filter((p) => PROTECTED_PREFIXES.some((prefix) => p.startsWith(prefix)));
+}
+export async function findMissingPayloadFiles(incomingPaths, payloadDir) {
+    const missing = [];
+    for (const p of incomingPaths) {
+        try {
+            await readFile(join(payloadDir, p));
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                missing.push(p);
+            else
+                throw err;
+        }
+    }
+    return missing;
+}
+export async function findConflicts(incomingPaths, payloadDir, targetRepo) {
+    const conflicts = [];
+    for (const p of incomingPaths) {
+        const targetPath = join(targetRepo, p);
+        let targetContent;
+        try {
+            targetContent = await readFile(targetPath);
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            throw err;
+        }
+        const bundleContent = await readFile(join(payloadDir, p));
+        if (!targetContent.equals(bundleContent)) {
+            conflicts.push(p);
+        }
+    }
+    return conflicts;
+}
+/**
+ * Paths this CLI GENERATES or MERGES rather than materialising from a payload,
+ * and which must therefore never be removed by omission from a payload.
+ *
+ * WHY THIS EXISTS — measured, not anticipated
+ *   `.claude/settings.json` used to be payload-shipped and is now merge-managed.
+ *   A repo whose last sync recorded it in `managed_paths` therefore hits this:
+ *   the path is absent from the incoming `MANAGED_PATHS.txt`, so `computeRemovals`
+ *   schedules it for deletion — and `removeManagedFiles` runs BEFORE
+ *   `syncMethodManagedSettings`, whose `readSettings` returns `{}` for a file that
+ *   is not there. So the merge's documented contract ("adopter-added entries and
+ *   other top-level keys are preserved") is void on exactly the transition where
+ *   ownership moved, and the adopter's `permissions`, `env` and their own
+ *   `mcpServers` entries are lost silently, with exit 0 and a "Refreshed" log line
+ *   that says "added" because it was seeding from empty.
+ *
+ *   That was measured on a real repo copy in a 30-repo estate, one apply short of
+ *   shipping. 30 of 65 repos were scheduled for the deletion.
+ *
+ * THE INVARIANT — a merge-managed path is never payload-managed, so its absence
+ *   from a payload carries NO information about whether it should exist. Only the
+ *   component that owns it may decide that. Enforced here rather than at the call
+ *   site so a second caller cannot reintroduce the defect: this is a property of
+ *   the paths, not of any one sync flow.
+ *
+ * ⚠ Ownership migrations (payload → generated) are the general hazard. Any future
+ *   path that moves this way must be added here IN THE SAME CHANGE, or the first
+ *   adopter to sync across the migration silently loses whatever they had.
+ */
+export const GENERATED_NEVER_REMOVE = [
+    // merge-managed: settings-merge.ts (adopter keys preserved by contract)
+    ".claude/settings.json",
+    // rendered: init/ci-workflow.ts
+    ".github/workflows/method-validation.yml",
+    // merge-managed: briefing-merge.ts (wrapper keeps adopter content below markers)
+    "CLAUDE.md",
+    "AGENTS.md",
+    "agent-instructions.md",
+];
+/** `.github/hooks/<event>.json` — rendered per-event by hooks-seed/copilot.ts. */
+const GENERATED_PREFIXES = [".github/hooks/"];
+/** True when this path's existence is owned by a generator, not by a payload. */
+export function isGeneratedPath(p) {
+    return (GENERATED_NEVER_REMOVE.includes(p) ||
+        GENERATED_PREFIXES.some((prefix) => p.startsWith(prefix)));
+}
+export function computeRemovals(prevPaths, incomingPaths, options) {
+    if (options.noDelete)
+        return [];
+    const incoming = new Set(incomingPaths);
+    return prevPaths.filter((p) => !incoming.has(p) && !isGeneratedPath(p));
+}
+/**
+ * SHADOW COLLISIONS — an incoming managed file whose basename already exists at
+ * a SHALLOWER, unmanaged path in the adopter's repo (ledger §3ap).
+ *
+ * When the distributed surface MOVES a file, copies previously delivered at the
+ * old location are stranded as unmanaged files. They keep resolving, so nothing
+ * breaks loudly, and they go stale silently as their managed twins evolve. One
+ * estate carried six such shadows, every one stale — including a rubric its own
+ * scoring tooling was still reading, so a repaired anchor shipped and was
+ * simultaneously unreachable through the tools meant to apply it.
+ *
+ * The quiet failure is the one that needs machinery: a rename that breaks its
+ * citations announces itself, and this one does not. Flagging the collision as
+ * it is created beats a per-estate census finding it months later.
+ *
+ * ⚠ BASENAME EQUALITY IS NECESSARY AND NOWHERE NEAR SUFFICIENT — learned on
+ * this detector's FIRST LIVE RUN, from the estate that reported the class.
+ * It fired on a repo's own top-level `README.md` against the managed
+ * `docs/method/README.md`: 24KB "# {Adopter Product}" versus 10KB "# `docs/method/`",
+ * two lines in common, two documents that merely share a filename. That is not
+ * a stranded copy and never could be, and it would have fired in 24 of 40 repos.
+ *
+ * The defect was building the detector from the CLASS'S SYMPTOM instead of its
+ * cause. In every real instance the shadow was a FORMER COPY of the managed
+ * file — same basename AND same subject — left behind by a move. So common
+ * ancestry is the discriminator, and `looksRelated` supplies it: a candidate
+ * must resemble the managed file's content, not merely echo its name.
+ *
+ * `exists` and `read` are injected so this is testable without a filesystem,
+ * and so the rule itself can be read without reading a sync flow.
+ */
+export function detectShadowCollisions(managedPaths, exists, read) {
+    const managedSet = new Set(managedPaths);
+    const seenBasename = new Map();
+    for (const rel of managedPaths) {
+        const base = rel.slice(rel.lastIndexOf("/") + 1);
+        if (!seenBasename.has(base))
+            seenBasename.set(base, rel);
+    }
+    const shadows = [];
+    for (const [base, managedRel] of seenBasename) {
+        const parts = managedRel.split("/");
+        // Walk the managed path's own ancestors, shallowest first: a shadow is the
+        // same basename ABOVE the file that now owns the name. A deeper twin is a
+        // different artefact, not a stranded copy.
+        for (let cut = 0; cut < parts.length - 1; cut++) {
+            const candidate = [...parts.slice(0, cut), base].join("/");
+            if (candidate === managedRel)
+                continue;
+            // A path the incoming bundle also manages is not a shadow — it is
+            // delivered content, and sync owns both.
+            if (managedSet.has(candidate))
+                continue;
+            if (exists(candidate) && looksRelated(candidate, managedRel, read)) {
+                shadows.push({ shadow: candidate, managed: managedRel });
+                break;
+            }
+        }
+    }
+    return shadows;
+}
+/**
+ * Do these two files look like copies of one another?
+ *
+ * Deliberately crude and deliberately CONSERVATIVE: a stranded copy diverges by
+ * drift, so it keeps most of its lines; two unrelated files sharing a name share
+ * almost none. Without a reader (no filesystem access) it returns FALSE — the
+ * detector stays silent rather than guessing, because a false shadow costs a
+ * reader's attention on every sync while a missed one is found by the standing
+ * per-estate census.
+ */
+function looksRelated(shadowPath, managedPath, read) {
+    if (!read)
+        return false;
+    const a = read(shadowPath);
+    const b = read(managedPath);
+    if (a === null || b === null)
+        return false;
+    const lines = (t) => new Set(t
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 20));
+    const A = lines(a);
+    const B = lines(b);
+    if (A.size === 0 || B.size === 0)
+        return false;
+    let shared = 0;
+    for (const l of A)
+        if (B.has(l))
+            shared++;
+    // Share of the SMALLER file's substantive lines. A stale copy of a file that
+    // has since grown is still a copy, so the smaller side is the right
+    // denominator — using the larger one would miss exactly the drifted shadows
+    // this exists to catch.
+    return shared / Math.min(A.size, B.size) >= 0.3;
+}
+//# sourceMappingURL=diff.js.map