@agentxm/extension-authoring 0.28.11 → 0.28.13

package/dist/src/version/change-authored-version.js

@@ -0,0 +1,224 @@
+/**
+ * Changing the version an authored manifest declares.
+ *
+ * A version is one field of one manifest the workspace authors, so this use
+ * case decides three things: that the named package really is authored here,
+ * what the next version is, and that nothing else in the manifest moves. The
+ * write runs inside the workspace transaction like every other authoring
+ * change, so an interrupted or failed bump restores the manifest rather than
+ * leaving a half-written file, and the operation reports the real resolution
+ * the transaction settled with.
+ *
+ * `prepare` reads the manifest, settles `from` and `to`, and writes nothing.
+ * `previewOrApply` resolves that candidate; a bump to the version the manifest
+ * already carries settles as unchanged rather than rewriting the file.
+ *
+ * @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 * as semver from "semver";
+import { manifestFilenameForType } from "@agentxm/extension-content";
+import { extensionTypeSentenceLabels, extensionTypeToPlural, formatFqn, parseFqn, } from "@agentxm/extension-model/unstable/extensions";
+import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
+import { VersionSchema } from "@agentxm/extension-model/unstable/version-constraints";
+import { operationPresentation, prepareExecutionCandidate, resolveExecutionCandidate, } from "@agentxm/workspace-operations";
+import { WorkspaceMutations, } from "@agentxm/workspace-state";
+import { runWorkspaceTransaction, } from "@agentxm/workspace-transactions";
+import { authoredDeclaration } from "../authored-declaration.js";
+import { AuthoringFailed } from "../errors.js";
+import { AuthoringScopeUnsupported } from "../create/errors.js";
+import { authoringStepFailure } from "../step-failure.js";
+import { AuthoredManifestUnavailable, authoredManifestUnavailableCategory, authoredManifestUnavailableDetail, VersionTargetIdentityMismatch, VersionTargetInvalid, VersionTargetNotAuthored, } from "./errors.js";
+// -----------------------------------------------------------------------------
+// Manifest access
+// -----------------------------------------------------------------------------
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const decodeExactVersion = (value, manifestPath) => Schema.decodeUnknownEffect(VersionSchema)(value).pipe(Effect.mapError((cause) => new AuthoredManifestUnavailable({ manifestPath, reason: "invalid", cause })));
+/** Read one authored manifest as its raw text and its decoded object. */
+const readManifest = Effect.fn("ChangeAuthoredVersion.readManifest")(function* (args) {
+    const fs = yield* FileSystem.FileSystem;
+    const exists = yield* fs.exists(args.absolutePath).pipe(Effect.orElseSucceed(() => false));
+    if (!exists) {
+        return yield* new AuthoredManifestUnavailable({
+            manifestPath: args.manifestPath,
+            reason: "missing",
+            createCommand: args.createCommand,
+        });
+    }
+    const content = yield* fs.readFileString(args.absolutePath).pipe(Effect.mapError((cause) => new AuthoredManifestUnavailable({
+        manifestPath: args.manifestPath,
+        reason: "unreadable",
+        cause,
+    })));
+    const parsed = yield* Effect.try({
+        try: () => JSON.parse(content),
+        catch: (cause) => new AuthoredManifestUnavailable({
+            manifestPath: args.manifestPath,
+            reason: "unparsable",
+            cause,
+        }),
+    });
+    if (!isRecord(parsed)) {
+        return yield* new AuthoredManifestUnavailable({
+            manifestPath: args.manifestPath,
+            reason: "invalid",
+        });
+    }
+    return { content, manifest: Object.fromEntries(Object.entries(parsed)) };
+});
+/**
+ * The next version this request asks for.
+ *
+ * An exact version must itself be an exact version: a range like `^2.0.0`
+ * names a set of releases, and a manifest declares one.
+ */
+const nextVersion = (from, change, manifestPath) => {
+    if (change._tag === "Exact") {
+        return Schema.decodeUnknownEffect(VersionSchema)(change.version).pipe(Effect.mapError(() => new VersionTargetInvalid({
+            detail: `"${change.version}" is not an exact version`,
+            recover: "Pass an exact semver version, for example 1.2.3.",
+        })));
+    }
+    const incremented = semver.inc(from, change.rule);
+    return incremented === null
+        ? Effect.fail(new VersionTargetInvalid({
+            detail: `Version "${from}" cannot take a ${change.rule} bump`,
+        }))
+        : decodeExactVersion(incremented, manifestPath);
+};
+/**
+ * Inside the transaction the manifest is re-read, so its unavailability
+ * becomes an authoring failure the closure reports rather than a refusal the
+ * request phase settles.
+ */
+const manifestUnavailableInClosure = (failure) => new AuthoringFailed({
+    category: authoredManifestUnavailableCategory(failure),
+    detail: authoredManifestUnavailableDetail(failure),
+    ...(failure.cause === undefined ? {} : { cause: failure.cause }),
+});
+/** The plan a version change resolves. */
+export const changeAuthoredVersionPlanName = "Update extension version";
+// -----------------------------------------------------------------------------
+// prepare
+// -----------------------------------------------------------------------------
+/** Settle a version change without writing anything. */
+export const prepareChangeAuthoredVersion = Effect.fn("ChangeAuthoredVersion.prepare")(function* (request) {
+    const ws = yield* WorkspaceMutations;
+    const path = yield* Path.Path;
+    const parsed = yield* Effect.fromResult(parseFqn(request.fqn));
+    if (ws.layout.scope !== "project") {
+        return yield* new AuthoringScopeUnsupported({ subject: "version", scope: ws.layout.scope });
+    }
+    const fqn = formatFqn(parsed);
+    const subject = extensionTypeSentenceLabels[parsed.type];
+    // Only a package this workspace declares as its own may have its manifest
+    // version changed; an acquired package's version is the publisher's.
+    const declaration = authoredDeclaration(ws, parsed.type, parsed.name);
+    const configuredSource = yield* declaration.read.pipe(Effect.map((current) => current.source));
+    if (Option.isNone(configuredSource) || !isWorkspaceSourceLocator(configuredSource.value)) {
+        return yield* new VersionTargetNotAuthored({
+            fqn,
+            subject,
+            ...(Option.isNone(configuredSource) ? {} : { configuredSource: configuredSource.value }),
+        });
+    }
+    const absolutePath = path.join(ws.layout.authoredRoot(parsed.type), parsed.name, manifestFilenameForType(parsed.type));
+    const manifestPath = path.relative(ws.baseDir, absolutePath);
+    const createCommand = `axm ${extensionTypeToPlural[parsed.type]} new`;
+    const { manifest } = yield* readManifest({ absolutePath, manifestPath, createCommand });
+    if (manifest["owner"] !== parsed.owner ||
+        manifest["type"] !== parsed.type ||
+        manifest["name"] !== parsed.name) {
+        return yield* new VersionTargetIdentityMismatch({ fqn, manifestPath });
+    }
+    const from = yield* decodeExactVersion(manifest["version"], manifestPath);
+    const to = yield* nextVersion(from, request.change, manifestPath);
+    const unchanged = from === to;
+    const artifact = {
+        path: manifestPath,
+        scope: ws.scope,
+        version: to,
+        previousVersion: from,
+        change: unchanged ? "unchanged" : "updated",
+        ...(unchanged ? {} : { fileCount: 1 }),
+    };
+    const step = {
+        readiness: "ready",
+        label: fqn,
+        message: `${from} -> ${to}`,
+        artifact,
+        run: runWorkspaceTransaction({
+            targets: [absolutePath],
+            transition: Effect.gen(function* () {
+                if (unchanged)
+                    return;
+                const fs = yield* FileSystem.FileSystem;
+                // The candidate was settled against the manifest as it was read; a
+                // manifest that moved since then is a different decision, so the
+                // transaction refuses rather than overwriting the newer content.
+                const current = yield* readManifest({ absolutePath, manifestPath, createCommand }).pipe(Effect.mapError(manifestUnavailableInClosure));
+                const currentVersion = yield* decodeExactVersion(current.manifest["version"], manifestPath).pipe(Effect.mapError(manifestUnavailableInClosure));
+                if (currentVersion !== from) {
+                    return yield* new AuthoringFailed({
+                        category: "conflict",
+                        detail: `Manifest version changed to ${currentVersion} before the bump could be applied: ${manifestPath}`,
+                    });
+                }
+                const newline = current.content.endsWith("\n") ? "\n" : "";
+                yield* fs
+                    .writeFileString(absolutePath, `${JSON.stringify({ ...current.manifest, version: to }, null, 2)}${newline}`)
+                    .pipe(Effect.mapError((cause) => new AuthoringFailed({
+                    category: "internal",
+                    detail: `Failed to write manifest: ${manifestPath}`,
+                    cause,
+                })));
+            }),
+            validate: () => Effect.gen(function* () {
+                const current = yield* readManifest({ absolutePath, manifestPath, createCommand }).pipe(Effect.mapError(manifestUnavailableInClosure));
+                const currentVersion = yield* decodeExactVersion(current.manifest["version"], manifestPath).pipe(Effect.mapError(manifestUnavailableInClosure));
+                if (currentVersion !== to) {
+                    return yield* new AuthoringFailed({
+                        category: "internal",
+                        detail: `Manifest ${manifestPath} declares ${currentVersion} after the bump to ${to}`,
+                    });
+                }
+            }),
+        }).pipe(Effect.mapError(authoringStepFailure), Effect.as({
+            result: "success",
+            message: `Updated ${subject} ${fqn} ${from} -> ${to}`,
+            ...(unchanged ? { disposition: "unchanged" } : {}),
+            artifact,
+        })),
+    };
+    const plan = {
+        _tag: "Plan",
+        name: changeAuthoredVersionPlanName,
+        description: Option.some(`Set ${fqn} to ${to}`),
+        presentation: operationPresentation({ imperative: "update", past: "Updated", gerund: "Updating" }, parsed.type),
+        jobs: [{ concurrency: 1, steps: [step] }],
+    };
+    return {
+        type: parsed.type,
+        fqn,
+        manifestPath,
+        from,
+        to,
+        unchanged,
+        execution: yield* prepareExecutionCandidate(plan),
+    };
+});
+// -----------------------------------------------------------------------------
+// previewOrApply
+// -----------------------------------------------------------------------------
+/** Preview or apply a settled version change, resolving to one operation outcome. */
+export const previewOrApplyChangeAuthoredVersion = (candidate, execution) => resolveExecutionCandidate(candidate.execution, execution);
+/** The version-change use case: settle a request, then preview or apply it. */
+export const ChangeAuthoredVersion = {
+    prepare: prepareChangeAuthoredVersion,
+    previewOrApply: previewOrApplyChangeAuthoredVersion,
+};
+//# sourceMappingURL=change-authored-version.js.map

