@intentius/chant 0.124.12 → 0.124.14

package/dist/components/cli-support.js

@@ -0,0 +1,427 @@
+/**
+ * CLI-facing helpers over component discovery (#560, epic #551) — kept
+ * separate from ../cli/commands/{list,describe}.ts and
+ * ../cli/handlers/graph.ts so those files stay thin dispatchers and the
+ * component-specific report shaping lives alongside the rest of the
+ * component subsystem, the same way ../op/discover.ts's results are shaped
+ * inline by its own CLI callers rather than a `cli` folder inside `op/`.
+ *
+ * Surfaces components in the three places the issue asks for:
+ *  - `chant list --components` — inventory (mirrors `ListEntity`/`listCommand`).
+ *  - `chant describe <name> --components` — one component's full JSON contract
+ *    projection (mirrors `describeCommand`'s effective-config view).
+ *  - `chant graph --components` — dependency order/waves from `dependsOn`
+ *    (mirrors `computeStackGraph`/`runStackGraph`, but reuses
+ *    `resolveComponentGraph` from ../driver.ts since a component's `dependsOn`
+ *    is already a flat name list — no AttrRef-style inference needed).
+ *  - `chant build --components --generate gitlab` — generate mode (#563):
+ *    synthesize CI YAML from the same discovered declarations instead of
+ *    running them, via `generateGitlabPipeline` (../generate-gitlab.ts).
+ *  - `chant run --components <name|all>` — interpret mode (#585): dispatch
+ *    discovered component(s) through the interpret `driver.ts` on the local
+ *    executor, the CLI entrypoint the driver (#556) never had.
+ */
+import { UnknownCanaryError } from "../gated-waves.js";
+import { lexiconModulePath, lexiconNames, importLexiconPackage } from "../lexicon-module.js";
+import { discoverComponents } from "./discover.js";
+import { inferArchetype, projectToJson } from "./component.js";
+import { deployContext, resolveComponentGraph, runInterpretDriver, runComponentDeploy, UnknownDependencyError, DependencyCycleError, DriverRunFailure, } from "./driver.js";
+import { gateName } from "../op/gate-name.js";
+import { isLexiconPlugin } from "../lexicon.js";
+import { dirname, relative } from "node:path";
+import { existsSync, statSync } from "node:fs";
+import { getHeadCommit } from "../lifecycle/git.js";
+import { buildCapabilityRegistry } from "./capability-plugin-loader.js";
+import { applyConfigDefaults } from "./config-defaults.js";
+import { loadChantConfig } from "../config.js";
+/** Discover components under `path` and shape them for `chant list --components`. */
+export async function listComponents(path, sandbox) {
+    const result = await discoverComponents(path, { sandbox });
+    if (result.errors.length > 0) {
+        return { success: false, components: [], errors: result.errors.map((e) => e.message) };
+    }
+    const components = [...result.components.values()]
+        .map(({ component, filePath }) => {
+        const projected = projectToJson(component);
+        return {
+            name: component.name,
+            archetype: projected.archetype,
+            dependsOn: component.dependsOn,
+            hasBuild: component.build !== undefined,
+            phases: component.deploy.map((p) => p.phase),
+            filePath,
+        };
+    })
+        .sort((a, b) => a.name.localeCompare(b.name));
+    return { success: true, components, errors: [] };
+}
+/** Find and project one named component, for `chant describe <name> --components`. */
+export async function describeComponent(path, name, sandbox) {
+    const result = await discoverComponents(path, { sandbox });
+    if (result.errors.length > 0) {
+        return { success: false, component: name, output: result.errors.map((e) => e.message).join("\n") };
+    }
+    const found = result.components.get(name);
+    if (!found) {
+        const known = [...result.components.keys()].sort().join(", ");
+        return {
+            success: false,
+            component: name,
+            output: `No component "${name}" found.\nKnown components: ${known || "(none)"}`,
+        };
+    }
+    const json = projectToJson(found.component);
+    return {
+        success: true,
+        component: name,
+        described: { name, filePath: found.filePath, json },
+        output: "",
+    };
+}
+/** Compute the components' dependency graph under `path`, for `chant graph --components`. */
+export async function computeComponentGraph(path, sandbox, buildParams) {
+    // #1490 — without this the component graph is always the DEFAULT-parameter
+    // graph. `discoverComponents` has honoured `buildParams` since #1108; every
+    // caller simply stopped short of passing them, so `--param backups=omit`
+    // dropped the CronJob from `chant build` and left the component that
+    // describes it in `chant graph --components`. Two commands disagreeing about
+    // what the source says, which is the thing #1064 and #1108 each fixed one
+    // layer of.
+    const result = await discoverComponents(path, { sandbox, buildParams });
+    if (result.errors.length > 0) {
+        return { success: false, order: [], waves: [], edges: [], error: result.errors.map((e) => e.message).join("\n") };
+    }
+    const driverComponents = [...result.components.values()].map(({ component }) => ({
+        name: component.name,
+        dependsOn: component.dependsOn,
+        deploy: component.deploy,
+    }));
+    // component name → its declaring file, relative to `path`, for node deep-links.
+    const files = {};
+    // component name → owned live resource names (#1491), declared or the
+    // contract's identity fallback.
+    const liveNames = {};
+    // component name → declared composite kind(s) (#1492), only for components
+    // that declared them — no identity fallback (see ComponentGraphResult doc).
+    const composites = {};
+    const archetypes = {};
+    const environments = {};
+    for (const [name, discovered] of result.components) {
+        const declaredEnvironments = discovered.component.environments;
+        if (declaredEnvironments && declaredEnvironments.length > 0)
+            environments[name] = declaredEnvironments.map((e) => ({ ...e }));
+        archetypes[name] = discovered.component.archetype ?? inferArchetype(discovered.component);
+        files[name] = relative(path, discovered.filePath);
+        const declared = discovered.component.liveNames;
+        liveNames[name] = declared && declared.length > 0 ? [...declared] : [name];
+        const declaredComposites = discovered.component.composites;
+        if (declaredComposites && declaredComposites.length > 0)
+            composites[name] = [...declaredComposites];
+    }
+    try {
+        const { order, waves } = resolveComponentGraph(driverComponents);
+        const edges = [];
+        for (const c of driverComponents) {
+            for (const dep of c.dependsOn ?? [])
+                edges.push({ from: c.name, to: dep });
+        }
+        return { success: true, order, waves, edges, files, liveNames, composites, archetypes, environments };
+    }
+    catch (err) {
+        if (err instanceof UnknownDependencyError || err instanceof DependencyCycleError) {
+            return { success: false, order: [], waves: [], edges: [], error: err.message };
+        }
+        throw err;
+    }
+}
+/**
+ * Load a lexicon's plugin (`@intentius/chant-lexicon-<name>`) to reach its
+ * `generateComponentPipeline`. Tolerant: returns null when the package can't be
+ * resolved. Mirrors the lexicon-borne loading the capability + upstream-pin
+ * seams use, kept here so `components` doesn't depend on the `cli` plugin loader.
+ */
+async function loadLexiconPlugin(name) {
+    let mod;
+    try {
+        mod = (await importLexiconPackage(lexiconModulePath(name) ?? `@intentius/chant-lexicon-${name}`));
+    }
+    catch {
+        return null;
+    }
+    for (const value of Object.values(mod)) {
+        if (isLexiconPlugin(value))
+            return value;
+    }
+    return null;
+}
+/**
+ * Generate mode (#563): discover every `Component` under `path` and
+ * synthesize a thin CI pipeline for `lexicon` that triggers each component's
+ * own composition in dependency order/waves — the same `resolveComponentGraph`
+ * order `chant graph --components`/the interpret driver use. No deploy logic
+ * is inlined into the generated YAML; a cross-cutting change goes through
+ * `options`, never per component. The CI-specific synthesis is contributed by
+ * the target lexicon's `generateComponentPipeline` (#688); core owns only the
+ * generic discovery + graph.
+ */
+export async function generateComponentsPipeline(path, lexicon, options, sandbox, 
+/**
+ * chant #1108 — this invocation's resolved build-time parameter values
+ * (../cli/handlers/build.ts resolves them, the same sequence `chant build`
+ * runs, BEFORE calling this function), forwarded into discovery so a
+ * `params.<name>` reference inside a discovered `*.component.ts` file
+ * resolves instead of reading `{}`. See `discoverComponents`'s
+ * `buildParams` option (./discover.ts) for the full doc.
+ */
+buildParams) {
+    const plugin = await loadLexiconPlugin(lexicon);
+    if (!plugin?.generateComponentPipeline) {
+        return {
+            success: false,
+            error: `Lexicon "${lexicon}" does not support generate mode (no generateComponentPipeline). GitLab, GitHub, and Forgejo are supported today.`,
+        };
+    }
+    const result = await discoverComponents(path, { sandbox, buildParams });
+    if (result.errors.length > 0) {
+        return { success: false, error: result.errors.map((e) => e.message).join("\n") };
+    }
+    const driverComponents = [...result.components.values()].map(({ component }) => ({
+        name: component.name,
+        dependsOn: component.dependsOn,
+        deploy: component.deploy,
+    }));
+    try {
+        const { yaml, stages, jobs, env } = plugin.generateComponentPipeline(driverComponents, options);
+        return { success: true, yaml, stages, jobs, ...(env ? { env } : {}), buildParams };
+    }
+    catch (err) {
+        if (err instanceof UnknownDependencyError || err instanceof DependencyCycleError || err instanceof UnknownCanaryError) {
+            return { success: false, error: err.message };
+        }
+        throw err;
+    }
+}
+// ── Interpret mode: `chant run --components <name|all>` (#585) ──────────────
+/** Convert a discovered `Component` to the driver's leaner `DriverComponent` shape (name/dependsOn/deploy/rollback — the only fields the driver reads). */
+function toDriverComponent(component) {
+    return {
+        name: component.name,
+        dependsOn: component.dependsOn,
+        deploy: component.deploy,
+        ...(component.rollback ? { rollback: component.rollback } : {}),
+    };
+}
+/**
+ * Find the first `gate` step anywhere in a component's `deploy`/`rollback`
+ * composition (including nested fan-out phases).
+ *
+ * A declaration-time question, not a pre-flight refusal: since #2119 the
+ * driver decides a gate against the ledger when it reaches one, so nothing
+ * needs to know up front that a component has one.
+ *
+ * The name comes back on `gate` whichever key the component spelled it with,
+ * so a caller never has to know about the deprecated `signalName` (#2202).
+ */
+export function findComponentGate(component) {
+    const search = (phases) => {
+        for (const phaseDef of phases ?? []) {
+            for (const entry of phaseDef.steps) {
+                if (entry.kind === "gate") {
+                    return { gate: gateName(entry) };
+                }
+                if (typeof entry.phase === "string" && Array.isArray(entry.steps)) {
+                    const nested = search([entry]);
+                    if (nested)
+                        return nested;
+                }
+            }
+            const fromOnFailure = search(phaseDef.onFailure);
+            if (fromOnFailure)
+                return fromOnFailure;
+        }
+        return undefined;
+    };
+    return search(component.deploy) ?? search(component.rollback);
+}
+/**
+ * Discover every component under `path` and resolve `selector` (`"all"` or a
+ * single component name) to the `DriverComponent`(s) to run, with no gate
+ * check and no dispatch — just discovery + selection, factored out of
+ * `runComponents` so another entrypoint can reuse the exact same selection
+ * semantics without inheriting the run itself.
+ */
+export async function resolveComponentTargets(path, selector, sandbox, 
+/** chant #1108 — this invocation's resolved build-time parameter values, forwarded into `discoverComponents` so a `params.<name>` reference inside a discovered `*.component.ts` file resolves instead of reading `{}`. See `discoverComponents`'s `buildParams` option (./discover.ts). */
+buildParams) {
+    const result = await discoverComponents(path, { sandbox, buildParams });
+    if (result.errors.length > 0) {
+        return { success: false, targets: [], error: result.errors.map((e) => e.message).join("\n") };
+    }
+    const discovered = [...result.components.values()].map(({ component }) => component);
+    const all = discovered.map((component) => toDriverComponent(component));
+    if (selector === "all") {
+        // chant #1522 — a seam-gated component (`enabled: false`, computed from
+        // this run's own params) sits out of "all": the run deploys the estate
+        // the parameters describe, not the units the seams turned off. A disabled
+        // dependency is satisfied vacuously — ordering is dependsOn's only
+        // semantics — so it is also stripped from the survivors' dependsOn,
+        // rather than failing wave resolution as an unknown name.
+        const disabled = new Set(discovered.filter((c) => c.enabled === false).map((c) => c.name));
+        const targets = all
+            .filter((c) => !disabled.has(c.name))
+            .map((c) => (c.dependsOn?.some((d) => disabled.has(d)) ? { ...c, dependsOn: c.dependsOn.filter((d) => !disabled.has(d)) } : c));
+        return { success: true, targets };
+    }
+    const found = all.find((c) => c.name === selector);
+    const disabledByName = discovered.find((c) => c.name === selector && c.enabled === false);
+    if (disabledByName) {
+        // An explicit ask for a unit the parameters excluded is a mistake to
+        // surface, not to skip silently.
+        return {
+            success: false,
+            targets: [],
+            error: `Component "${selector}" is disabled under this run's parameters (enabled: false) — enable the seam it is gated on, or run without naming it.`,
+        };
+    }
+    if (!found) {
+        const known = all.map((c) => c.name).sort().join(", ");
+        return {
+            success: false,
+            targets: [],
+            error: `Component "${selector}" not found.${known ? ` Known components: ${known}` : " No components discovered."}`,
+        };
+    }
+    return { success: true, targets: [found] };
+}
+export async function runComponents(path, selector, options = {}) {
+    const resolved = await resolveComponentTargets(path, selector, options.sandbox, options.buildParams);
+    if (!resolved.success) {
+        return { success: false, selected: [], error: resolved.error };
+    }
+    const targets = resolved.targets;
+    // (#629) Resolve `chant.config.ts`'s `sbom`/`signing`/`vulnPolicy` sections
+    // and fill their defaults into every recognized step (`generate-sbom`,
+    // `sign`/`attest-provenance`, `verify`, `vuln-gate`) that didn't already
+    // specify the value itself, BEFORE dispatching to the driver — the driver
+    // itself stays capability-agnostic and never reads project config (see
+    // ./config-defaults.ts's module doc). Loaded up front here (rather than just
+    // before `applyConfigDefaults`) so the same config drives which capability
+    // plugins the registry loads: a component's cloud leaves (e.g. `cfn-deploy`)
+    // are contributed by the project's active lexicons (`config.lexicons`), not
+    // baked into core — see ./capability-plugin-loader.ts.
+    const { config } = options.config ? { config: options.config } : await loadChantConfig(path);
+    const registry = options.registry ??
+        (await buildCapabilityRegistry({
+            plugins: options.capabilityPlugins ?? config.capabilities,
+            lexicons: lexiconNames(config.lexicons),
+        }));
+    const env = options.env ?? "local";
+    const selected = targets.map((c) => c.name);
+    const resolvedTargets = targets.map((component) => applyConfigDefaults(component, config));
+    // Cross-component/cross-stack outputs to resolve references against. Seeded
+    // from a caller (a downstream CI job passing an upstream job's dumped
+    // outputs via `--seed-outputs`); grows as this run's components complete.
+    const seedOutputs = options.componentOutputs ?? {};
+    const { onProgress } = options;
+    const gates = options.gates;
+    // #3061: the commit this run deploys, for the workloads' vcs.ref.head.revision. The digest comes
+    // from the run's own publish step. Best effort: outside a git checkout nothing is passed.
+    const revision = options.revision !== undefined
+        ? options.revision ?? undefined
+        : await getHeadCommit({ cwd: existsSync(path) && statSync(path).isDirectory() ? path : dirname(path) }).catch(() => undefined);
+    const releaseIdentity = () => (revision ? { revision } : {});
+    try {
+        if (selector === "all") {
+            const run = await runInterpretDriver(resolvedTargets, registry, {
+                env,
+                releaseIdentity,
+                componentOutputs: seedOutputs,
+                onProgress,
+                ...(gates ? { gates } : {}),
+            });
+            return {
+                success: run.status === "ok",
+                run,
+                selected,
+                buildParams: options.buildParams,
+                ...(run.status === "gated" && run.gate
+                    ? {
+                        gated: {
+                            component: run.gatedComponent ?? selected[0],
+                            gate: run.gate,
+                            ...(run.gatePushed !== undefined ? { pushed: run.gatePushed } : {}),
+                            ...(run.gatePushWarning ? { pushWarning: run.gatePushWarning } : {}),
+                            ...(run.gateMismatch ? { mismatch: run.gateMismatch } : {}),
+                        },
+                    }
+                    : {}),
+            };
+        }
+        // Single-component invocation: run just this component, bypassing
+        // whole-graph `dependsOn` resolution (see docstring above). The seeded
+        // outputs stand in for the dependency components that ran in earlier jobs,
+        // so a single-component run still resolves their `stackOutput()`/publish
+        // references. `runComponentDeploy` mutates this map with this component's
+        // own outputs, which `run.componentOutputs` then exposes for `--dump-outputs`.
+        //
+        // There's no `runInterpretDriver` call here to thread progress through
+        // (that's the whole point of the single-component bypass), so the
+        // run-start/wave-start/component-start/…/run-done envelope is emitted by
+        // hand, treating this one component as a single-wave run — the same shape
+        // `run.waves`/`run.order` below already give it.
+        const componentOutputs = { ...seedOutputs };
+        const componentName = resolvedTargets[0].name;
+        onProgress?.({ type: "run-start", waves: [selected] });
+        onProgress?.({ type: "wave-start", wave: 1, components: selected });
+        onProgress?.({ type: "component-start", wave: 1, component: componentName });
+        const componentResult = await runComponentDeploy(resolvedTargets[0], deployContext({ env, releaseIdentity }, componentName), registry, componentOutputs, onProgress, gates ? { port: gates } : undefined);
+        const status = componentResult.status === "fail" ? "failed" : componentResult.status;
+        onProgress?.({ type: "component-done", wave: 1, component: componentName, status });
+        onProgress?.({ type: "wave-done", wave: 1, status });
+        onProgress?.({ type: "run-done", status });
+        const run = {
+            order: selected,
+            waves: [selected],
+            results: [componentResult],
+            ok: componentResult.ok,
+            status: componentResult.status,
+            failedComponent: componentResult.status === "fail" ? componentResult.component : undefined,
+            ...(componentResult.status === "gated"
+                ? {
+                    gatedComponent: componentResult.component,
+                    gate: componentResult.gate,
+                    ...(componentResult.gatePushed !== undefined ? { gatePushed: componentResult.gatePushed } : {}),
+                    ...(componentResult.gatePushWarning ? { gatePushWarning: componentResult.gatePushWarning } : {}),
+                    ...(componentResult.gateMismatch ? { gateMismatch: componentResult.gateMismatch } : {}),
+                }
+                : {}),
+            componentOutputs,
+        };
+        return {
+            success: componentResult.ok,
+            run,
+            selected,
+            buildParams: options.buildParams,
+            ...(componentResult.status === "gated" && componentResult.gate
+                ? {
+                    gated: {
+                        component: componentResult.component,
+                        gate: componentResult.gate,
+                        ...(componentResult.gatePushed !== undefined ? { pushed: componentResult.gatePushed } : {}),
+                        ...(componentResult.gatePushWarning ? { pushWarning: componentResult.gatePushWarning } : {}),
+                        ...(componentResult.gateMismatch ? { mismatch: componentResult.gateMismatch } : {}),
+                    },
+                }
+                : {}),
+        };
+    }
+    catch (err) {
+        if (err instanceof DriverRunFailure) {
+            return { success: false, run: err.result, selected, error: err.message };
+        }
+        if (err instanceof UnknownDependencyError || err instanceof DependencyCycleError) {
+            return { success: false, selected, error: err.message };
+        }
+        throw err;
+    }
+}

