@agentxm/extension-authoring 0.28.12 → 0.28.13

package/dist/src/packs/change-pack-membership.js

@@ -0,0 +1,246 @@
+/**
+ * Changing which extensions an authored pack declares.
+ *
+ * A pack's membership is a manifest an author owns, so both directions share
+ * one use case: find the pack the selector names, confirm the workspace
+ * authors it, read the manifest under a plan-time hash, decide which members
+ * the selector resolves to, and reduce that to a delta. An empty delta is a
+ * settled outcome, not a failure.
+ *
+ * @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 Schema from "effect/Schema";
+import { isCatalogExtensionType, } from "@agentxm/extension-model/unstable/extension-types";
+import { decodeExtensionNameSync, formatFqn, parseExtensionFqnParts, } from "@agentxm/extension-model/unstable/extensions";
+import { PACK_MANIFEST_FILENAME, PackManifestSchema, } from "@agentxm/extension-model/unstable/packs/manifest-schema";
+import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
+import { operationPresentation, prepareExecutionCandidate, resolveExecutionCandidate, } from "@agentxm/workspace-operations";
+import { WorkspaceMutations, computePackPathsForLayout, configuredRowsByName, resolveWorkspaceExtensionRef, usableAcceptedCanonical, } from "@agentxm/workspace-state";
+import { settingsRelativePath } from "../create/authoring-owner.js";
+import { addToPack } from "./add-to-pack.js";
+import { resolveConfiguredPackSelector } from "./configured-pack-selector.js";
+import { hashContent } from "./hash-content.js";
+import { isSelectorPattern, selectorMatches } from "./glob.js";
+import { PackGraphInvalid, PackManifestUnavailable, PackMemberAmbiguous, PackMemberNotDeclared, PackMemberNotFound, PackMemberUnmanaged, PackNotAuthored, PackOwnerUnconfigured, PackSourceMissing, } from "./membership-errors.js";
+import { removeFromPack } from "./remove-from-pack.js";
+// -----------------------------------------------------------------------------
+// Member candidates
+// -----------------------------------------------------------------------------
+/**
+ * Derive a lower-bound range from a resolved version.
+ *
+ * A lower bound tracks the latest published member while recording the
+ * version observed when the member was added. A caret would pin pre-1.0
+ * members to their current minor (`^0.4.2` stops before `0.5.0`), stranding
+ * every later release.
+ */
+const toVersionRange = (version) => `>=${version}`;
+/** Every managed, versioned extension in the workspace a pack may depend on. */
+const memberCandidates = Effect.fn("ChangePackMembership.memberCandidates")(function* () {
+    const ws = yield* WorkspaceMutations;
+    const graph = yield* ws.getDesiredStateGraph();
+    const candidates = [];
+    for (const node of graph.nodes) {
+        if (!isCatalogExtensionType(node.type))
+            continue;
+        if (node.source === undefined)
+            continue;
+        const ref = node.identity.startsWith("workspace:")
+            ? yield* resolveWorkspaceExtensionRef({
+                settingsName: node.name,
+                source: node.source,
+                expectedType: node.type,
+                layout: ws.layout,
+                scope: ws.scope,
+            }).pipe(Effect.map(Option.some))
+            : yield* usableAcceptedCanonical({ workspace: ws, type: node.type, name: node.name }).pipe(Effect.map(Option.map((canonical) => canonical.ref)));
+        if (Option.isNone(ref) ||
+            (ref.value.refType !== "registry" && ref.value.refType !== "workspace")) {
+            continue;
+        }
+        const acceptedIdentity = node.identity.startsWith("workspace:")
+            ? node.identity.slice("workspace:".length)
+            : node.identity;
+        const parsed = parseExtensionFqnParts(acceptedIdentity);
+        if (parsed === undefined || parsed.type !== node.type)
+            continue;
+        const packageName = decodeExtensionNameSync(parsed.name);
+        candidates.push({
+            type: node.type,
+            name: node.name,
+            owner: parsed.owner,
+            packageName,
+            fqn: formatFqn({ owner: parsed.owner, type: node.type, name: packageName }),
+            versionRange: toVersionRange(ref.value.version),
+        });
+    }
+    return { graph, candidates };
+});
+// -----------------------------------------------------------------------------
+// prepare
+// -----------------------------------------------------------------------------
+/** Settle a membership change without writing anything. */
+export const preparePackMembership = Effect.fn("ChangePackMembership.prepare")(function* (request) {
+    const ws = yield* WorkspaceMutations;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const configuredPacks = yield* ws.records
+        .rows("pack")
+        .pipe(Effect.map((rows) => Object.values(configuredRowsByName(rows))));
+    const configuredOwner = yield* ws.getConfiguredOwner();
+    const selection = yield* resolveConfiguredPackSelector({
+        configured: configuredPacks,
+        ...(Option.isNone(configuredOwner) ? {} : { configuredOwner: configuredOwner.value }),
+        selector: request.pack,
+    });
+    const pack = selection.configuredName;
+    const source = selection.entry.source;
+    if (source === undefined)
+        return yield* new PackSourceMissing({ pack });
+    if (!isWorkspaceSourceLocator(source))
+        return yield* new PackNotAuthored({ pack });
+    if (Option.isNone(configuredOwner)) {
+        return yield* new PackOwnerUnconfigured({ pack, settingsPath: settingsRelativePath(path, ws) });
+    }
+    const packOwner = configuredOwner.value;
+    const manifestPath = path.join(computePackPathsForLayout(path.join, ws.layout, "workspace", packOwner, pack).canonicalPath, PACK_MANIFEST_FILENAME);
+    const manifestContent = yield* fs
+        .readFileString(manifestPath)
+        .pipe(Effect.mapError((cause) => new PackManifestUnavailable({ path: manifestPath, reason: "unreadable", cause })));
+    const manifestHash = hashContent(manifestContent);
+    const json = yield* Effect.try({
+        try: () => JSON.parse(manifestContent),
+        catch: (cause) => new PackManifestUnavailable({ path: manifestPath, reason: "unparsable", cause }),
+    });
+    const manifest = yield* Schema.decodeUnknownEffect(PackManifestSchema)(json).pipe(Effect.mapError((cause) => new PackManifestUnavailable({ path: manifestPath, reason: "invalid", cause })));
+    const pattern = isSelectorPattern(request.selector);
+    const members = yield* request.change === "add"
+        ? additions({ pack, packOwner, request, pattern, manifest })
+        : removals({ manifest, request, pattern });
+    if (members.length === 0) {
+        const unchanged = { _tag: "NoChange", change: request.change, pack };
+        return unchanged;
+    }
+    const step = {
+        readiness: "ready",
+        label: pack,
+        run: request.change === "add"
+            ? addToPack({
+                name: "add-to-pack",
+                args: {
+                    packName: pack,
+                    packOwner,
+                    additions: Object.fromEntries(members.map((member) => [member.fqn, member.range])),
+                    manifestHash,
+                },
+            })
+            : removeFromPack({
+                name: "remove-from-pack",
+                args: {
+                    packName: pack,
+                    packOwner,
+                    removals: members.map((member) => member.fqn),
+                    manifestHash,
+                },
+            }),
+    };
+    const memberCount = members.length;
+    const plan = {
+        _tag: "Plan",
+        name: packMembershipPlanName(request.change),
+        description: Option.some(request.change === "add"
+            ? `Add ${memberCount} ${memberCount === 1 ? "extension" : "extensions"} to ${pack}`
+            : `Remove ${memberCount} ${memberCount === 1 ? "extension" : "extensions"} from ${pack}`),
+        presentation: operationPresentation(request.change === "add"
+            ? { imperative: "add", past: "Added", gerund: "Adding" }
+            : { imperative: "remove", past: "Removed", gerund: "Removing" }, "pack"),
+        jobs: [{ concurrency: 1, steps: [step] }],
+    };
+    const change = {
+        _tag: "Change",
+        change: request.change,
+        pack,
+        members: members.map((member) => member.fqn),
+        execution: yield* prepareExecutionCandidate(plan),
+    };
+    return change;
+});
+const additions = Effect.fn("ChangePackMembership.additions")(function* (args) {
+    const { candidates, graph } = yield* memberCandidates();
+    const packFqn = formatFqn({
+        owner: args.packOwner,
+        type: "pack",
+        name: decodeExtensionNameSync(args.pack),
+    });
+    const targetPackProblems = graph.problems.filter((problem) => "pack" in problem && (problem.pack === packFqn || problem.pack === `workspace:${packFqn}`));
+    if (targetPackProblems.length > 0)
+        return yield* new PackGraphInvalid({ packFqn });
+    const requestedFqn = parseExtensionFqnParts(args.request.selector);
+    const matched = args.pattern
+        ? candidates.filter((candidate) => selectorMatches(args.request.selector, candidate.name))
+        : requestedFqn !== undefined
+            ? candidates.filter((candidate) => candidate.type === requestedFqn.type &&
+                candidate.owner === requestedFqn.owner &&
+                candidate.packageName === requestedFqn.name)
+            : candidates.filter((candidate) => candidate.name === args.request.selector);
+    // A bare name installed under more than one type is ambiguous: adding the
+    // wrong one would silently pin an extension the author did not mean.
+    if (!args.pattern && requestedFqn === undefined) {
+        const matchedTypes = [...new Set(matched.map((candidate) => candidate.type))];
+        if (matchedTypes.length > 1) {
+            return yield* new PackMemberAmbiguous({
+                selector: args.request.selector,
+                pack: args.pack,
+                matches: matched.map((candidate) => ({ type: candidate.type, fqn: candidate.fqn })),
+            });
+        }
+    }
+    if (matched.length === 0) {
+        if (args.pattern) {
+            return yield* new PackMemberNotFound({ selector: args.request.selector, pattern: true });
+        }
+        const installed = graph.nodes.some((node) => node.type !== "pack" && node.name === args.request.selector);
+        return yield* installed
+            ? new PackMemberUnmanaged({ selector: args.request.selector })
+            : new PackMemberNotFound({ selector: args.request.selector, pattern: false });
+    }
+    const resolved = [];
+    for (const candidate of matched) {
+        if (args.manifest.dependencies[candidate.fqn] === candidate.versionRange)
+            continue;
+        resolved.push({ fqn: candidate.fqn, range: candidate.versionRange });
+    }
+    return resolved;
+});
+const removals = Effect.fn("ChangePackMembership.removals")(function* (args) {
+    const declared = Object.keys(args.manifest.dependencies);
+    const matched = args.pattern
+        ? declared.filter((fqn) => selectorMatches(args.request.selector, fqn))
+        : declared.includes(args.request.selector)
+            ? [args.request.selector]
+            : [];
+    if (matched.length === 0) {
+        return yield* new PackMemberNotDeclared({
+            selector: args.request.selector,
+            pattern: args.pattern,
+        });
+    }
+    return matched.map((fqn) => ({ fqn, range: "" }));
+});
+/** The plan a membership change of this direction resolves. */
+export const packMembershipPlanName = (change) => change === "add" ? "Add to pack" : "Remove from pack";
+// -----------------------------------------------------------------------------
+// previewOrApply
+// -----------------------------------------------------------------------------
+/** Preview or apply a settled membership change. */
+export const previewOrApplyPackMembership = (candidate, execution) => resolveExecutionCandidate(candidate.execution, execution);
+/** The pack-membership use case: settle a request, then preview or apply it. */
+export const ChangePackMembership = {
+    prepare: preparePackMembership,
+    previewOrApply: previewOrApplyPackMembership,
+};
+//# sourceMappingURL=change-pack-membership.js.map

