@agentxm/extension-lifecycle 0.28.11 → 0.28.13

package/dist/src/packs/dependency-resolution.js

@@ -1,414 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import { formatFqn, parseFqnOrThrow, toExtensionTypePlural, } from "@agentxm/extension-model/unstable/extensions";
-import { SourceAuthorityBlocked, PackConstraintShadowed, PackDependencyConflict, PackDependencyInvalid, PackDependencyMissing, PackDependencyUnsatisfied, } from "@agentxm/extension-workspace";
-import * as semver from "semver";
-import { releaseAgeExemptionForIdentity } from "@agentxm/registry-protocol/unstable/registry/release-age-policy";
-const validateSelectedDependency = (candidate, expectedType, parsed, fqn, constraint) => {
-    if (candidate.type !== expectedType ||
-        (candidate.refType !== "registry" && candidate.refType !== "workspace") ||
-        candidate.owner !== parsed.owner ||
-        candidate.name !== parsed.name) {
-        return new PackDependencyConflict({
-            detail: `Authorized dependency resolution does not match pack dependency ${fqn}`,
-        });
-    }
-    if (!semver.satisfies(candidate.version, constraint)) {
-        return new PackDependencyConflict({
-            detail: `Authorized dependency ${fqn}@${candidate.version} does not satisfy ${constraint}`,
-        });
-    }
-    return Effect.succeed({
-        owner: parsed.owner,
-        type: expectedType,
-        name: parsed.name,
-        ref: candidate,
-    });
-};
-const registrySourceForDependency = (pack, owner, sourceOverride) => {
-    const source = sourceOverride ?? (pack.source.type === "registry" ? pack.source : undefined);
-    if (source === undefined) {
-        return Effect.fail(new PackDependencyInvalid({
-            detail: `Cannot resolve pack dependencies from non-registry source`,
-        }));
-    }
-    return Effect.succeed({
-        ...source,
-        owner: Option.some(owner),
-    });
-};
-const workspaceConstraintConflict = (pack, memberFqn, workspaceVersion, constraint) => new PackConstraintShadowed({
-    packSource: pack.source.type === "workspace" ? "workspace" : "registry",
-    packFqn: formatFqn({ owner: pack.owner, type: "pack", name: pack.pack.name }),
-    memberFqn,
-    constraint,
-    workspaceVersion,
-});
-const resolveDependencyRef = (pack, expectedType, fqn, constraint, sources, minimumReleaseAge, sourceOverride, workspaceResolver, dependencyResolver) => Effect.gen(function* () {
-    const parsed = parseFqnOrThrow(fqn);
-    if (parsed.type !== expectedType) {
-        return yield* new PackDependencyInvalid({
-            detail: `Pack dependency type mismatch for expected ${expectedType}`,
-        });
-    }
-    if (workspaceResolver !== undefined) {
-        const workspace = yield* workspaceResolver({
-            owner: parsed.owner,
-            type: expectedType,
-            name: parsed.name,
-            constraint,
-            root: formatFqn({ owner: pack.owner, type: "pack", name: pack.pack.name }),
-        });
-        if (workspace.kind === "blocked") {
-            return yield* new SourceAuthorityBlocked({
-                detail: workspace.fact.detail,
-                recovery: workspace.fact.recovery,
-            });
-        }
-        if (workspace.kind === "selected") {
-            const candidate = workspace.ref;
-            if (candidate.type !== expectedType ||
-                candidate.refType !== "workspace" ||
-                candidate.owner !== parsed.owner ||
-                candidate.name !== parsed.name) {
-                return yield* new PackDependencyConflict({
-                    detail: `Configured workspace authority does not match pack dependency ${fqn}`,
-                });
-            }
-            if (!semver.satisfies(candidate.version, constraint)) {
-                return yield* workspaceConstraintConflict(pack, fqn, candidate.version, constraint);
-            }
-            return {
-                owner: parsed.owner,
-                type: expectedType,
-                name: parsed.name,
-                ref: candidate,
-            };
-        }
-    }
-    if (dependencyResolver !== undefined) {
-        const candidate = yield* dependencyResolver({
-            owner: parsed.owner,
-            type: expectedType,
-            name: parsed.name,
-            constraint,
-            root: formatFqn({ owner: pack.owner, type: "pack", name: pack.pack.name }),
-        });
-        return yield* validateSelectedDependency(candidate, expectedType, parsed, fqn, constraint);
-    }
-    const source = yield* registrySourceForDependency(pack, parsed.owner, sourceOverride);
-    const matches = yield* Effect.scoped(sources.find(source, {
-        names: [parsed.name],
-        type: expectedType,
-        owner: Option.some(parsed.owner),
-        versionRange: Option.some(constraint),
-        ...(minimumReleaseAge === undefined ? {} : { minimumReleaseAge }),
-    }));
-    const matchingRef = matches.find((candidate) => candidate.type === expectedType &&
-        candidate.refType === "registry" &&
-        candidate.owner === parsed.owner &&
-        candidate.name === parsed.name);
-    if (matchingRef === undefined) {
-        return yield* new PackDependencyInvalid({
-            detail: `Unable to resolve pack dependency ${fqn}@${constraint}`,
-        });
-    }
-    return {
-        owner: parsed.owner,
-        type: expectedType,
-        name: parsed.name,
-        ref: matchingRef,
-    };
-});
-const dependencyReleaseAgeRecord = (args) => ({
-    reason: "minimum-release-age",
-    target: args.dependencyTarget,
-    dependencyPath: [args.packTarget, args.dependencyTarget],
-    requestedRange: args.constraint,
-    ...(args.selectedVersion === undefined ? {} : { selectedVersion: args.selectedVersion }),
-    candidateVersion: args.evidence.version,
-    publishedAt: args.evidence.publishedAt,
-    eligibleAt: args.evidence.eligibleAt,
-    minimumReleaseAgeSeconds: args.evidence.minimumReleaseAgeSeconds,
-});
-const resolveDependencyRefWithReleaseAge = (pack, expectedType, fqn, constraint, sources, evaluation, sourceOverride, workspaceResolver, dependencyResolver) => Effect.gen(function* () {
-    const parsed = parseFqnOrThrow(fqn);
-    if (parsed.type !== expectedType) {
-        return yield* new PackDependencyInvalid({
-            detail: `Pack dependency type mismatch for expected ${expectedType}`,
-        });
-    }
-    if (workspaceResolver !== undefined) {
-        const workspace = yield* workspaceResolver({
-            owner: parsed.owner,
-            type: expectedType,
-            name: parsed.name,
-            constraint,
-            root: formatFqn({ owner: pack.owner, type: "pack", name: pack.pack.name }),
-        });
-        if (workspace.kind === "blocked") {
-            return yield* new SourceAuthorityBlocked({
-                detail: workspace.fact.detail,
-                recovery: workspace.fact.recovery,
-            });
-        }
-        if (workspace.kind === "selected") {
-            const candidate = workspace.ref;
-            if (candidate.type !== expectedType ||
-                candidate.refType !== "workspace" ||
-                candidate.owner !== parsed.owner ||
-                candidate.name !== parsed.name) {
-                return yield* new PackDependencyConflict({
-                    detail: `Configured workspace authority does not match pack dependency ${fqn}`,
-                });
-            }
-            if (!semver.satisfies(candidate.version, constraint)) {
-                return yield* workspaceConstraintConflict(pack, fqn, candidate.version, constraint);
-            }
-            return {
-                kind: "selected",
-                dependency: {
-                    owner: parsed.owner,
-                    type: expectedType,
-                    name: parsed.name,
-                    ref: candidate,
-                },
-                holdbacks: [],
-                bypasses: [],
-            };
-        }
-    }
-    if (dependencyResolver !== undefined) {
-        const candidate = yield* dependencyResolver({
-            owner: parsed.owner,
-            type: expectedType,
-            name: parsed.name,
-            constraint,
-            root: formatFqn({ owner: pack.owner, type: "pack", name: pack.pack.name }),
-        });
-        return {
-            kind: "selected",
-            dependency: yield* validateSelectedDependency(candidate, expectedType, parsed, fqn, constraint),
-            holdbacks: [],
-            bypasses: [],
-        };
-    }
-    const source = yield* registrySourceForDependency(pack, parsed.owner, sourceOverride);
-    const resolution = yield* Effect.scoped(sources.resolveNamedRegistry(source, {
-        name: parsed.name,
-        type: expectedType,
-        owner: parsed.owner,
-        versionRange: Option.some(constraint),
-        releaseAgeEvaluation: evaluation,
-    }));
-    const packTarget = formatFqn({ owner: pack.owner, type: "pack", name: pack.pack.name });
-    const dependencyTarget = formatFqn(parsed);
-    if (resolution.kind === "not_found") {
-        return yield* new PackDependencyMissing({ dependencyTarget });
-    }
-    if (resolution.kind === "version_unsatisfied") {
-        return yield* new PackDependencyUnsatisfied({ dependencyTarget, constraint });
-    }
-    if (resolution.kind === "policy_held") {
-        return {
-            kind: "policy_held",
-            holdback: dependencyReleaseAgeRecord({
-                packTarget,
-                dependencyTarget,
-                constraint,
-                evidence: resolution.candidate,
-            }),
-        };
-    }
-    const ref = resolution.ref;
-    return {
-        kind: "selected",
-        dependency: {
-            owner: parsed.owner,
-            type: expectedType,
-            name: parsed.name,
-            ref,
-        },
-        holdbacks: resolution.kind === "exempted" || resolution.newerHeld === undefined
-            ? []
-            : [
-                dependencyReleaseAgeRecord({
-                    packTarget,
-                    dependencyTarget,
-                    constraint,
-                    evidence: resolution.newerHeld,
-                    selectedVersion: ref.version,
-                }),
-            ],
-        bypasses: resolution.kind === "selected"
-            ? []
-            : [
-                {
-                    ...dependencyReleaseAgeRecord({
-                        packTarget,
-                        dependencyTarget,
-                        constraint,
-                        evidence: resolution.bypassed,
-                        selectedVersion: ref.version,
-                    }),
-                    ...resolution.exemption,
-                },
-            ],
-    };
-});
-const toResolvedMap = (dependencies) => Object.fromEntries(dependencies.map((dependency) => {
-    const ref = dependency.ref;
-    return [
-        formatFqn(dependency),
-        ref.refType === "registry"
-            ? {
-                source: "registry",
-                version: ref.version,
-                publisherBindingId: ref.publisherBindingId,
-                integrity: Option.getOrElse(ref.integrity, () => ""),
-            }
-            : {
-                source: "workspace",
-                version: ref.version,
-                sourceIdentity: `workspace:${ref.owner}/${toExtensionTypePlural(ref.type)}/${ref.name}`,
-                contentIdentity: ref.sourceHash,
-            },
-    ];
-}));
-const resolveDependencyGroup = (pack, dependencies, expectedType, sources, minimumReleaseAge, sourceOverride, workspaceResolver, dependencyResolver) => Effect.forEach(dependencies, ([fqn, constraint]) => resolveDependencyRef(pack, expectedType, fqn, constraint, sources, minimumReleaseAge, sourceOverride, workspaceResolver, dependencyResolver), { concurrency: "unbounded" });
-/**
- * Group dependency FQNs by extension type.
- *
- * The `groups` record is keyed by every non-pack extension type, so a new type
- * fails compile here rather than being silently dropped from pack membership.
- */
-const partitionDependencies = (dependencies) => {
-    const groups = {
-        skill: [],
-        "mcp-server": [],
-        subagent: [],
-        rule: [],
-        hook: [],
-        knowledge: [],
-    };
-    const unsupported = [];
-    for (const [fqn, constraint] of Object.entries(dependencies)) {
-        const parsed = parseFqnOrThrow(fqn);
-        if (parsed.type === "pack") {
-            unsupported.push(fqn);
-            continue;
-        }
-        groups[parsed.type].push([fqn, constraint]);
-    }
-    return { groups, unsupported };
-};
-export const resolvePackDependencies = (pack, sources, minimumReleaseAge, sourceOverride, workspaceResolver, dependencyResolver) => Effect.gen(function* () {
-    const dependencies = partitionDependencies(pack.pack.dependencies);
-    if (dependencies.unsupported.length > 0) {
-        return yield* new PackDependencyInvalid({
-            detail: `Pack declares ${dependencies.unsupported.length} unsupported dependency type${dependencies.unsupported.length === 1 ? "" : "s"}: ${dependencies.unsupported.join(", ")}`,
-        });
-    }
-    const resolveGroup = (type) => resolveDependencyGroup(pack, dependencies.groups[type], type, sources, minimumReleaseAge, sourceOverride, workspaceResolver, dependencyResolver);
-    const resolvedSkills = yield* resolveGroup("skill");
-    const resolvedMcpServers = yield* resolveGroup("mcp-server");
-    const resolvedSubagents = yield* resolveGroup("subagent");
-    const resolvedRules = yield* resolveGroup("rule");
-    const resolvedHooks = yield* resolveGroup("hook");
-    const resolvedKnowledge = yield* resolveGroup("knowledge");
-    return {
-        resolvedSkills: toResolvedMap(resolvedSkills),
-        resolvedMcpServers: toResolvedMap(resolvedMcpServers),
-        resolvedSubagents: toResolvedMap(resolvedSubagents),
-        resolvedRules: toResolvedMap(resolvedRules),
-        resolvedHooks: toResolvedMap(resolvedHooks),
-        resolvedKnowledge: toResolvedMap(resolvedKnowledge),
-        dependencyRefs: [
-            ...resolvedSkills,
-            ...resolvedMcpServers,
-            ...resolvedSubagents,
-            ...resolvedRules,
-            ...resolvedHooks,
-            ...resolvedKnowledge,
-        ].map((dependency) => dependency.ref),
-    };
-});
-export const resolvePackDependenciesWithReleaseAge = (pack, sources, evaluation, sourceOverride, workspaceResolver, dependencyResolver) => Effect.gen(function* () {
-    const packExemption = pack.refType === "registry"
-        ? releaseAgeExemptionForIdentity(evaluation, {
-            owner: pack.owner,
-            type: "pack",
-            name: pack.pack.name,
-        })
-        : undefined;
-    const dependencyEvaluation = packExemption?.bypassCause === "exclude"
-        ? { ...evaluation, grantedExemption: packExemption }
-        : evaluation;
-    const dependencies = partitionDependencies(pack.pack.dependencies);
-    if (dependencies.unsupported.length > 0) {
-        return yield* new PackDependencyInvalid({
-            detail: `Pack declares ${dependencies.unsupported.length} unsupported dependency type${dependencies.unsupported.length === 1 ? "" : "s"}: ${dependencies.unsupported.join(", ")}`,
-        });
-    }
-    const entries = [
-        ...dependencies.groups.skill.map(([fqn, constraint]) => ({
-            type: "skill",
-            fqn,
-            constraint,
-        })),
-        ...dependencies.groups["mcp-server"].map(([fqn, constraint]) => ({
-            type: "mcp-server",
-            fqn,
-            constraint,
-        })),
-        ...dependencies.groups.subagent.map(([fqn, constraint]) => ({
-            type: "subagent",
-            fqn,
-            constraint,
-        })),
-        ...dependencies.groups.rule.map(([fqn, constraint]) => ({
-            type: "rule",
-            fqn,
-            constraint,
-        })),
-        ...dependencies.groups.hook.map(([fqn, constraint]) => ({
-            type: "hook",
-            fqn,
-            constraint,
-        })),
-        ...dependencies.groups.knowledge.map(([fqn, constraint]) => ({
-            type: "knowledge",
-            fqn,
-            constraint,
-        })),
-    ];
-    const resolutions = yield* Effect.forEach(entries, ({ type, fqn, constraint }) => resolveDependencyRefWithReleaseAge(pack, type, fqn, constraint, sources, dependencyEvaluation, sourceOverride, workspaceResolver, dependencyResolver), { concurrency: "unbounded" });
-    const holdbacks = resolutions.flatMap((resolution) => resolution.kind === "policy_held" ? [resolution.holdback] : resolution.holdbacks);
-    const bypasses = resolutions.flatMap((resolution) => resolution.kind === "selected" ? resolution.bypasses : []);
-    if (resolutions.some((resolution) => resolution.kind === "policy_held")) {
-        return { kind: "policy_held", holdbacks, bypasses };
-    }
-    const selected = resolutions.flatMap((resolution) => resolution.kind === "selected" ? [resolution.dependency] : []);
-    const byType = (type) => selected.filter((dependency) => dependency.type === type);
-    const resolvedSkills = byType("skill");
-    const resolvedMcpServers = byType("mcp-server");
-    const resolvedSubagents = byType("subagent");
-    const resolvedRules = byType("rule");
-    const resolvedHooks = byType("hook");
-    const resolvedKnowledge = byType("knowledge");
-    return {
-        kind: "selected",
-        holdbacks,
-        bypasses,
-        dependencies: {
-            resolvedSkills: toResolvedMap(resolvedSkills),
-            resolvedMcpServers: toResolvedMap(resolvedMcpServers),
-            resolvedSubagents: toResolvedMap(resolvedSubagents),
-            resolvedRules: toResolvedMap(resolvedRules),
-            resolvedHooks: toResolvedMap(resolvedHooks),
-            resolvedKnowledge: toResolvedMap(resolvedKnowledge),
-            dependencyRefs: selected.map((dependency) => dependency.ref),
-        },
-    };
-});
-//# sourceMappingURL=dependency-resolution.js.map

