@intentius/chant 0.79.0 → 0.81.0

package/dist/workspace/init.d.ts

@@ -0,0 +1,96 @@
+/**
+ * `chant workspace init [dir] [--name <name>] [--yes] [--verbose]` (#2534):
+ * propose a declaration from the projects already in a repository, print it
+ * with the directories that would leave the root project, and write it only
+ * once the user confirms (#2525 rule 1, ws-012).
+ *
+ * The proposal is a starting point for review, never written silently:
+ *
+ * - each outermost chant project (a chant.config.ts or .json) becomes a
+ *   `chant` member, and the root's own config makes a root member `"."`;
+ * - each nested declaration becomes a `workspace` member;
+ * - each other npm package, from the npm workspaces or any other
+ *   package.json, becomes an `other` member with a `because`;
+ * - projects under an `examples`, `test` or `fixtures`-style directory become
+ *   example groups (ws-051), one glob per tree where the tree is mostly
+ *   projects, explicit paths where it isn't;
+ * - each `chant` member gets an `ownership.stack` of its own (#2538, ws-037):
+ *   a stack no other member uses is kept, and a shared or missing one gets a
+ *   proposed name. The stack stays in the member's chant.config, since
+ *   markers carry no member key, so this is printed for the user to apply and
+ *   never written.
+ *
+ * Nothing here runs project code: it reads file names and package.json files.
+ */
+import type { CommandContext } from "../cli/registry.js";
+import { type WorkspaceTree } from "./tree.js";
+export interface ProposedEntry {
+    name: string;
+    dir?: string;
+    kind: string;
+    because?: string;
+    glob?: string | string[];
+}
+/** The ownership stack proposed for one `chant` member (#2538). */
+export interface StackProposal {
+    member: string;
+    dir: string;
+    /** The config file the stack is set in, relative to the root. */
+    config: string;
+    /**
+     * The member's `ownership.stack` as written, when it is a plain string in
+     * the config. Null when it sets none, or computes it.
+     */
+    current: string | null;
+    /** The stack the member should use; equal to `current` when that is kept. */
+    proposed: string;
+    /** Why the stack changes: `missing`, `shared` with another member, or `computed`. Absent when kept. */
+    reason?: "missing" | "shared" | "computed";
+}
+export interface Proposal {
+    root: string;
+    /** The declaration as it would be written. */
+    declaration: {
+        name: string;
+        schema: 1;
+        members: ProposedEntry[];
+    };
+    /** Directories leaving the root project, with the .ts source files each holds. */
+    leaving: {
+        dir: string;
+        owner: string;
+        files: string[];
+    }[];
+    /** One ownership stack per `chant` member, all distinct (ws-037). */
+    stacks: StackProposal[];
+}
+export declare function sanitizeName(raw: string): string;
+/**
+ * A member's `ownership.stack` read from its config's text, without running
+ * it: `{ stack }` when it is a plain string, `{ computed: true }` when the
+ * config has an ownership block whose stack is not one, and `{}` when it sets
+ * none.
+ */
+export declare function readOwnershipStack(tree: WorkspaceTree, dir: string): {
+    config: string;
+    stack?: string;
+    computed?: boolean;
+} | undefined;
+/**
+ * One distinct stack per `chant` member, in declaration order, so the root
+ * member and then the outermost directories keep theirs first. A stack only
+ * one member uses is kept. A shared stack stays with the first member using
+ * it, and the others get their member name. A member with no stack, or one
+ * the config computes, gets its member name too. A proposed name never takes
+ * a stack another member already sets.
+ */
+export declare function proposeStacks(tree: WorkspaceTree, members: {
+    name: string;
+    dir: string;
+    kind: string;
+}[]): StackProposal[];
+export declare function proposeWorkspace(root: string, options?: {
+    name?: string;
+}): Proposal;
+export declare function runWorkspaceInit(ctx: CommandContext): Promise<number>;
+//# sourceMappingURL=init.d.ts.map