package/dist/src/packs/configured-pack-selector.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Which configured pack a selector names.
+ *
+ * A person edits a pack by the name their workspace configured it under, or
+ * by its owner-qualified identity. The local name wins when both could match,
+ * because that is the name the workspace itself uses.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import type { ConfiguredRecordRow } from "@agentxm/workspace-state";
+import { PackNotConfigured, PackSelectorAmbiguous, PackSelectorNotAPack } from "./membership-errors.js";
+export interface ConfiguredPackSelection {
+    readonly configuredName: string;
+    readonly entry: ConfiguredRecordRow;
+    readonly match: "local-name" | "fqn";
+}
+export interface ResolveConfiguredPackSelectorArgs {
+    readonly configured: ReadonlyArray<ConfiguredRecordRow>;
+    readonly configuredOwner?: string;
+    readonly selector: string;
+}
+export declare const resolveConfiguredPackSelector: (args: ResolveConfiguredPackSelectorArgs) => Effect.Effect<ConfiguredPackSelection, PackSelectorNotAPack | PackNotConfigured | PackSelectorAmbiguous>;
+//# sourceMappingURL=configured-pack-selector.d.ts.map

package/dist/src/packs/configured-pack-selector.js

@@ -0,0 +1,53 @@
+/**
+ * Which configured pack a selector names.
+ *
+ * A person edits a pack by the name their workspace configured it under, or
+ * by its owner-qualified identity. The local name wins when both could match,
+ * because that is the name the workspace itself uses.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import { parseRegistrySourcePatternParts, parseSourceQualifiedRegistrySourcePatternParts, } from "@agentxm/extension-model/unstable/extensions";
+import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
+import { PackNotConfigured, PackSelectorAmbiguous, PackSelectorNotAPack, } from "./membership-errors.js";
+const configuredPackFqn = (entry, configuredOwner) => {
+    if (entry.source === undefined)
+        return undefined;
+    if (entry.source === "registry" || isWorkspaceSourceLocator(entry.source)) {
+        return configuredOwner === undefined ? undefined : `${configuredOwner}/packs/${entry.name}`;
+    }
+    const parsed = parseSourceQualifiedRegistrySourcePatternParts(entry.source);
+    return parsed?.type === "packs" && parsed.name !== undefined
+        ? `${parsed.owner}/packs/${parsed.name}`
+        : undefined;
+};
+export const resolveConfiguredPackSelector = (args) => {
+    const local = args.configured.find((entry) => entry.name === args.selector);
+    if (local !== undefined) {
+        return Effect.succeed({ configuredName: local.name, entry: local, match: "local-name" });
+    }
+    const parsed = parseRegistrySourcePatternParts(args.selector);
+    if (parsed?.type !== undefined && parsed.type !== "packs") {
+        return Effect.fail(new PackSelectorNotAPack({ selector: args.selector }));
+    }
+    if (parsed?.type !== "packs" || parsed.name === undefined || parsed.versionRange !== undefined) {
+        return Effect.fail(new PackNotConfigured({ selector: args.selector }));
+    }
+    const fqn = `${parsed.owner}/packs/${parsed.name}`;
+    const matches = args.configured.filter((entry) => configuredPackFqn(entry, args.configuredOwner) === fqn);
+    const [selected, ...rest] = matches;
+    if (selected === undefined) {
+        return Effect.fail(new PackNotConfigured({ selector: args.selector }));
+    }
+    if (rest.length > 0) {
+        return Effect.fail(new PackSelectorAmbiguous({
+            selector: args.selector,
+            configuredNames: matches
+                .map((entry) => entry.name)
+                .sort((left, right) => left.localeCompare(right)),
+        }));
+    }
+    return Effect.succeed({ configuredName: selected.name, entry: selected, match: "fqn" });
+};
+//# sourceMappingURL=configured-pack-selector.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * Matching a member selector that carries a `*` wildcard.
+ *
+ * Only `*` is a wildcard; every other character, `?` and `[` included, is a
+ * literal, so an owner-qualified identity matches itself. Matching is
+ * case-sensitive.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/** Whether a selector carries a wildcard rather than naming one member. */
+export declare const isSelectorPattern: (selector: string) => boolean;
+/** Whether a selector matches this name. */
+export declare const selectorMatches: (selector: string, name: string) => boolean;
+//# sourceMappingURL=glob.d.ts.map

