@agentxm/workspace-state 0.28.4-bootstrap.0

package/dist/src/workspace/desired-pack-lock.js

@@ -0,0 +1,132 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as semver from "semver";
+import { parseExtensionFqnParts } from "@agentxm/extension-model/unstable/extensions";
+import { computePackManifestContentIdentity } from "./pack-manifest-content-identity.js";
+import { PACK_MANIFEST_FILENAME, PackManifestSchema, } from "@agentxm/extension-model/unstable/packs/manifest-schema";
+import { computePackPathsForLayout } from "./pack-paths.js";
+import { isInlineDesiredExtension, } from "./desired-state-graph.js";
+import { isDesiredExtensionActive } from "./desired-state-enabled.js";
+const normalizedPackIdentity = (identity) => identity.startsWith("workspace:") ? identity.slice("workspace:".length) : identity;
+const isPackProblem = (problem) => problem.type.startsWith("pack-");
+const withoutInvalidPackOrigins = (graph, invalidPacks) => graph.nodes.flatMap((node) => {
+    if (isInlineDesiredExtension(node))
+        return [node];
+    if (node.type === "pack")
+        return [node];
+    const origins = node.origins.filter((origin) => origin.type !== "pack" || !invalidPacks.has(normalizedPackIdentity(origin.pack)));
+    if (origins.length === 0)
+        return [];
+    const settingsOrigin = origins.find((origin) => origin.type === "settings");
+    const packOrigin = origins.find((origin) => origin.type === "pack");
+    const constraints = origins.flatMap((origin) => origin.type === "settings" && origin.authority === "inline"
+        ? []
+        : origin.constraint === undefined
+            ? []
+            : [origin.constraint]);
+    if (settingsOrigin?.type === "settings" && settingsOrigin.authority === "inline") {
+        return [{ ...node, enabled: isDesiredExtensionActive(origins), constraints, origins }];
+    }
+    return [
+        {
+            ...node,
+            source: (settingsOrigin !== undefined && "source" in settingsOrigin
+                ? settingsOrigin.source
+                : undefined) ??
+                (packOrigin === undefined
+                    ? node.source
+                    : `${packOrigin.source}@${packOrigin.constraint}`),
+            enabled: isDesiredExtensionActive(origins),
+            constraints,
+            origins,
+        },
+    ];
+});
+const decodeManifest = Schema.decodeUnknownSync(PackManifestSchema, {
+    onExcessProperty: "error",
+});
+/**
+ * Authorize enabled external Pack manifests against their accepted lock row.
+ * Workspace-authored Pack manifests are desired authority and need no lock row.
+ */
+export const validateDesiredPackLock = ({ graph, lockfile, layout, }) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const problems = [];
+    const invalidPacks = new Set(graph.problems.flatMap((problem) => isPackProblem(problem) ? [normalizedPackIdentity(problem.pack)] : []));
+    for (const node of graph.nodes) {
+        if (node.type !== "pack" || !node.enabled || node.identity.startsWith("workspace:")) {
+            continue;
+        }
+        const identity = parseExtensionFqnParts(node.identity);
+        const entry = lockfile.packs?.[node.name];
+        const configuredSourceName = node.source.startsWith("@")
+            ? "agentxm"
+            : node.source.slice(0, node.source.indexOf(":"));
+        if (identity === undefined ||
+            identity.type !== "pack" ||
+            entry === undefined ||
+            entry.sourceName !== configuredSourceName ||
+            entry.owner !== identity.owner ||
+            entry.name !== identity.name ||
+            !node.constraints.every((constraint) => semver.satisfies(entry.resolvedVersion, constraint))) {
+            problems.push({
+                type: "pack-resolution-unavailable",
+                pack: node.identity,
+                detail: "The configured external Pack has no matching accepted resolution.",
+            });
+            invalidPacks.add(normalizedPackIdentity(node.identity));
+            continue;
+        }
+        const manifestPath = path.join(computePackPathsForLayout(path.join, layout, entry.sourceName, identity.owner, identity.name).canonicalPath, PACK_MANIFEST_FILENAME);
+        const readResult = yield* Effect.result(fs.readFileString(manifestPath));
+        if (Result.isFailure(readResult)) {
+            problems.push({
+                type: "pack-manifest-content-mismatch",
+                pack: node.identity,
+                path: manifestPath,
+                status: "missing",
+                acceptedVersion: entry.resolvedVersion,
+                acceptedContentIdentity: entry.manifestContentIdentity,
+            });
+            invalidPacks.add(normalizedPackIdentity(node.identity));
+            continue;
+        }
+        const decoded = Result.try({
+            try: () => decodeManifest(JSON.parse(readResult.success)),
+            catch: () => undefined,
+        });
+        const observedManifest = Result.isSuccess(decoded) && decoded.success !== undefined ? decoded.success : undefined;
+        const observedContentIdentity = observedManifest === undefined
+            ? undefined
+            : computePackManifestContentIdentity(observedManifest);
+        if (observedManifest === undefined ||
+            observedContentIdentity !== entry.manifestContentIdentity) {
+            problems.push({
+                type: "pack-manifest-content-mismatch",
+                pack: node.identity,
+                path: manifestPath,
+                status: "changed",
+                acceptedVersion: entry.resolvedVersion,
+                acceptedContentIdentity: entry.manifestContentIdentity,
+                ...(observedManifest === undefined || observedContentIdentity === undefined
+                    ? {}
+                    : {
+                        observedVersion: observedManifest.version,
+                        observedContentIdentity,
+                    }),
+            });
+            invalidPacks.add(normalizedPackIdentity(node.identity));
+        }
+    }
+    return {
+        ...graph,
+        complete: graph.complete && problems.length === 0,
+        nodes: withoutInvalidPackOrigins(graph, invalidPacks),
+        problems: [...graph.problems, ...problems],
+    };
+});
+//# sourceMappingURL=desired-pack-lock.js.map