package/dist/src/packs/manager.d.ts

@@ -1,16 +0,0 @@
-/**
- * Pack manager service.
- *
- * Implements ExtensionManager<PackRef>. Delegates to existing
- * pack materialization functions and workspace service methods.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import * as Layer from "effect/Layer";
-import { SourceHostProviders } from "@agentxm/extension-sources";
-import { PackManager } from "@agentxm/extension-workspace";
-import { WorkspaceMutations } from "@agentxm/workspace-state";
-export declare const PackManagerLive: Layer.Layer<PackManager, never, SourceHostProviders | WorkspaceMutations | FileSystem.FileSystem | Path.Path>;
-//# sourceMappingURL=manager.d.ts.map

package/dist/src/packs/manager.js

@@ -1,181 +0,0 @@
-/**
- * Pack manager service.
- *
- * Implements ExtensionManager<PackRef>. Delegates to existing
- * pack materialization functions and workspace service methods.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import { PackArchiveFetchFailed, PackDefinitionInvalid, PackInstallStateMissing, PackStagingFailed, } from "@agentxm/extension-workspace";
-import { canReuseInstalledPackage, replaceCanonicalDirectoryWithInspection, } from "@agentxm/extension-workspace";
-import { configuredPacksToDiskRefs } from "@agentxm/extension-workspace";
-import { SourceHostProviders } from "@agentxm/extension-sources";
-import { PackManager } from "@agentxm/extension-workspace";
-import { WorkspaceMutations } from "@agentxm/workspace-state";
-import { copyExtensionDirectory } from "@agentxm/extension-workspace";
-import { computePackPathsForLayout } from "@agentxm/workspace-state";
-import { removeIfExists } from "@agentxm/workspace-state";
-import { acceptedRegistryVersionForRef, validateExactResolvedVersion, } from "@agentxm/workspace-state";
-import { decodeVersionSync } from "@agentxm/extension-model/unstable/version-constraints";
-import { configuredRowsByName } from "@agentxm/workspace-state";
-import { isObservedInstalled } from "@agentxm/workspace-state";
-import { acceptedCanonicalObservation, prepareAcceptedCanonicalTransition, removableAcceptedCanonicalPath, } from "@agentxm/workspace-state";
-import { computePackManifestContentIdentity } from "@agentxm/workspace-state";
-import { computeMaterializedTreeIntegrity, } from "@agentxm/workspace-state";
-// Build pack SetPackArgs from a registry ref
-const buildSetPackArgs = (ref, versionRange, treeIntegrity) => ({
-    type: "registry",
-    sourceType: "registry",
-    packageFormat: "agentxm",
-    endpoint: ref.source.location,
-    extensionType: "pack",
-    workspaceName: ref.pack.name,
-    owner: ref.owner,
-    name: ref.pack.name,
-    resolvedVersion: decodeVersionSync(ref.version),
-    integrity: Option.getOrElse(ref.integrity, () => ""),
-    sourceName: ref.source.name,
-    publisherBindingId: ref.publisherBindingId,
-    treeIntegrity,
-    manifestContentIdentity: computePackManifestContentIdentity({
-        owner: ref.owner,
-        type: "pack",
-        name: ref.pack.name,
-        version: ref.version,
-        dependencies: ref.pack.dependencies,
-    }),
-    versionRange,
-});
-// -----------------------------------------------------------------------------
-// Live Layer
-// -----------------------------------------------------------------------------
-export const PackManagerLive = Layer.effect(PackManager, Effect.gen(function* () {
-    const ws = yield* WorkspaceMutations;
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const sources = yield* SourceHostProviders;
-    const baseDir = ws.baseDir;
-    // Build a layer to provide FileSystem + Path to inner effects
-    const fsPathLayer = Layer.merge(Layer.succeed(FileSystem.FileSystem, fs), Layer.succeed(Path.Path, path));
-    const provide = (effect) => Effect.provide(effect, fsPathLayer);
-    const lastTreeIntegrities = new Map();
-    const materializeInstall = Effect.fn("PackManager.materializeInstall")(function* ({ ref, force }) {
-        if (ref.refType === "registry") {
-            yield* validateExactResolvedVersion(`packs.${ref.pack.name}.resolvedVersion`, ref.version);
-        }
-        const packDir = computePackPathsForLayout(path.join, ws.layout, ref.refType === "workspace" ? "workspace" : ref.source.name, ref.owner, ref.pack.name).canonicalPath;
-        const canonicalExists = yield* fs.exists(packDir).pipe(Effect.orElseSucceed(() => false));
-        if (ref.refType === "workspace") {
-            if (ref.scope !== ws.scope || path.resolve(ref.location) !== path.resolve(packDir)) {
-                return yield* new PackDefinitionInvalid({
-                    detail: `Invalid workspace pack source location: ${ref.location}`,
-                });
-            }
-            if (!canonicalExists) {
-                return yield* new PackDefinitionInvalid({
-                    detail: `Workspace pack package is missing: ${packDir}`,
-                });
-            }
-            return;
-        }
-        const lockedEntry = yield* ws.getLockedPack(ref.pack.name);
-        const lockedVersion = acceptedRegistryVersionForRef(lockedEntry, ref);
-        if (yield* provide(canReuseInstalledPackage({
-            installedPath: packDir,
-            force: force === true,
-            refVersion: ref.version,
-            hasIntegrity: Option.isSome(ref.integrity),
-            ...(lockedVersion === undefined ? {} : { lockedVersion }),
-            existsFailureDetail: (target) => `Failed to check if canonical pack path exists: ${target}`,
-        }))) {
-            if (Option.isSome(lockedEntry)) {
-                const observedTree = yield* provide(computeMaterializedTreeIntegrity(packDir));
-                if (observedTree === lockedEntry.value.treeIntegrity) {
-                    lastTreeIntegrities.set(ref.pack.name, lockedEntry.value.treeIntegrity);
-                    return;
-                }
-            }
-        }
-        yield* Effect.scoped(Effect.gen(function* () {
-            const fetched = yield* sources
-                .fetch(ref)
-                .pipe(Effect.mapError((e) => new PackArchiveFetchFailed({ message: e.message, cause: e })));
-            const materialized = yield* provide(replaceCanonicalDirectoryWithInspection({
-                baseDir,
-                canonicalPath: packDir,
-                populate: (stagingPath) => copyExtensionDirectory(fetched.directory, stagingPath).pipe(Effect.mapError((cause) => new PackStagingFailed({ packDir, cause }))),
-                inspect: computeMaterializedTreeIntegrity,
-            }));
-            lastTreeIntegrities.set(ref.pack.name, materialized.inspection);
-        }));
-    });
-    const materializeUninstall = Effect.fn("PackManager.materializeUninstall")(function* ({ target }) {
-        const canonical = yield* provide(acceptedCanonicalObservation({ workspace: ws, type: "pack", name: target.name }));
-        const packDir = removableAcceptedCanonicalPath(canonical);
-        if (Option.isSome(packDir))
-            yield* removeIfExists(fs, packDir.value);
-    });
-    const materializeDeactivate = () => Effect.void;
-    const buildCurrentPackArgs = (ref, versionRange) => Effect.gen(function* () {
-        if (ref.refType !== "registry")
-            return Option.none();
-        const treeIntegrity = lastTreeIntegrities.get(ref.pack.name);
-        if (treeIntegrity === undefined) {
-            return yield* new PackInstallStateMissing({ name: ref.pack.name });
-        }
-        return Option.some(buildSetPackArgs(ref, versionRange, treeIntegrity));
-    });
-    return {
-        type: "pack",
-        runTransaction: ws.runTransaction,
-        isInstalled: Effect.fn("PackManager.isInstalled")(function* ({ target, }) {
-            return yield* isObservedInstalled(ws, "pack", target.name);
-        }),
-        materializeInstall,
-        prepareSourceTransition: ({ ref }) => provide(prepareAcceptedCanonicalTransition({
-            workspace: ws,
-            type: "pack",
-            name: ref.pack.name,
-            ref,
-        })),
-        getConfiguredSource: Effect.fn("PackManager.getConfiguredSource")(function* ({ target }) {
-            const configured = yield* ws.getConfiguredPackEntries();
-            return Option.fromUndefinedOr(configured[target.name]?.source);
-        }),
-        listMaterializable: Effect.fn("PackManager.listMaterializable")(function* () {
-            const configured = yield* ws.records.rows("pack").pipe(Effect.map(configuredRowsByName));
-            return yield* configuredPacksToDiskRefs({ fs, path, baseDir, scope: ws.scope, layout: ws.layout }, configured);
-        }),
-        materializeUninstall,
-        materializeDeactivate,
-        upsertSettingsEntry: Effect.fn("PackManager.upsertSettingsEntry")(function* ({ ref, versionRange, }) {
-            const args = yield* buildCurrentPackArgs(ref, versionRange);
-            if (Option.isSome(args)) {
-                yield* ws.setPack(args.value);
-            }
-            else {
-                yield* ws.setPackEntry(ref.pack.name, {
-                    source: "workspace",
-                    enabled: true,
-                });
-            }
-        }),
-        removeSettingsEntry: ({ target }) => ws.removePackSettings(target.name).pipe(Effect.withSpan("PackManager.removeSettingsEntry")),
-        upsertLockfileEntry: Effect.fn("PackManager.upsertLockfileEntry")(function* ({ ref }) {
-            const args = yield* buildCurrentPackArgs(ref, Option.none());
-            if (Option.isSome(args)) {
-                yield* ws.setPackLock(args.value);
-            }
-            else {
-                yield* ws.removePackLock(ref.pack.name);
-            }
-        }),
-        removeLockfileEntry: ({ target }) => ws.removePackLock(target.name).pipe(Effect.withSpan("PackManager.removeLockfileEntry")),
-    };
-}));
-//# sourceMappingURL=manager.js.map

package/dist/src/registry-materialization.d.ts

@@ -1,52 +0,0 @@
-/**
- * Registry-backed canonical package materialization.
- *
- * The canonical-directory staging/swap machinery lives in
- * `@agentxm/extension-workspace`; this module owns only the registry
- * fetch/verify/extract path.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Option from "effect/Option";
-import * as Path from "effect/Path";
-import * as HttpClient from "effect/unstable/http/HttpClient";
-import type { Version, VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
-import type { ExtensionName, ExtensionType } from "@agentxm/extension-model/unstable/extensions/common";
-import type { Handle } from "@agentxm/extension-model/unstable/extensions/handle";
-import { ArchiveIntegrityMismatch, type CanonicalDirectoryReplacementError, type MaterializedPackage } from "@agentxm/extension-workspace";
-import { CoupledDependencyFailure } from "@agentxm/extension-workspace";
-import { type MaterializedTreeInvalid } from "@agentxm/workspace-state";
-export interface RegistryPackageMaterializationMessages {
-    readonly integrityMismatchDetail: string;
-}
-export interface MaterializeRegistryPackageArgs<E = never> {
-    readonly baseDir: string;
-    /**
-     * Canonical installed path for this extension. Bytes always land in a sibling
-     * staging directory first and are swapped in after validation.
-     */
-    readonly destinationPath: string;
-    readonly sourceLocation: URL;
-    readonly owner: Handle;
-    readonly type: ExtensionType;
-    readonly name: ExtensionName;
-    readonly version: Version | VersionRange;
-    readonly integrity: Option.Option<string>;
-    readonly messages: RegistryPackageMaterializationMessages;
-    readonly validate?: (stagingPath: string) => Effect.Effect<void, E, FileSystem.FileSystem | Path.Path>;
-}
-/**
- * Fetch, verify, and extract a registry package into `destinationPath`.
- *
- * Always writes. Whether new bytes are needed at all is
- * `canReuseInstalledPackage`'s decision, which the caller makes against the
- * canonical installed path before choosing a destination.
- *
- * Registry client and archive-extraction failures travel opaquely as coupled
- * dependency failures; the application boundary restores and converts them.
- */
-export declare const materializeRegistryPackageWithTreeIntegrity: <E = never>(args: MaterializeRegistryPackageArgs<E>) => Effect.Effect<MaterializedPackage, E | CoupledDependencyFailure | ArchiveIntegrityMismatch | CanonicalDirectoryReplacementError | MaterializedTreeInvalid, FileSystem.FileSystem | HttpClient.HttpClient | Path.Path>;
-export declare const materializeRegistryPackage: <E = never>(args: MaterializeRegistryPackageArgs<E>) => Effect.Effect<string, CoupledDependencyFailure | ArchiveIntegrityMismatch | CanonicalDirectoryReplacementError | MaterializedTreeInvalid | E, FileSystem.FileSystem | HttpClient.HttpClient | Path.Path>;
-//# sourceMappingURL=registry-materialization.d.ts.map