package/dist/src/packs/glob.js

@@ -0,0 +1,44 @@
+/**
+ * Matching a member selector that carries a `*` wildcard.
+ *
+ * Only `*` is a wildcard; every other character, `?` and `[` included, is a
+ * literal, so an owner-qualified identity matches itself. Matching is
+ * case-sensitive.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+const matches = (pattern, name) => {
+    let patternIndex = 0;
+    let nameIndex = 0;
+    let wildcardIndex = -1;
+    let wildcardNameIndex = 0;
+    while (nameIndex < name.length) {
+        const token = pattern[patternIndex];
+        if (token !== undefined && token !== "*" && token === name[nameIndex]) {
+            patternIndex += 1;
+            nameIndex += 1;
+        }
+        else if (token === "*") {
+            wildcardIndex = patternIndex;
+            wildcardNameIndex = nameIndex;
+            patternIndex += 1;
+        }
+        else if (wildcardIndex >= 0) {
+            patternIndex = wildcardIndex + 1;
+            wildcardNameIndex += 1;
+            nameIndex = wildcardNameIndex;
+        }
+        else {
+            return false;
+        }
+    }
+    while (pattern[patternIndex] === "*") {
+        patternIndex += 1;
+    }
+    return patternIndex === pattern.length;
+};
+/** Whether a selector carries a wildcard rather than naming one member. */
+export const isSelectorPattern = (selector) => selector.includes("*");
+/** Whether a selector matches this name. */
+export const selectorMatches = (selector, name) => matches(selector, name);
+//# sourceMappingURL=glob.js.map