package/dist/src/version/errors.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Typed refusals a version change can settle with.
+ *
+ * Each one carries the facts a person needs to recover — the identity they
+ * named, the source the workspace records for it, the manifest that could not
+ * be read — and none carries rendered prose. The application boundary owns the
+ * sentence; the feature owns the decision.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+declare const VersionTargetNotAuthored_base: Schema.Class<VersionTargetNotAuthored, Schema.TaggedStruct<"VersionTargetNotAuthored", {
+    /** Owner-qualified identity the person named. */
+    readonly fqn: Schema.String;
+    /** Sentence-cased subject, e.g. `skill`. */
+    readonly subject: Schema.String;
+    /** The source the workspace records, when it records one. */
+    readonly configuredSource: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The named package is not one this workspace authors: either nothing
+ * declares the name, or its declaration names a source outside workspace
+ * authorship. Only an authored manifest has a version this workspace may set.
+ */
+export declare class VersionTargetNotAuthored extends VersionTargetNotAuthored_base {
+}
+declare const VersionTargetIdentityMismatch_base: Schema.Class<VersionTargetIdentityMismatch, Schema.TaggedStruct<"VersionTargetIdentityMismatch", {
+    /** Owner-qualified identity the person named. */
+    readonly fqn: Schema.String;
+    /** Path of the manifest that disagrees, relative to the workspace root. */
+    readonly manifestPath: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The authored manifest at the canonical location describes a different package. */
+export declare class VersionTargetIdentityMismatch extends VersionTargetIdentityMismatch_base {
+}
+declare const VersionTargetInvalid_base: Schema.Class<VersionTargetInvalid, Schema.TaggedStruct<"VersionTargetInvalid", {
+    readonly detail: Schema.String;
+    /** What a valid value looks like, when there is one to name. */
+    readonly recover: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** The requested target or version is not one a manifest can carry. */
+export declare class VersionTargetInvalid extends VersionTargetInvalid_base {
+}
+declare const AuthoredManifestUnavailable_base: Schema.Class<AuthoredManifestUnavailable, Schema.TaggedStruct<"AuthoredManifestUnavailable", {
+    /** Path of the manifest, relative to the workspace root. */
+    readonly manifestPath: Schema.String;
+    readonly reason: Schema.Literals<readonly ["missing", "unreadable", "unparsable", "invalid"]>;
+    /** The command that would create the package, when it is missing. */
+    readonly createCommand: Schema.optional<Schema.String>;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/** The authored manifest could not be read, parsed, or decoded. */
+export declare class AuthoredManifestUnavailable extends AuthoredManifestUnavailable_base {
+}
+/**
+ * The fact sentence an unavailable manifest reports. The producer owns it so
+ * the transaction closure and the application boundary say the same thing.
+ */
+export declare const authoredManifestUnavailableDetail: (failure: AuthoredManifestUnavailable) => string;
+/** The error category an unavailable manifest is reported under. */
+export declare const authoredManifestUnavailableCategory: (failure: AuthoredManifestUnavailable) => "internal" | "not_found" | "validation";
+/** Every typed refusal settling a version change can surface. */
+export type AuthoredVersionError = VersionTargetNotAuthored | VersionTargetIdentityMismatch | VersionTargetInvalid | AuthoredManifestUnavailable;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/version/errors.js

@@ -0,0 +1,73 @@
+/**
+ * Typed refusals a version change can settle with.
+ *
+ * Each one carries the facts a person needs to recover — the identity they
+ * named, the source the workspace records for it, the manifest that could not
+ * be read — and none carries rendered prose. The application boundary owns the
+ * sentence; the feature owns the decision.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+/**
+ * The named package is not one this workspace authors: either nothing
+ * declares the name, or its declaration names a source outside workspace
+ * authorship. Only an authored manifest has a version this workspace may set.
+ */
+export class VersionTargetNotAuthored extends Schema.TaggedError()("VersionTargetNotAuthored", {
+    /** Owner-qualified identity the person named. */
+    fqn: Schema.String,
+    /** Sentence-cased subject, e.g. `skill`. */
+    subject: Schema.String,
+    /** The source the workspace records, when it records one. */
+    configuredSource: Schema.optional(Schema.String),
+}) {
+}
+/** The authored manifest at the canonical location describes a different package. */
+export class VersionTargetIdentityMismatch extends Schema.TaggedError()("VersionTargetIdentityMismatch", {
+    /** Owner-qualified identity the person named. */
+    fqn: Schema.String,
+    /** Path of the manifest that disagrees, relative to the workspace root. */
+    manifestPath: Schema.String,
+}) {
+}
+/** The requested target or version is not one a manifest can carry. */
+export class VersionTargetInvalid extends Schema.TaggedError()("VersionTargetInvalid", {
+    detail: Schema.String,
+    /** What a valid value looks like, when there is one to name. */
+    recover: Schema.optional(Schema.String),
+}) {
+}
+/** The authored manifest could not be read, parsed, or decoded. */
+export class AuthoredManifestUnavailable extends Schema.TaggedError()("AuthoredManifestUnavailable", {
+    /** Path of the manifest, relative to the workspace root. */
+    manifestPath: Schema.String,
+    reason: Schema.Literals(["missing", "unreadable", "unparsable", "invalid"]),
+    /** The command that would create the package, when it is missing. */
+    createCommand: Schema.optional(Schema.String),
+    cause: Schema.optional(Schema.Unknown),
+}) {
+}
+/**
+ * The fact sentence an unavailable manifest reports. The producer owns it so
+ * the transaction closure and the application boundary say the same thing.
+ */
+export const authoredManifestUnavailableDetail = (failure) => {
+    switch (failure.reason) {
+        case "missing":
+            return `Manifest not found: ${failure.manifestPath}`;
+        case "unreadable":
+            return `Failed to read manifest: ${failure.manifestPath}`;
+        case "unparsable":
+            return `Invalid JSON in manifest: ${failure.manifestPath}`;
+        case "invalid":
+            return `Invalid version in manifest: ${failure.manifestPath}`;
+    }
+};
+/** The error category an unavailable manifest is reported under. */
+export const authoredManifestUnavailableCategory = (failure) => failure.reason === "missing"
+    ? "not_found"
+    : failure.reason === "unreadable"
+        ? "internal"
+        : "validation";
+//# sourceMappingURL=errors.js.map

package/package.json

@@ -4,19 +4,29 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/extension-model": "^0.28.11",
-    "@agentxm/extension-workspace": "^0.28.11",
-    "@agentxm/registry-protocol": "^0.28.11",
-    "@agentxm/workspace-operations": "^0.28.11",
-    "@agentxm/workspace-state": "^0.28.11",
+    "@agentxm/extension-content": "^0.28.13",
+    "@agentxm/extension-materialization": "^0.28.13",
+    "@agentxm/extension-model": "^0.28.13",
+    "@agentxm/extension-sources": "^0.28.13",
+    "@agentxm/registry-auth": "^0.28.13",
+    "@agentxm/registry-client": "^0.28.13",
+    "@agentxm/workspace-operations": "^0.28.13",
+    "@agentxm/workspace-projection": "^0.28.13",
+    "@agentxm/workspace-state": "^0.28.13",
+    "@agentxm/workspace-transactions": "^0.28.13",
     "effect": "4.0.0-rc.112",
+    "semver": "^7.8.5",
     "yaml": "^2.9.0"
   },
   "description": "AXM extension-authoring feature: new-extension scaffolding, fork, native import, adopt/demote identity policy, and authored pack membership for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
   "devDependencies": {
+    "@agentxm/agent-integration": "^0.28.13",
+    "@agentxm/extension-resolution": "^0.28.13",
+    "@agentxm/specification-metadata": "^0.28.13",
     "@effect/platform-node": "4.0.0-rc.112",
     "@effect/vitest": "4.0.0-rc.112",
     "@types/bun": "^1.3.14",
+    "@types/semver": "^7.7.1",
     "@typescript/native": "npm:typescript@^7.0.2",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
     "vitest": "^4.1.10"
@@ -29,6 +39,11 @@
       "axm-source": "./src/index.ts",
       "default": "./dist/src/index.js",
       "types": "./dist/src/index.d.ts"
+    },
+    "./testing": {
+      "axm-source": "./src/testing.ts",
+      "default": "./dist/src/testing.js",
+      "types": "./dist/src/testing.d.ts"
     }
   },
   "files": [
@@ -45,11 +60,11 @@
     "access": "public"
   },
   "repository": {
-    "directory": "packages/extension-authoring",
+    "directory": "packages/core/extension-authoring",
     "type": "git",
     "url": "https://github.com/agentxm/axm.git"
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.28.11"
-}
+  "version": "0.28.13"
+}

package/dist/src/desired-identity.d.ts

@@ -1,19 +0,0 @@
-import { type ExtensionName, type ExtensionType } from "@agentxm/extension-model/unstable/extensions/common";
-import type { Handle } from "@agentxm/extension-model/unstable/extensions/handle";
-export type DesiredPackageAuthority = "registry" | "workspace";
-export interface DecodedDesiredExtensionIdentity {
-    readonly authority: DesiredPackageAuthority;
-    readonly owner: Handle;
-    readonly type: ExtensionType;
-    readonly name: ExtensionName;
-    readonly fqn: string;
-}
-/**
- * Decode the source-qualified identity stored in the desired-state graph.
- *
- * This is deliberately narrower than source-locator parsing: desired graph
- * identities are either validated Registry FQNs or `workspace:` followed by a
- * validated FQN. Unknown authorities fail closed.
- */
-export declare const decodeDesiredExtensionIdentity: (identity: string) => DecodedDesiredExtensionIdentity | undefined;
-//# sourceMappingURL=desired-identity.d.ts.map

package/dist/src/desired-identity.js

@@ -1,26 +0,0 @@
-import { parseExtensionFqnParts, } from "@agentxm/extension-model/unstable/extensions/common";
-const workspacePrefix = "workspace:";
-/**
- * Decode the source-qualified identity stored in the desired-state graph.
- *
- * This is deliberately narrower than source-locator parsing: desired graph
- * identities are either validated Registry FQNs or `workspace:` followed by a
- * validated FQN. Unknown authorities fail closed.
- */
-export const decodeDesiredExtensionIdentity = (identity) => {
-    const authority = identity.startsWith(workspacePrefix)
-        ? "workspace"
-        : "registry";
-    const fqn = authority === "workspace" ? identity.slice(workspacePrefix.length) : identity;
-    const parsed = parseExtensionFqnParts(fqn);
-    if (parsed === undefined)
-        return undefined;
-    return {
-        authority,
-        owner: parsed.owner,
-        type: parsed.type,
-        name: parsed.name,
-        fqn,
-    };
-};
-//# sourceMappingURL=desired-identity.js.map

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

@@ -1,31 +0,0 @@
-/**
- * The application-supplied conversion from authoring failures to the plan
- * step vocabulary. Error rendering is application-owned: the CLI implements
- * this with the same dispatcher it uses at its output boundary, so step
- * categories and details inside authoring operations stay byte-identical
- * with rendered errors. The feature keeps only the requirement, never the
- * mapping.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as ServiceMap from "effect/Context";
-import * as Effect from "effect/Effect";
-import type { StepFailure } from "@agentxm/workspace-operations";
-export interface AuthoringFailureAdapterService {
-    /**
-     * Serialize any failure an authoring operation can surface — kernel
-     * failures and the feature's own typed failures — into the plan-step
-     * vocabulary.
-     */
-    readonly toStepFailure: (failure: unknown) => StepFailure;
-}
-declare const AuthoringFailureAdapter_base: ServiceMap.ServiceClass<AuthoringFailureAdapter, "@agentxm/extension-authoring/failure-adapter/AuthoringFailureAdapter", AuthoringFailureAdapterService>;
-export declare class AuthoringFailureAdapter extends AuthoringFailureAdapter_base {
-}
-/**
- * Serialize every failure of one authoring operation into the plan-step
- * vocabulary through the application-supplied adapter.
- */
-export declare const withAdaptedStepFailures: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, StepFailure, R | AuthoringFailureAdapter>;
-export {};
-//# sourceMappingURL=failure-adapter.d.ts.map