package/dist/src/workspace/desired-state-enabled.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared origin-precedence semantics for desired extension nodes.
+ *
+ * An explicit disabled settings entry is user intent and overrides pack
+ * membership. Otherwise any enabled settings origin or pack origin activates
+ * the extension.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type DesiredStateEnabledOrigin = {
+    readonly type: "settings";
+    readonly enabled: boolean;
+} | {
+    readonly type: "pack";
+    readonly enabled: boolean;
+};
+export declare const isDesiredExtensionActive: (origins: ReadonlyArray<DesiredStateEnabledOrigin>) => boolean;
+//# sourceMappingURL=desired-state-enabled.d.ts.map

package/dist/src/workspace/desired-state-enabled.js

@@ -0,0 +1,16 @@
+/**
+ * Shared origin-precedence semantics for desired extension nodes.
+ *
+ * An explicit disabled settings entry is user intent and overrides pack
+ * membership. Otherwise any enabled settings origin or pack origin activates
+ * the extension.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const isDesiredExtensionActive = (origins) => {
+    const settingsOrigin = origins.find((origin) => origin.type === "settings");
+    if (settingsOrigin?.enabled === false)
+        return false;
+    return origins.some((origin) => origin.enabled);
+};
+//# sourceMappingURL=desired-state-enabled.js.map

package/dist/src/workspace/desired-state-graph.d.ts

@@ -0,0 +1,114 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { type ExtensionType } from "@agentxm/extension-model/unstable/extensions";
+import type { PackRef } from "@agentxm/extension-model/unstable/extensions/refs/pack";
+import type { Settings } from "../settings/index.js";
+import { type WorkspaceLayout } from "./layout.js";
+export type DesiredExtensionOrigin = {
+    readonly type: "settings";
+    readonly authority?: "sourced";
+    readonly source: string;
+    readonly enabled: boolean;
+    readonly constraint?: string;
+} | {
+    readonly type: "settings";
+    readonly authority: "inline";
+    readonly source?: undefined;
+    readonly constraint?: undefined;
+    readonly enabled: boolean;
+} | {
+    readonly type: "pack";
+    readonly pack: string;
+    readonly manifestPath: string;
+    readonly source: string;
+    readonly constraint: string;
+    readonly enabled: boolean;
+};
+interface DesiredExtensionNodeCommon {
+    readonly type: ExtensionType;
+    readonly name: string;
+    readonly identity: string;
+    readonly enabled: boolean;
+    readonly constraints: ReadonlyArray<string>;
+    readonly origins: ReadonlyArray<DesiredExtensionOrigin>;
+}
+export type DesiredExtensionNode = DesiredExtensionNodeCommon & ({
+    readonly authority?: "sourced";
+    readonly source: string;
+} | {
+    readonly type: "mcp-server";
+    readonly authority: "inline";
+    readonly source?: undefined;
+});
+export declare const isInlineDesiredExtension: (node: DesiredExtensionNode) => node is DesiredExtensionNode & {
+    readonly authority: "inline";
+};
+export declare const isSourcedDesiredExtension: (node: DesiredExtensionNode) => node is DesiredExtensionNode & {
+    readonly source: string;
+};
+export interface DesiredConstraintContributor {
+    readonly source: "settings" | "pack";
+    readonly range: string;
+    readonly location: string;
+    readonly dependingPack?: string;
+}
+export type DesiredStateProblem = {
+    readonly type: "workspace-owner-missing";
+    readonly extensionType: ExtensionType;
+    readonly name: string;
+} | {
+    readonly type: "pack-manifest-unavailable";
+    readonly pack: string;
+    readonly path: string;
+} | {
+    readonly type: "pack-manifest-invalid";
+    readonly pack: string;
+    readonly path: string;
+} | {
+    readonly type: "pack-identity-mismatch";
+    readonly pack: string;
+    readonly path: string;
+    readonly detail: string;
+} | {
+    readonly type: "pack-resolution-unavailable";
+    readonly pack: string;
+    readonly detail: string;
+} | {
+    readonly type: "pack-manifest-content-mismatch";
+    readonly pack: string;
+    readonly path?: string;
+    readonly status: string;
+    readonly acceptedVersion: string;
+    readonly acceptedContentIdentity: string;
+    readonly observedVersion?: string;
+    readonly observedContentIdentity?: string;
+} | {
+    readonly type: "projection-collision";
+    readonly extensionType: ExtensionType;
+    readonly name: string;
+    readonly identities: ReadonlyArray<string>;
+} | {
+    readonly type: "constraint-conflict";
+    readonly extensionType: ExtensionType;
+    readonly name: string;
+    readonly constraints: ReadonlyArray<string>;
+    readonly contributors: ReadonlyArray<DesiredConstraintContributor>;
+};
+export interface DesiredStateGraph {
+    readonly complete: boolean;
+    readonly nodes: ReadonlyArray<DesiredExtensionNode>;
+    readonly problems: ReadonlyArray<DesiredStateProblem>;
+}
+export type ProspectivePackRef = Pick<PackRef, "owner" | "pack" | "version">;
+interface DesiredStateGraphArgs {
+    readonly baseDir: string;
+    readonly settings: Settings;
+    readonly layout?: WorkspaceLayout;
+    /** Resolved Pack roots whose manifests supersede the currently materialized copy. */
+    readonly prospectivePacks?: ReadonlyArray<ProspectivePackRef>;
+}
+export declare const collectDesiredConstraintContributors: (_path: Path.Path, origins: ReadonlyArray<DesiredExtensionOrigin>) => ReadonlyArray<DesiredConstraintContributor>;
+export declare const buildDesiredStateGraph: ({ baseDir, settings, layout, prospectivePacks, }: DesiredStateGraphArgs) => Effect.Effect<DesiredStateGraph, never, FileSystem.FileSystem | Path.Path>;
+export {};
+//# sourceMappingURL=desired-state-graph.d.ts.map