package/dist/src/packs/membership-errors.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Typed refusals for editing an authored pack's membership.
+ *
+ * Each one carries the facts the boundary needs to name a recovery — the
+ * selector that did not resolve, the packs it matched, the types a bare name
+ * is installed as — and none of them carries rendered prose.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+declare const PackSelectorNotAPack_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackSelectorNotAPack";
+} & Readonly<A>;
+/** The selector names an extension type other than a pack. */
+export declare class PackSelectorNotAPack extends PackSelectorNotAPack_base<{
+    readonly selector: string;
+}> {
+}
+declare const PackNotConfigured_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackNotConfigured";
+} & Readonly<A>;
+/** No configured pack answers to the selector. */
+export declare class PackNotConfigured extends PackNotConfigured_base<{
+    readonly selector: string;
+}> {
+}
+declare const PackSelectorAmbiguous_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackSelectorAmbiguous";
+} & Readonly<A>;
+/** More than one configured pack answers to the same identity. */
+export declare class PackSelectorAmbiguous extends PackSelectorAmbiguous_base<{
+    readonly selector: string;
+    /** Configured local names that resolve to the selector, sorted. */
+    readonly configuredNames: ReadonlyArray<string>;
+}> {
+}
+declare const PackSourceMissing_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackSourceMissing";
+} & Readonly<A>;
+/** The configured pack declares no source, so its authorship is unknown. */
+export declare class PackSourceMissing extends PackSourceMissing_base<{
+    readonly pack: string;
+}> {
+}
+declare const PackNotAuthored_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackNotAuthored";
+} & Readonly<A>;
+/** The pack resolves to a source this workspace does not author. */
+export declare class PackNotAuthored extends PackNotAuthored_base<{
+    readonly pack: string;
+}> {
+}
+declare const PackOwnerUnconfigured_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackOwnerUnconfigured";
+} & Readonly<A>;
+/** The pack is workspace-authored but the workspace records no owner. */
+export declare class PackOwnerUnconfigured extends PackOwnerUnconfigured_base<{
+    readonly pack: string;
+    /** Workspace-relative settings file that records the owner. */
+    readonly settingsPath: string;
+}> {
+}
+declare const PackManifestUnavailable_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackManifestUnavailable";
+} & Readonly<A>;
+/** The pack manifest could not be read, parsed, or decoded. */
+export declare class PackManifestUnavailable extends PackManifestUnavailable_base<{
+    readonly path: string;
+    readonly reason: "unreadable" | "unparsable" | "invalid";
+    readonly cause: unknown;
+}> {
+}
+declare const PackGraphInvalid_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackGraphInvalid";
+} & Readonly<A>;
+/** The desired-state graph reports problems with this exact pack. */
+export declare class PackGraphInvalid extends PackGraphInvalid_base<{
+    readonly packFqn: string;
+}> {
+}
+declare const PackMemberAmbiguous_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackMemberAmbiguous";
+} & Readonly<A>;
+/** A bare member name is installed under more than one extension type. */
+export declare class PackMemberAmbiguous extends PackMemberAmbiguous_base<{
+    readonly selector: string;
+    readonly pack: string;
+    readonly matches: ReadonlyArray<{
+        readonly type: string;
+        readonly fqn: string;
+    }>;
+}> {
+}
+declare const PackMemberUnmanaged_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackMemberUnmanaged";
+} & Readonly<A>;
+/** The named extension exists in the workspace but carries no resolved version. */
+export declare class PackMemberUnmanaged extends PackMemberUnmanaged_base<{
+    readonly selector: string;
+}> {
+}
+declare const PackMemberNotFound_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackMemberNotFound";
+} & Readonly<A>;
+/** Nothing in the workspace answers to the member selector. */
+export declare class PackMemberNotFound extends PackMemberNotFound_base<{
+    readonly selector: string;
+    readonly pattern: boolean;
+}> {
+}
+declare const PackMemberNotDeclared_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackMemberNotDeclared";
+} & Readonly<A>;
+/** Nothing in the pack manifest answers to the member selector. */
+export declare class PackMemberNotDeclared extends PackMemberNotDeclared_base<{
+    readonly selector: string;
+    readonly pattern: boolean;
+}> {
+}
+/** Every refusal the pack-membership use case constructs. */
+export type PackMembershipError = PackSelectorNotAPack | PackNotConfigured | PackSelectorAmbiguous | PackSourceMissing | PackNotAuthored | PackOwnerUnconfigured | PackManifestUnavailable | PackGraphInvalid | PackMemberAmbiguous | PackMemberUnmanaged | PackMemberNotFound | PackMemberNotDeclared;
+export {};
+//# sourceMappingURL=membership-errors.d.ts.map