package/dist/src/failure-adapter.js

@@ -1,23 +0,0 @@
-/**
- * The application-supplied conversion from authoring failures to the plan
- * step vocabulary. Error rendering is application-owned: the CLI implements
- * this with the same dispatcher it uses at its output boundary, so step
- * categories and details inside authoring operations stay byte-identical
- * with rendered errors. The feature keeps only the requirement, never the
- * mapping.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as ServiceMap from "effect/Context";
-import * as Effect from "effect/Effect";
-export class AuthoringFailureAdapter extends ServiceMap.Service()("@agentxm/extension-authoring/failure-adapter/AuthoringFailureAdapter") {
-}
-/**
- * Serialize every failure of one authoring operation into the plan-step
- * vocabulary through the application-supplied adapter.
- */
-export const withAdaptedStepFailures = (effect) => Effect.gen(function* () {
-    const adapter = yield* AuthoringFailureAdapter;
-    return yield* effect.pipe(Effect.mapError((failure) => adapter.toStepFailure(failure)));
-});
-//# sourceMappingURL=failure-adapter.js.map

package/dist/src/hooks/new-hook.d.ts

@@ -1,46 +0,0 @@
-/**
- * New hook operation — scaffolds a new hook directory with the manifest and a
- * starter entrypoint.
- *
- * @experimental This API is unstable and may change without notice.
- */
-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/handle";
-import type { OperationHandler } from "@agentxm/workspace-operations";
-import type { Operation } from "@agentxm/workspace-operations";
-import { WorkspaceMutations } from "@agentxm/workspace-state";
-import { type HookEvent, type HookRuntime } from "@agentxm/extension-model/unstable/hooks/manifest-schema";
-/**
- * Args for the new-hook operation.
- */
-export interface NewHookOperationArgs {
-    /** Hook name (validated, lowercase with hyphens). */
-    readonly name: string;
-    /** Owner (e.g., "@myorg"). */
-    readonly owner: Handle;
-    /** Interpreter family for the entrypoint. */
-    readonly runtime: HookRuntime;
-    /** Canonical hook event the scaffold binds to. */
-    readonly event: HookEvent;
-    /** Optional raw matcher (only meaningful for tool.pre/tool.post). */
-    readonly matcher: string | undefined;
-}
-/**
- * Scaffold a new hook in the workspace.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export type NewHookOperation = Operation<"new-hook", NewHookOperationArgs>;
-/**
- * New-hook operation handler.
- *
- * 1. Compute managed extension directory path
- * 2. Check if the hook already exists (directory or settings entry)
- * 3. Create the managed extension + src directories
- * 4. Write hook.json manifest
- * 5. Write starter entrypoint in src/
- */
-export declare const newHook: OperationHandler<NewHookOperation, FileSystem.FileSystem | Path.Path | WorkspaceMutations | AuthoringFailureAdapter>;
-//# sourceMappingURL=new-hook.d.ts.map