package/dist/src/workspace/desired-state-graph.js

@@ -0,0 +1,384 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as semver from "semver";
+import { extensionTypes, parseExtensionFqnParts, parseRegistrySourceRef, toExtensionTypePlural, } from "@agentxm/extension-model/unstable/extensions";
+import { PACK_MANIFEST_FILENAME, PackManifestSchema, } from "@agentxm/extension-model/unstable/packs/manifest-schema";
+import { computePackPathsForLayout } from "./pack-paths.js";
+import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
+import { isDesiredExtensionActive } from "./desired-state-enabled.js";
+import { configuredAuthoredDirectory } from "./layout.js";
+import { SETTINGS_FILENAME } from "@agentxm/extension-model/unstable/workspace-files";
+import { ACQUIRED_EXTENSIONS_DIR } from "./constants.js";
+import { intersectVersionConstraints } from "@agentxm/extension-model/unstable/version-constraints";
+export const isInlineDesiredExtension = (node) => node.authority === "inline";
+export const isSourcedDesiredExtension = (node) => node.authority !== "inline";
+const nodeKey = (type, name) => `${type}:${name}`;
+const packageIdentity = (identity) => identity.startsWith("workspace:") ? identity.slice("workspace:".length) : identity;
+const registryLocator = (source) => {
+    if (source.startsWith("@"))
+        return { sourceName: "agentxm", ref: source };
+    const separator = source.indexOf(":");
+    if (separator <= 0)
+        return undefined;
+    const ref = source.slice(separator + 1);
+    return ref.startsWith("@") ? { sourceName: source.slice(0, separator), ref } : undefined;
+};
+const sourceIdentity = (type, name, source, settings) => {
+    if (isWorkspaceSourceLocator(source)) {
+        return settings.owner === undefined
+            ? { identity: source }
+            : { identity: `workspace:${settings.owner}/${toExtensionTypePlural(type)}/${name}` };
+    }
+    const locator = registryLocator(source);
+    const parsed = locator === undefined ? undefined : parseRegistrySourceRef(locator.ref);
+    if (parsed !== undefined && parsed.type === toExtensionTypePlural(type)) {
+        return {
+            identity: `${parsed.owner}/${parsed.type}/${parsed.name}`,
+            ...(parsed.versionRange === undefined ? {} : { constraint: parsed.versionRange }),
+        };
+    }
+    return { identity: source };
+};
+const packIdentity = (settingsName, source, settings) => {
+    if (isWorkspaceSourceLocator(source)) {
+        if (settings.owner === undefined)
+            return undefined;
+        return {
+            owner: settings.owner,
+            name: settingsName,
+            fqn: `${settings.owner}/packs/${settingsName}`,
+        };
+    }
+    const locator = registryLocator(source);
+    const parsed = locator === undefined ? undefined : parseRegistrySourceRef(locator.ref);
+    if (parsed !== undefined && parsed.type === "packs") {
+        return {
+            owner: parsed.owner,
+            name: parsed.name,
+            fqn: `${parsed.owner}/packs/${parsed.name}`,
+            ...(parsed.versionRange === undefined ? {} : { constraint: parsed.versionRange }),
+        };
+    }
+    if (source === "registry" && settings.owner !== undefined) {
+        return {
+            owner: settings.owner,
+            name: settingsName,
+            fqn: `${settings.owner}/packs/${settingsName}`,
+        };
+    }
+    return undefined;
+};
+export const collectDesiredConstraintContributors = (_path, origins) => origins
+    .flatMap((origin) => {
+    if (origin.type === "settings" && origin.authority === "inline")
+        return [];
+    if (origin.constraint === undefined)
+        return [];
+    if (origin.type === "settings") {
+        return [
+            {
+                source: "settings",
+                range: origin.constraint,
+                location: SETTINGS_FILENAME,
+            },
+        ];
+    }
+    return [
+        {
+            source: "pack",
+            dependingPack: origin.pack.replace(/^workspace:/, ""),
+            range: origin.constraint,
+            location: origin.manifestPath,
+        },
+    ];
+})
+    .sort((left, right) => {
+    const byPack = (left.dependingPack ?? "").localeCompare(right.dependingPack ?? "");
+    if (byPack !== 0)
+        return byPack;
+    const byRange = left.range.localeCompare(right.range);
+    return byRange === 0 ? left.location.localeCompare(right.location) : byRange;
+});
+const parsePackManifest = (raw) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    const decoded = Schema.decodeUnknownResult(PackManifestSchema)(parsed);
+    return Result.isSuccess(decoded) ? decoded.success : undefined;
+};
+export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectivePacks = [], }) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const candidates = [];
+    const problems = [];
+    const prospectivePacksByIdentity = new Map(prospectivePacks.map((ref) => [`${ref.owner}/packs/${ref.pack.name}`, ref]));
+    const addSettingsEntries = (type, entries) => {
+        for (const [name, entry] of Object.entries(entries ?? {})) {
+            const bundled = type === "skill" && entry.origin === "bundled";
+            const identity = bundled
+                ? { identity: `bundled:@agentxm/skills/${name}` }
+                : sourceIdentity(type, name, entry.source, settings);
+            if (!bundled && isWorkspaceSourceLocator(entry.source) && settings.owner === undefined) {
+                problems.push({ type: "workspace-owner-missing", extensionType: type, name });
+            }
+            candidates.push({
+                type,
+                name,
+                identity: identity.identity,
+                authority: "sourced",
+                source: entry.source,
+                enabled: entry.enabled,
+                ...(identity.constraint === undefined ? {} : { constraint: identity.constraint }),
+                origin: {
+                    type: "settings",
+                    authority: "sourced",
+                    source: entry.source,
+                    enabled: entry.enabled,
+                    ...(identity.constraint === undefined ? {} : { constraint: identity.constraint }),
+                },
+            });
+        }
+    };
+    addSettingsEntries("skill", settings.skills);
+    for (const [name, entry] of Object.entries(settings.mcpServers ?? {})) {
+        if (entry.kind === "inline") {
+            candidates.push({
+                type: "mcp-server",
+                name,
+                identity: `@workspace/mcps/${name}`,
+                authority: "inline",
+                enabled: entry.enabled,
+                origin: { type: "settings", authority: "inline", enabled: entry.enabled },
+            });
+            continue;
+        }
+        const identity = sourceIdentity("mcp-server", name, entry.source, settings);
+        if (isWorkspaceSourceLocator(entry.source) && settings.owner === undefined) {
+            problems.push({ type: "workspace-owner-missing", extensionType: "mcp-server", name });
+        }
+        candidates.push({
+            type: "mcp-server",
+            name,
+            identity: identity.identity,
+            authority: "sourced",
+            source: entry.source,
+            enabled: entry.enabled,
+            ...(identity.constraint === undefined ? {} : { constraint: identity.constraint }),
+            origin: {
+                type: "settings",
+                authority: "sourced",
+                source: entry.source,
+                enabled: entry.enabled,
+                ...(identity.constraint === undefined ? {} : { constraint: identity.constraint }),
+            },
+        });
+    }
+    addSettingsEntries("subagent", settings.subagents);
+    addSettingsEntries("rule", settings.rules);
+    addSettingsEntries("hook", settings.hooks);
+    addSettingsEntries("knowledge", settings.knowledge);
+    for (const [settingsName, entry] of Object.entries(settings.packs ?? {})) {
+        const identity = packIdentity(settingsName, entry.source, settings);
+        if (identity === undefined) {
+            problems.push({
+                type: "pack-identity-mismatch",
+                pack: entry.source,
+                path: "",
+                detail: "The configured pack source does not identify a Registry or workspace pack.",
+            });
+            continue;
+        }
+        candidates.push({
+            type: "pack",
+            name: identity.name,
+            identity: isWorkspaceSourceLocator(entry.source)
+                ? `workspace:${identity.fqn}`
+                : identity.fqn,
+            authority: "sourced",
+            source: entry.source,
+            enabled: entry.enabled !== false,
+            ...(identity.constraint === undefined ? {} : { constraint: identity.constraint }),
+            origin: {
+                type: "settings",
+                authority: "sourced",
+                source: entry.source,
+                enabled: entry.enabled !== false,
+                ...(identity.constraint === undefined ? {} : { constraint: identity.constraint }),
+            },
+        });
+        const workspacePack = isWorkspaceSourceLocator(entry.source);
+        const configuredRegistrySource = registryLocator(entry.source)?.sourceName ?? "agentxm";
+        const manifestPath = path.join(layout === undefined
+            ? path.join(baseDir, workspacePack
+                ? configuredAuthoredDirectory(settings, "pack")
+                : path.join(ACQUIRED_EXTENSIONS_DIR, configuredRegistrySource, identity.owner, "packs"), identity.name)
+            : computePackPathsForLayout(path.join, layout, workspacePack ? "workspace" : configuredRegistrySource, identity.owner, identity.name).canonicalPath, PACK_MANIFEST_FILENAME);
+        const prospective = prospectivePacksByIdentity.get(identity.fqn);
+        const manifest = yield* prospective === undefined
+            ? Effect.gen(function* () {
+                const readResult = yield* Effect.result(fs.readFileString(manifestPath));
+                if (Result.isFailure(readResult)) {
+                    problems.push({
+                        type: "pack-manifest-unavailable",
+                        pack: identity.fqn,
+                        path: manifestPath,
+                    });
+                    return undefined;
+                }
+                const decoded = parsePackManifest(readResult.success);
+                if (decoded === undefined) {
+                    problems.push({
+                        type: "pack-manifest-invalid",
+                        pack: identity.fqn,
+                        path: manifestPath,
+                    });
+                }
+                return decoded;
+            })
+            : Effect.succeed({
+                owner: prospective.owner,
+                type: "pack",
+                name: prospective.pack.name,
+                version: prospective.version,
+                dependencies: prospective.pack.dependencies,
+            });
+        if (manifest === undefined)
+            continue;
+        if (manifest.owner !== identity.owner ||
+            manifest.name !== identity.name ||
+            (identity.constraint !== undefined &&
+                !semver.satisfies(manifest.version, identity.constraint))) {
+            problems.push({
+                type: "pack-identity-mismatch",
+                pack: identity.fqn,
+                path: manifestPath,
+                detail: `Expected ${identity.fqn}${identity.constraint === undefined ? "" : `@${identity.constraint}`}, found ${manifest.owner}/packs/${manifest.name}@${manifest.version}.`,
+            });
+            continue;
+        }
+        for (const [fqn, constraint] of Object.entries(manifest.dependencies)) {
+            const parsed = parseExtensionFqnParts(fqn);
+            if (parsed === undefined || parsed.type === "pack")
+                continue;
+            candidates.push({
+                type: parsed.type,
+                name: parsed.name,
+                identity: `${parsed.owner}/${toExtensionTypePlural(parsed.type)}/${parsed.name}`,
+                authority: "sourced",
+                source: `${fqn}@${constraint}`,
+                enabled: entry.enabled !== false,
+                constraint,
+                origin: {
+                    type: "pack",
+                    pack: workspacePack ? `workspace:${identity.fqn}` : identity.fqn,
+                    manifestPath: path.relative(baseDir, manifestPath),
+                    source: fqn,
+                    constraint,
+                    enabled: entry.enabled !== false,
+                },
+            });
+        }
+    }
+    const nodes = new Map();
+    for (const candidate of candidates) {
+        const key = nodeKey(candidate.type, candidate.name);
+        const existing = nodes.get(key);
+        if (existing === undefined) {
+            nodes.set(key, candidate.authority === "sourced"
+                ? {
+                    type: candidate.type,
+                    name: candidate.name,
+                    identity: candidate.identity,
+                    authority: "sourced",
+                    source: candidate.source,
+                    enabled: candidate.enabled,
+                    constraints: candidate.constraint === undefined ? [] : [candidate.constraint],
+                    origins: [candidate.origin],
+                }
+                : {
+                    type: "mcp-server",
+                    name: candidate.name,
+                    identity: candidate.identity,
+                    authority: "inline",
+                    enabled: candidate.enabled,
+                    constraints: [],
+                    origins: [candidate.origin],
+                });
+            continue;
+        }
+        if (packageIdentity(existing.identity) !== packageIdentity(candidate.identity)) {
+            problems.push({
+                type: "projection-collision",
+                extensionType: candidate.type,
+                name: candidate.name,
+                identities: [existing.identity, candidate.identity],
+            });
+            continue;
+        }
+        if (isInlineDesiredExtension(existing) || candidate.authority === "inline") {
+            problems.push({
+                type: "projection-collision",
+                extensionType: candidate.type,
+                name: candidate.name,
+                identities: [existing.identity, candidate.identity],
+            });
+            continue;
+        }
+        const origins = [...existing.origins, candidate.origin];
+        nodes.set(key, {
+            ...existing,
+            source: existing.origins.some((origin) => origin.type === "settings")
+                ? existing.source
+                : candidate.source,
+            enabled: isDesiredExtensionActive(origins),
+            constraints: candidate.constraint === undefined || existing.constraints.includes(candidate.constraint)
+                ? existing.constraints
+                : [...existing.constraints, candidate.constraint],
+            origins,
+        });
+    }
+    for (const node of nodes.values()) {
+        if (intersectVersionConstraints(node.constraints) === undefined) {
+            problems.push({
+                type: "constraint-conflict",
+                extensionType: node.type,
+                name: node.name,
+                constraints: node.constraints,
+                contributors: collectDesiredConstraintContributors(path, node.origins),
+            });
+        }
+    }
+    const typeOrder = new Map(extensionTypes.map((type, index) => [type, index]));
+    const orderedNodes = [...nodes.values()]
+        .map((node) => {
+        if (isInlineDesiredExtension(node))
+            return node;
+        const constraint = intersectVersionConstraints(node.constraints);
+        return {
+            ...node,
+            source: node.identity.startsWith("@") && node.constraints.length > 0 && constraint !== undefined
+                ? `${node.identity}@${constraint}`
+                : node.source,
+        };
+    })
+        .sort((left, right) => {
+        const leftOrder = typeOrder.get(left.type) ?? Number.MAX_SAFE_INTEGER;
+        const rightOrder = typeOrder.get(right.type) ?? Number.MAX_SAFE_INTEGER;
+        return leftOrder === rightOrder
+            ? left.name.localeCompare(right.name)
+            : leftOrder - rightOrder;
+    });
+    return {
+        complete: problems.length === 0,
+        nodes: orderedNodes,
+        problems,
+    };
+});
+//# sourceMappingURL=desired-state-graph.js.map

package/dist/src/workspace/desired-state-problem-text.d.ts

@@ -0,0 +1,6 @@
+import type { DesiredStateProblem } from "./desired-state-graph.js";
+/** Sanitized terminal text for one desired-state problem. */
+export declare const desiredStateProblemText: (problem: DesiredStateProblem) => string;
+/** Stable, sanitized terminal text for a desired-state problem set. */
+export declare const desiredStateProblemsText: (problems: ReadonlyArray<DesiredStateProblem>) => string;
+//# sourceMappingURL=desired-state-problem-text.d.ts.map