package/dist/src/packs/membership-errors.js

@@ -0,0 +1,47 @@
+/**
+ * Typed refusals for editing an authored pack's membership.
+ *
+ * Each one carries the facts the boundary needs to name a recovery — the
+ * selector that did not resolve, the packs it matched, the types a bare name
+ * is installed as — and none of them carries rendered prose.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Data from "effect/Data";
+/** The selector names an extension type other than a pack. */
+export class PackSelectorNotAPack extends Data.TaggedError("PackSelectorNotAPack") {
+}
+/** No configured pack answers to the selector. */
+export class PackNotConfigured extends Data.TaggedError("PackNotConfigured") {
+}
+/** More than one configured pack answers to the same identity. */
+export class PackSelectorAmbiguous extends Data.TaggedError("PackSelectorAmbiguous") {
+}
+/** The configured pack declares no source, so its authorship is unknown. */
+export class PackSourceMissing extends Data.TaggedError("PackSourceMissing") {
+}
+/** The pack resolves to a source this workspace does not author. */
+export class PackNotAuthored extends Data.TaggedError("PackNotAuthored") {
+}
+/** The pack is workspace-authored but the workspace records no owner. */
+export class PackOwnerUnconfigured extends Data.TaggedError("PackOwnerUnconfigured") {
+}
+/** The pack manifest could not be read, parsed, or decoded. */
+export class PackManifestUnavailable extends Data.TaggedError("PackManifestUnavailable") {
+}
+/** The desired-state graph reports problems with this exact pack. */
+export class PackGraphInvalid extends Data.TaggedError("PackGraphInvalid") {
+}
+/** A bare member name is installed under more than one extension type. */
+export class PackMemberAmbiguous extends Data.TaggedError("PackMemberAmbiguous") {
+}
+/** The named extension exists in the workspace but carries no resolved version. */
+export class PackMemberUnmanaged extends Data.TaggedError("PackMemberUnmanaged") {
+}
+/** Nothing in the workspace answers to the member selector. */
+export class PackMemberNotFound extends Data.TaggedError("PackMemberNotFound") {
+}
+/** Nothing in the pack manifest answers to the member selector. */
+export class PackMemberNotDeclared extends Data.TaggedError("PackMemberNotDeclared") {
+}
+//# sourceMappingURL=membership-errors.js.map