package/dist/workspace/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/workspace/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAYtD,OAAO,EAAmC,KAAK,aAAa,EAAE,MAAM,QAAQ,CAAC;AAsB7E,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1B;AAED,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,CAAC;IACjB,uGAAuG;IACvG,MAAM,CAAC,EAAE,SAAS,GAAG,QAAQ,GAAG,UAAU,CAAC;CAC5C;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,CAAC,CAAC;QAAC,OAAO,EAAE,aAAa,EAAE,CAAA;KAAE,CAAC;IACnE,kFAAkF;IAClF,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IAC3D,qEAAqE;IACrE,MAAM,EAAE,aAAa,EAAE,CAAC;CACzB;AAiDD,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQhD;AAuDD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,CAkBvI;AASD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,aAAa,EAAE,CAuB1H;AAoFD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,QAAQ,CAsFxF;AA4ED,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAkE3E"}

package/dist/workspace/jsonc.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A small JSON reader that keeps positions, for the workspace declaration
+ * (#2534). `chant.workspace.json` is strict JSON; `chant.workspace.jsonc` also
+ * allows `//` and `/* *\/` comments and trailing commas.
+ *
+ * `JSON.parse` would do for the strict file, but it reports neither a line
+ * nor a column in every runtime, it accepts duplicate keys by keeping the last
+ * one, and it can't say where a value sits once parsed. A schema error has to
+ * name the line it comes from, so this reader records where each value and
+ * each key starts, by JSON Pointer.
+ */
+export interface TextLocation {
+    /** 1-based. */
+    line: number;
+    /** 1-based, counted in UTF-16 code units. */
+    column: number;
+}
+export interface JsonParseOptions {
+    /** Allow comments and trailing commas (`.jsonc`). */
+    jsonc: boolean;
+}
+export type JsonParseResult = {
+    ok: true;
+    value: unknown;
+    /**
+     * Where the value at `pointer` starts, or where its key starts when
+     * `key` is set. Falls back to the nearest ancestor that has a position.
+     */
+    locate(pointer: string, key?: boolean): TextLocation;
+} | {
+    ok: false;
+    message: string;
+    location: TextLocation;
+};
+/** Escape one reference token for a JSON Pointer (RFC 6901). */
+export declare function pointerToken(token: string | number): string;
+export declare function parseJsonText(text: string, options: JsonParseOptions): JsonParseResult;
+//# sourceMappingURL=jsonc.d.ts.map

package/dist/workspace/jsonc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonc.d.ts","sourceRoot":"","sources":["../../src/workspace/jsonc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,YAAY;IAC3B,eAAe;IACf,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,qDAAqD;IACrD,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,MAAM,eAAe,GACvB;IACE,EAAE,EAAE,IAAI,CAAC;IACT,KAAK,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,YAAY,CAAC;CACtD,GACD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAA;CAAE,CAAC;AAW3D,gEAAgE;AAChE,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,eAAe,CAoLtF"}

package/dist/workspace/kinds.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Member kinds (#2524 D3, #2535; ws-031 for the plugin shape, ws-051 for
+ * `examples`).
+ *
+ * A kind is data: a name, a precedence and a probe that says what its
+ * directory holds. Probes run no code (K3). Four kinds are built in: the
+ * member kinds `chant`, `workspace` and `other`, and the group kind
+ * `examples`. Every other kind comes from a pinned package, which publishes
+ * its kinds as a JSON file at a `./workspace-kinds` subpath, the way a
+ * lexicon publishes a slim `./detect` entry (#426). chant finds that file
+ * through the package's `package.json` and reads it with the file system, so
+ * reading kinds never imports the package and never loads a lexicon.
+ *
+ * The vocabulary is closed: a member whose kind no registry knows fails
+ * closed, and the message lists the known kinds. When the probes of several
+ * kinds claim one directory, the highest precedence decides, and a tie
+ * fails ({@link resolveKind}).
+ */
+import type { WorkspaceTree } from "./tree.js";
+export declare const KINDS_SCHEMA_ID: string;
+/** The subpath a package publishes its kinds at. */
+export declare const KINDS_SUBPATH = "./workspace-kinds";
+/**
+ * The probe a package's kind carries (#2535, #2545). It passes when any of
+ * its clauses does. A name in either clause may use `*`, which matches any
+ * run of characters in one file name, so `*.tf` is every Terraform file.
+ */
+export interface FileProbe {
+    /** A file matching one of these names sits directly in the directory. */
+    anyFile?: string[];
+    /**
+     * A file directly in the directory whose name matches one of `in` has a
+     * line that opens an unlabelled block named in `blocks`: leading space,
+     * the name, optional space, then `{`. This is how a choudoufu root's
+     * `live {` block is found without parsing HCL (#2545).
+     */
+    anyBlock?: {
+        in: string[];
+        blocks: string[];
+    };
+}
+/** What a kind's probe checks in a directory. */
+export type KindProbe = 
+/** Files, or blocks in files, sit directly in the directory. */
+FileProbe
+/** The directory exists; nothing else is checked (`other`). */
+ | {
+    directory: true;
+}
+/** The directory holds a chant project, as {@link holdsChantProject} says (`examples`). */
+ | {
+    chantProject: true;
+};
+/**
+ * Which outputs a member of a kind exposes as link targets (#2524 D6,
+ * #2539). A member link may only name an output its producer exposes.
+ */
+export type KindOutputs = 
+/** The chant project's own outputs, read from its source without running it (`chant`). */
+{
+    from: "chant-source";
+}
+/** None: the member is opaque to links (`workspace`, and the group kind `examples`). */
+ | {
+    from: "none";
+}
+/** The names listed here, plus any the member entry lists in `outputs` (`other`, and kinds from a package). */
+ | {
+    from: "declared";
+    names: string[];
+};
+export interface MemberKind {
+    name: string;
+    /** One line for listings and error messages. */
+    description: string;
+    probe: KindProbe;
+    /**
+     * When several kinds' probes claim one directory, the highest precedence
+     * decides; equal highest precedences are a tie, and a tie fails. `other`
+     * and `examples` are never claimants.
+     */
+    precedence: number;
+    /** A member kind, or the kind of an example group (ws-051). */
+    shape: "member" | "group";
+    /** The outputs a member of this kind exposes as link targets (#2539). */
+    outputs: KindOutputs;
+    /** Where the kind comes from: `builtin`, or the package that supplies it. */
+    source: string;
+}
+export interface KindRegistry {
+    get(name: string): MemberKind | undefined;
+    /** Every member kind's name, sorted, for "unknown kind" messages. */
+    names(): string[];
+    /** Every kind, group kinds included, in registration order. */
+    all(): MemberKind[];
+}
+/** The group kind (ws-051). An entry of this kind is a group, not a member. */
+export declare const EXAMPLES_KIND = "examples";
+export declare const BUILTIN_KINDS: readonly MemberKind[];
+export declare const BUILTIN_KIND_NAMES: readonly string[];
+/** A registry holding the built-in kinds and then `extra`, which must not repeat a name. */
+export declare function createKindRegistry(extra?: readonly MemberKind[]): KindRegistry;
+export declare function builtinKindRegistry(): KindRegistry;
+/** Whether `dir` (tree-relative) passes `kind`'s probe. The directory is known to exist. */
+export declare function probeKind(kind: MemberKind, tree: WorkspaceTree, dir: string): boolean;
+export interface KindResolution {
+    /** Every member kind whose probe claims the directory, highest precedence first. */
+    claims: MemberKind[];
+    /** The kind the precedence order picks, when exactly one has the highest precedence. */
+    winner: MemberKind | undefined;
+    /** The kinds sharing the highest precedence, when there are two or more. A tie fails. */
+    tie: MemberKind[];
+}
+/**
+ * Which kind's probe claims `dir` (tree-relative). Only member kinds whose
+ * probe looks at the directory take part: `other` claims every directory and
+ * so claims none, and `examples` is a group kind. `exclude` leaves kinds out,
+ * such as `workspace` for the root member, whose directory holds the
+ * workspace's own declaration.
+ */
+export declare function resolveKind(kinds: KindRegistry, tree: WorkspaceTree, dir: string, exclude?: readonly string[]): KindResolution;
+/**
+ * Whether directory `dir` holds a chant project, for an example group's
+ * matches (ws-051). That is true when a chant config sits in it or up to four
+ * levels below it (many examples keep theirs in `src/`), or when its own
+ * `package.json` depends on `@intentius/chant` or a chant lexicon, which is
+ * how an example with no config names its lexicon.
+ */
+export declare function holdsChantProject(tree: WorkspaceTree, dir: string): boolean;
+export interface KindData {
+    kinds: MemberKind[];
+    /** Why the data can't be used, one line each. Empty when it can. */
+    problems: string[];
+}
+/**
+ * Check the text of a kinds file against `workspace-kinds.schema.json` and
+ * the rules the schema can't say: no built-in name, and no name twice.
+ * `source` names the package in the kinds and in the messages.
+ */
+export declare function parseKindData(text: string, source: string): KindData;
+export interface PackageKinds extends KindData {
+    /** The kinds file, absolute, or undefined when the package publishes none. */
+    file: string | undefined;
+}
+/**
+ * Where a package's `exports` send `./workspace-kinds`, or undefined when
+ * the package doesn't export that subpath. Only the literal key counts: a
+ * `./*` pattern maps the subpath to code, which chant never runs for kinds.
+ */
+export declare function kindsExportTarget(pkg: Record<string, unknown>): string | undefined | {
+    problem: string;
+};
+/** Read the kinds a package directory publishes. Reads files only; imports nothing. */
+export declare function readPackageKinds(packageDir: string, source?: string): PackageKinds;
+/**
+ * The directory of an installed package `name`, found the way Node finds a
+ * bare import: `node_modules/<name>` in `fromDir` and each directory above it.
+ * It looks for the directory, not for an entry point, so it works for a
+ * package whose `exports` don't expose `package.json`.
+ */
+export declare function findInstalledPackage(name: string, fromDir: string): string | undefined;
+export interface PinLike {
+    package: string | null;
+    version: string | null;
+    path: string | null;
+}
+export interface KindLoadProblem {
+    /** The pin's index in the declaration's `pins`. */
+    pin: number;
+    message: string;
+}
+export interface LoadedKinds {
+    registry: KindRegistry;
+    problems: KindLoadProblem[];
+}
+/**
+ * Build the registry for a workspace: the built-in kinds plus the kinds
+ * every pin publishes. `workspaceRoot` is the absolute workspace root; a
+ * package pin is looked up from there, and a path pin is relative to it.
+ * An installed version that differs from the pin, a kinds file that doesn't
+ * validate, and a kind name two packages both supply are problems; the kinds
+ * involved are left out, so members of those kinds read as unknown.
+ * Never throws.
+ */
+export declare function loadKindRegistry(pins: readonly PinLike[], workspaceRoot: string): LoadedKinds;
+/**
+ * Whether `file` (absolute, inside `packageDir`) is published, as far as the
+ * package's `files` list says. A package with no `files` list publishes
+ * everything npm doesn't ignore by default.
+ */
+export declare function kindsFileShips(packageDir: string, file: string): boolean;
+//# sourceMappingURL=kinds.d.ts.map

package/dist/workspace/kinds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kinds.d.ts","sourceRoot":"","sources":["../../src/workspace/kinds.ts"],"names":[],"mappings":"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"}

package/dist/workspace/lineage-check.d.ts

@@ -0,0 +1,84 @@
+/**
+ * `chant workspace check [--at <rev>] [--json] [--format stylish|json|sarif] [--generated]`:
+ * the lineage checks (#2550, D9), and the declaration checks (#2535, D16)
+ * when a declaration sits between the current directory and the git root.
+ *
+ * D9 says open manual steps fail `check`. So far, `check` checks the
+ * lineage lock only: the lock must be readable, and no scope may have an open
+ * manual step. It needs no `chant.workspace.json`, the way `chant workspace
+ * lineage` needs none, and a directory without a lock passes with nothing to
+ * check. The declaration checks report `WSP` findings through lint's
+ * reporters (`./checks.ts`), and cover member ledgers (#2538), recorded
+ * pipelines (#2542) and generated files (#2541) as well as the declaration
+ * itself (#2641). `--generated` runs each declared generator too.
+ *
+ * `chant workspace upgrade` runs the same checks in its staging worktree
+ * before it reaches its gate.
+ */
+import type { CommandContext } from "../cli/registry.js";
+import type { DeclarationCheckReport } from "./checks.js";
+/** Closed: a reader may switch on it. */
+export declare const CHECK_CODES: readonly ["lock-invalid", "manual-step-open"];
+export type CheckCode = (typeof CHECK_CODES)[number];
+export interface CheckFinding {
+    code: CheckCode;
+    /** The scope the finding is in, or null for the lock as a whole. */
+    scope: string | null;
+    /** The file, relative to the lock's directory, when the finding is about one. */
+    path?: string;
+    message: string;
+}
+export interface CheckReport {
+    lock: string | null;
+    ok: boolean;
+    findings: CheckFinding[];
+}
+/**
+ * Run the lineage checks over the lock at `root`. Never throws a
+ * {@link LockError}. `lockText` is the lock's text when it comes from
+ * somewhere other than the disk, such as a revision (`--at`), with null
+ * for no lock.
+ */
+export declare function checkLineage(root: string, lockText?: string | null): CheckReport;
+/** A finding's identity, for comparing two reports. */
+export declare function findingKey(f: CheckFinding): string;
+/** The version of the `check` document this chant writes. */
+export declare const CHECK_CONTRACT_VERSION = 1;
+/** `$id` of the JSON Schema for the `--format json` output, shipped beside this file. */
+export declare const CHECK_OUTPUT_SCHEMA_ID = "https://intentius.io/chant/schemas/workspace/check/v1/check.schema.json";
+/** Why `check` could not run at all: only the `--at` codes. A declaration that can't be read is a WSP001 finding instead. */
+export declare const CHECK_ERROR_CODES: readonly ["not-a-git-repository", "revision-unknown"];
+export type CheckErrorCode = (typeof CHECK_ERROR_CODES)[number];
+/** What `check --format json` prints (#2536). `check.schema.json` describes it. */
+export type CheckDocument = (CheckReport & {
+    $schema: string;
+    contract: number;
+    chant: string;
+    at: string | null;
+    /** The declaration's workspace, or null when there is none; `name` is null when it can't be read. */
+    workspace: {
+        name: string | null;
+        root: string;
+    } | null;
+    declaration?: DeclarationCheckReport;
+}) | {
+    $schema: string;
+    contract: number;
+    chant: string;
+    error: {
+        code: CheckErrorCode;
+        message: string;
+        location: null;
+    };
+};
+/**
+ * Run every check from `cwd`, in the working tree or at revision `at`, and
+ * build the document the JSON formats print. Paths in findings are relative
+ * to `cwd`. `runGenerators` is `--generated`; with `at` it does nothing,
+ * since the member facts describe the working tree, not the revision.
+ */
+export declare function runChecks(cwd: string, at?: string, options?: {
+    runGenerators?: boolean;
+}): Promise<CheckDocument>;
+export declare function runWorkspaceCheck(ctx: CommandContext): Promise<number>;
+//# sourceMappingURL=lineage-check.d.ts.map

package/dist/workspace/lineage-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lineage-check.d.ts","sourceRoot":"","sources":["../../src/workspace/lineage-check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAKvD,yCAAyC;AACzC,eAAO,MAAM,WAAW,+CAAgF,CAAC;AACzG,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,CAAC;IAChB,oEAAoE;IACpE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,iFAAiF;IACjF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,WAAW,CAsBhF;AAED,uDAAuD;AACvD,wBAAgB,UAAU,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAElD;AAkCD,6DAA6D;AAC7D,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC,yFAAyF;AACzF,eAAO,MAAM,sBAAsB,4EAA4E,CAAC;AAEhH,6HAA6H;AAC7H,eAAO,MAAM,iBAAiB,uDAAwF,CAAC;AACvH,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhE,mFAAmF;AACnF,MAAM,MAAM,aAAa,GACrB,CAAC,WAAW,GAAG;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,qGAAqG;IACrG,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACxD,WAAW,CAAC,EAAE,sBAAsB,CAAC;CACtC,CAAC,GACF;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAE,IAAI,EAAE,cAAc,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE,CAAA;CAAE,CAAC;AAE3H;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAwD3H;AAED,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA6D5E"}

package/dist/workspace/lineage-cli.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `chant workspace lineage [--json]` and
+ * `chant workspace lineage resolve <path>` (#2540).
+ *
+ * The first shows each scope in `.chant/workspace.lock.json`: where it came
+ * from, which files the project has edited since, and which manual steps are
+ * open. The second closes a manual step once the file has been merged by
+ * hand. Neither needs a `chant.workspace.json`: lineage works for a plain
+ * project (#2525 rule 4).
+ */
+import type { CommandContext } from "../cli/registry.js";
+import { type ManualStep } from "./lineage-lock.js";
+export interface LineageScopeView {
+    scope: string;
+    kind: "template" | "vendor";
+    name?: string;
+    template: string;
+    ref?: string;
+    address: Record<string, unknown> | null;
+    files: number;
+    edited: string[];
+    missing: string[];
+    manualSteps: ManualStep[];
+}
+/** The lock as `--json` prints it: one view per scope, with its state in the tree. */
+export declare function lineageView(root: string): {
+    lock: string;
+    scopes: LineageScopeView[];
+} | null;
+export declare function runWorkspaceLineage(ctx: CommandContext): Promise<number>;
+//# sourceMappingURL=lineage-cli.d.ts.map

package/dist/workspace/lineage-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lineage-cli.d.ts","sourceRoot":"","sources":["../../src/workspace/lineage-cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAA6E,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAI5H,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,gBAAgB,EAAE,CAAA;CAAE,GAAG,IAAI,CAmB7F;AAED,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAmC9E"}

package/dist/workspace/lineage-init.d.ts

@@ -0,0 +1,101 @@
+/**
+ * The lineage lock at init (#2540, ws-047): `chant init --from <repo>@<ref>`
+ * and `chant init --template <name>` both leave `.chant/workspace.lock.json`
+ * with one lineage, scope `"."`, so a project made from a template can be
+ * upgraded later without first running adopt-lineage.
+ *
+ * `--from` fetches with `git`: the one network step, listed in the egress
+ * catalogue (`test/egress-catalogue.ts`). The commit and the tree of the
+ * chosen directory become the content address.
+ *
+ * Plain `chant init` without `--template` writes no lock. That keeps the
+ * output of an existing command unchanged (#2525 rule 2), and this module
+ * never loads for it.
+ */
+export interface TemplateSpec {
+    /** The repository as written. */
+    repo: string;
+    /** What `git fetch` is given: a URL, or an absolute local path. */
+    url: string;
+    ref: string;
+    /** The directory inside the repository to instantiate (`#<member>`). */
+    member?: string;
+    /** Stable identity: `<host>/<path>` for a remote, the path as written for a local repo, plus `#<member>`. */
+    id: string;
+}
+/**
+ * Parse `<repo>@<ref>[#<member>]`. `<repo>` is a git URL, an scp-style
+ * `git@host:path`, a local path, or `owner/name` for a GitHub repository.
+ */
+export declare function parseTemplateSpec(spec: string, cwd?: string): TemplateSpec;
+export interface FetchedTemplate {
+    commit: string;
+    tree: string;
+    /** Files under the chosen directory, relative to it. */
+    files: Map<string, {
+        data: Buffer;
+        executable: boolean;
+    }>;
+    /** Paths that were not copied, with the reason. */
+    skipped: Array<{
+        path: string;
+        reason: string;
+    }>;
+}
+export declare function git(cwd: string, args: string[]): string;
+/**
+ * Read the files of `member` (or the whole tree) at `commit` from a scratch
+ * repository that already holds the commit. Symbolic links, submodules and
+ * the template's own lineage lock are skipped, with the reason.
+ */
+export declare function readTemplateTree(scratch: string, commit: string, member: string | undefined, label: string): {
+    tree: string;
+    files: FetchedTemplate["files"];
+    skipped: FetchedTemplate["skipped"];
+};
+/**
+ * Fetch one commit of the template repository into a scratch repository and
+ * read the files of the chosen directory from it. The template's own lock is
+ * never copied: it describes the template's lineage, not the new project's.
+ */
+export declare function fetchTemplate(spec: TemplateSpec): FetchedTemplate;
+export interface InitFromOptions {
+    from: string;
+    /** Target directory (defaults to cwd). */
+    path?: string;
+    force?: boolean;
+    /** `--param name=value` values, parsed. Checked against the template's `chant.template.json` (#2627). */
+    params?: Record<string, string>;
+}
+export interface InitFromResult {
+    success: boolean;
+    createdFiles: string[];
+    warnings: string[];
+    error?: string;
+    spec?: TemplateSpec;
+    commit?: string;
+    /** The parameter values used, recorded in the lock. */
+    parameters?: Record<string, string>;
+}
+/** `chant init --from <repo>@<ref>[#<member>] [path]`. */
+export declare function initFromCommand(options: InitFromOptions): Promise<InitFromResult>;
+export interface TemplateLockInput {
+    targetDir: string;
+    lexicon: string;
+    template: string;
+    /** Files init wrote, relative to `targetDir`. */
+    createdFiles: string[];
+    chantVersion: string;
+    /** Set when the project's config declares the lexicon by path (#2520): the path, recorded instead of a package. */
+    lexiconModule?: string;
+}
+/**
+ * Record the lineage of a `chant init --template` project. Only files init
+ * actually wrote are listed; a file that already existed was not made from
+ * the template. `.chant/types/` is gitignored and left out (D14).
+ *
+ * Returns the lock's path relative to `targetDir`, or null when the target
+ * already has a lock (init never overwrites a lineage).
+ */
+export declare function writeTemplateLock(input: TemplateLockInput): string | null;
+//# sourceMappingURL=lineage-init.d.ts.map

package/dist/workspace/lineage-init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lineage-init.d.ts","sourceRoot":"","sources":["../../src/workspace/lineage-init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAuBH,MAAM,WAAW,YAAY;IAC3B,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6GAA6G;IAC7G,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,MAAsB,GAAG,YAAY,CAwCzF;AAID,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC1D,mDAAmD;IACnD,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClD;AAED,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAQvD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,KAAK,EAAE,MAAM,GACZ;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IAAC,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,CAAA;CAAE,CAiCxF;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,eAAe,CAgBjE;AAID,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,yGAAyG;IACzG,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC;AAED,0DAA0D;AAC1D,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAiFvF;AAgCD,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,mHAAmH;IACnH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,GAAG,IAAI,CA0BzE"}