package/dist/components/component.js

@@ -0,0 +1,120 @@
+/**
+ * Typed `Component` authoring form — Phase 2 (#560, epic #551).
+ *
+ * This is the real authoring frontend the docs (component-contract.mdx,
+ * composition-and-wiring.mdx) describe and that `pilots/authoring-shape.ts`
+ * (#555's stopgap) explicitly deferred to this issue. It mirrors
+ * `component.schema.json` field-for-field, so `projectToJson` stays a
+ * structural no-op — the interesting content lives in each component's
+ * composition, not in a bespoke serializer.
+ *
+ * See https://intentius.io/chant/components/component-contract/ and
+ * https://intentius.io/chant/components/composition-and-wiring/.
+ */
+/** Author a named phase. `steps` may mix capability `Step`s, `Gate`s, and nested `Phase`s (fan-out). */
+export function phase(name, steps, opts) {
+    return { phase: name, steps, ...(opts?.parallel ? { parallel: true } : {}) };
+}
+/** Author a gate step — a human approval the driver decides against the gate ledger, stopping the run `gated` when nothing has answered it. */
+export function gate(name, opts) {
+    return { kind: "gate", gate: name, ...opts };
+}
+/**
+ * Author a cross-stack output reference — the TypeScript-side equivalent of
+ * the JSON contract's `{ stackOutput: { stack, name } }` (schema
+ * `StackOutputReference`), e.g. `stackOutput("shared-alb", "ListenerArn")`.
+ * Resolved by `chant graph --stacks`, never by orchestrator code.
+ */
+export function stackOutput(stack, name) {
+    return { stackOutput: { stack, name } };
+}
+/**
+ * Every capability-family marker `inferArchetype` looks for, grouped the same
+ * way component-contract.mdx's archetype table groups phases. Kept as a plain
+ * list (not the full starter verb set) so this module has no dependency on
+ * `./registry`/`./verbs` — inference is a structural, name-based heuristic
+ * over the composition, not a capability-registry lookup.
+ */
+const BUILD_ONLY_HINT = new Set(["docker-build", "zip-package", "jvm-build"]);
+const PUBLISH_KIND_PREFIX = /^(publish-|load-image-on-host)/;
+/** True if a step's `kind` looks like a publish-family capability (`publish-image`, `publish-artifact`, `load-image-on-host`, ...). */
+function isPublishStep(step) {
+    return PUBLISH_KIND_PREFIX.test(step.kind);
+}
+/**
+ * Distinguishes a nested fan-out `Phase` from a `Step`/`Gate` within a
+ * phase's `steps` array. `Step` carries an open index signature
+ * (`[param: string]: unknown`), so a plain `"phase" in s` structural check
+ * cannot narrow `Step` away from `Phase` — checking the concrete field types
+ * (`phase` is a string, `steps` is an array) here is what actually
+ * disambiguates them.
+ */
+function isNestedPhase(s) {
+    return typeof s.phase === "string" && Array.isArray(s.steps);
+}
+/** Flatten every step across every phase (including nested fan-out phases) into one list, for structural inspection. */
+function allSteps(phases) {
+    const out = [];
+    const walk = (ps) => {
+        for (const p of ps) {
+            for (const s of p.steps) {
+                if (isNestedPhase(s))
+                    walk([s]);
+                else
+                    out.push(s);
+            }
+            if (p.onFailure)
+                walk(p.onFailure);
+        }
+    };
+    walk(phases);
+    return out;
+}
+/**
+ * Infer a component's archetype from the shape of its composition, when no
+ * explicit `archetype` is authored — matching the archetype table in
+ * component-contract.mdx:
+ *  - **producer-library**: has a `build`, and every step across `deploy` is a
+ *    publish-family step (or a gate) — build -> publish only, no apply.
+ *  - **service**: has a `build` and at least one non-publish, non-gate step
+ *    (an apply/verify step) — build -> publish -> apply -> verify.
+ *  - **infra**: no `build` — apply -> verify only.
+ *
+ * This is a structural heuristic, not a capability-registry lookup (see
+ * `BUILD_ONLY_HINT`/`isPublishStep` above): it only needs to distinguish
+ * "nothing but publish" from "something else happens after publish", which
+ * every merged pilot/fixture satisfies without consulting the registry.
+ */
+export function inferArchetype(component) {
+    if (!component.build)
+        return "infra";
+    const steps = allSteps(component.deploy);
+    const nonGateSteps = steps.filter((s) => s.kind !== "gate");
+    const hasNonPublishStep = nonGateSteps.some((s) => !isPublishStep(s));
+    return hasNonPublishStep ? "service" : "producer-library";
+}
+/**
+ * Project a typed `Component` to its plain-JSON contract form
+ * (component.schema.json). Field names already match the schema 1:1, so
+ * projection is mechanical: a deep `JSON.parse(JSON.stringify())` round-trip
+ * (dropping `undefined` optional fields) plus filling in `archetype` via
+ * `inferArchetype` when the author didn't supply one explicitly. Kept
+ * intentionally dumb beyond that inference — the schema/fixtures stay the
+ * source of truth for shape, not this function.
+ */
+export function projectToJson(component) {
+    const withArchetype = {
+        ...component,
+        archetype: component.archetype ?? inferArchetype(component),
+    };
+    return JSON.parse(JSON.stringify(withArchetype));
+}
+/** Runtime type guard: true if `value` looks like a `Component` (has the required `name`/`dependsOn`/`deploy` shape). Used by discovery to pick exported `Component` values out of a `*.component.ts` module without requiring a class/marker symbol. */
+export function isComponent(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const v = value;
+    return (typeof v.name === "string" &&
+        Array.isArray(v.dependsOn) &&
+        Array.isArray(v.deploy));
+}