package/dist/src/packs/remove-from-pack.d.ts

@@ -7,11 +7,11 @@
  */
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
-import { AuthoringFailureAdapter } from "../failure-adapter.js";
 import type { Handle } from "@agentxm/extension-model/unstable/extensions";
 import type { OperationHandler } from "@agentxm/workspace-operations";
 import type { Operation } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { WorkspaceTransactionScope } from "@agentxm/workspace-transactions";
 /**
  * Args for the remove-from-pack operation.
  */
@@ -40,5 +40,5 @@ export type RemoveFromPackOperation = Operation<"remove-from-pack", RemoveFromPa
  * 4. Apply removals to manifest
  * 5. Write updated manifest
  */
-export declare const removeFromPack: OperationHandler<RemoveFromPackOperation, FileSystem.FileSystem | Path.Path | WorkspaceMutations | AuthoringFailureAdapter>;
+export declare const removeFromPack: OperationHandler<RemoveFromPackOperation, FileSystem.FileSystem | Path.Path | WorkspaceMutations | WorkspaceTransactionScope>;
 //# sourceMappingURL=remove-from-pack.d.ts.map

package/dist/src/packs/remove-from-pack.js

@@ -10,8 +10,9 @@ import * as Path from "effect/Path";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import { AuthoringFailed } from "../errors.js";
-import { AuthoringFailureAdapter, withAdaptedStepFailures } from "../failure-adapter.js";
+import { authoringStepFailure } from "../step-failure.js";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { WorkspaceTransactionScope, runWorkspaceTransaction, } from "@agentxm/workspace-transactions";
 import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
 import { PACK_MANIFEST_FILENAME, PackManifestSchema, } from "@agentxm/extension-model/unstable/packs/manifest-schema";
 import { packManifestArtifact } from "./artifact.js";
@@ -53,7 +54,7 @@ export const removeFromPack = (op) => Effect.gen(function* () {
     }
     // 2. Read current manifest
     const manifestPath = path.join(ws.layout.authoredRoot("pack"), packName, PACK_MANIFEST_FILENAME);
-    yield* ws.runTransaction({
+    yield* runWorkspaceTransaction({
         targets: [manifestPath],
         transition: Effect.gen(function* () {
             const manifestContent = yield* fs.readFileString(manifestPath).pipe(Effect.mapError((e) => new AuthoringFailed({
@@ -141,5 +142,5 @@ export const removeFromPack = (op) => Effect.gen(function* () {
             fileCount: 1,
         }),
     };
-}).pipe(withAdaptedStepFailures);
+}).pipe(Effect.mapError(authoringStepFailure));
 //# sourceMappingURL=remove-from-pack.js.map

package/dist/src/step-failure.d.ts

@@ -0,0 +1,31 @@
+/**
+ * How an authoring closure serializes a failure into the plan-step vocabulary.
+ *
+ * The feature owns this: an authoring step that failed must report the same
+ * category, sentence, and recovery whether the failure came from authoring's
+ * own policy, from the canonical-materialization machinery underneath it, or
+ * from the workspace transaction around it. Nothing is supplied by the
+ * application, so no authoring operation carries a failure adapter in its
+ * requirements.
+ *
+ * Categories and detail sentences are the serialized contract of machine
+ * output; they are reproduced here verbatim from the families that construct
+ * them.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { StepFailure } from "@agentxm/workspace-operations";
+import { NativeMcpEntryRetirementFailed, type ExtensionManagerFailure } from "@agentxm/extension-materialization";
+import { AuthoringFailed } from "./errors.js";
+import { type AuthoredPackageError } from "./authored-package-errors.js";
+/** Every failure an authoring closure can settle a plan step with. */
+export type AuthoringStepFailure = ExtensionManagerFailure | AuthoredPackageError | AuthoringFailed | NativeMcpEntryRetirementFailed | StepFailure;
+/**
+ * Serialize one authoring-closure failure into the plan-step vocabulary.
+ *
+ * Families this feature or the machinery beneath it constructs are rendered
+ * exactly; families the kernel already serializes are delegated to it; and
+ * anything else carries its producer's own category and sentence through.
+ */
+export declare const authoringStepFailure: (failure: AuthoringStepFailure) => StepFailure;
+//# sourceMappingURL=step-failure.d.ts.map