@agentxm/workspace-state 0.28.4-bootstrap.0

package/dist/src/workspace/lock-entry-to-ref.js

@@ -0,0 +1,433 @@
+/**
+ * Reconstruct extension refs from lockfile entries.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import { pathToFileURL } from "node:url";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { LockEntryEndpointConflict, LockEntryNameInvalid, LockEntrySourceMissing, LockEntrySourceTypeConflict, LockEntryUrlInvalid, } from "./errors.js";
+import { decodeExtensionNameSync, } from "@agentxm/extension-model/unstable/extensions";
+const fileHref = (path) => pathToFileURL(path).href;
+const localLockEntryPath = (deps, entryPath) => deps.path.resolve(deps.baseDir, entryPath);
+const missingSource = (entryType, sourceName) => new LockEntrySourceMissing({ entryType, sourceName });
+const invalidUrl = (value) => new LockEntryUrlInvalid({ value });
+const invalidName = (name) => new LockEntryNameInvalid({ name });
+const decodeLockEntryName = (name) => Effect.try({
+    try: () => decodeExtensionNameSync(name),
+    catch: () => invalidName(name),
+});
+const hasSourceType = (sourceType) => (source) => source.type === sourceType;
+const registrySourceFromEntry = (entry, getSourceByName) => Effect.gen(function* () {
+    const configured = yield* getSourceByName(entry.sourceName);
+    if (Option.isNone(configured) || configured.value.type !== "registry") {
+        return yield* missingSource("registry", entry.sourceName);
+    }
+    if (configured.value.location.href !== entry.endpoint.href) {
+        return yield* new LockEntryEndpointConflict({
+            sourceKind: "Registry",
+            sourceName: entry.sourceName,
+            acceptedEndpoint: entry.endpoint.href,
+            resolvedEndpoint: configured.value.location.href,
+        });
+    }
+    return {
+        type: "registry",
+        name: configured.value.name,
+        location: entry.endpoint,
+        owner: Option.some(entry.owner),
+    };
+});
+function findSourceConfig(sourceType, sourceName, endpoint, getSourceByName) {
+    return Effect.gen(function* () {
+        const configured = yield* getSourceByName(sourceName);
+        if (Option.isNone(configured) || !hasSourceType(sourceType)(configured.value)) {
+            return yield* new LockEntrySourceTypeConflict({
+                sourceKind: sourceType,
+                sourceName,
+            });
+        }
+        if (configured.value.url.href !== endpoint.href) {
+            return yield* new LockEntryEndpointConflict({
+                sourceKind: sourceType,
+                sourceName,
+                acceptedEndpoint: endpoint.href,
+                resolvedEndpoint: configured.value.url.href,
+            });
+        }
+        return configured.value;
+    });
+}
+const gitBasedSourceFromEntry = (entry, getSourceByName) => {
+    switch (entry.type) {
+        case "github":
+            return Effect.map(findSourceConfig("github", entry.sourceName, entry.endpoint, getSourceByName), (source) => ({
+                type: "github",
+                name: source.name,
+                url: source.url,
+                owner: entry.owner,
+                repo: entry.repo,
+                ref: Option.fromUndefinedOr(entry.ref),
+                subPath: Option.fromUndefinedOr(entry.path),
+            }));
+        case "gitlab":
+            return Effect.map(findSourceConfig("gitlab", entry.sourceName, entry.endpoint, getSourceByName), (source) => ({
+                type: "gitlab",
+                name: source.name,
+                url: source.url,
+                owner: entry.owner,
+                repo: entry.repo,
+                ref: Option.fromUndefinedOr(entry.ref),
+                subPath: Option.fromUndefinedOr(entry.path),
+            }));
+        case "bitbucket":
+            return Effect.map(findSourceConfig("bitbucket", entry.sourceName, entry.endpoint, getSourceByName), (source) => ({
+                type: "bitbucket",
+                name: source.name,
+                url: source.url,
+                owner: entry.owner,
+                repo: entry.repo,
+                ref: Option.fromUndefinedOr(entry.ref),
+                subPath: Option.fromUndefinedOr(entry.path),
+            }));
+        case "azurerepos":
+            return Effect.map(findSourceConfig("azurerepos", entry.sourceName, entry.endpoint, getSourceByName), (source) => ({
+                type: "azurerepos",
+                name: source.name,
+                url: source.url,
+                organization: entry.organization,
+                project: entry.project,
+                repo: entry.repo,
+                ref: Option.fromUndefinedOr(entry.ref),
+                subPath: Option.fromUndefinedOr(entry.path),
+            }));
+        case "git":
+            return Effect.map(Effect.try({
+                try: () => new URL(entry.url),
+                catch: () => invalidUrl(entry.url),
+            }), (url) => ({
+                type: "git",
+                url,
+                ref: Option.fromUndefinedOr(entry.ref),
+            }));
+    }
+};
+const lockEntryLocation = (deps, entry) => {
+    const root = deps.scope === "project"
+        ? `${deps.baseDir}/agent_extensions`
+        : `${deps.baseDir}/.axm/workspace/agent_extensions`;
+    const selected = entry.path === undefined ? "" : `/${entry.path}`;
+    switch (entry.type) {
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+            return fileHref(`${root}/${entry.sourceName}/${entry.owner}/${entry.repo}${selected}`);
+        case "azurerepos":
+            return fileHref(`${root}/${entry.sourceName}/${entry.organization}/${entry.project}/${entry.repo}${selected}`);
+        case "git": {
+            const url = new URL(entry.url);
+            const repository = url.pathname.replace(/^\/+|\/+$/gu, "").replace(/\.git$/u, "");
+            return fileHref(`${root}/git/${url.hostname}/${repository}${selected}`);
+        }
+    }
+};
+export const skillLockEntryToRef = (name, entry, deps) => Effect.flatMap(decodeLockEntryName(name), (extensionName) => {
+    switch (entry.type) {
+        case "registry":
+            return Effect.map(registrySourceFromEntry(entry, deps.getConfiguredSourceByName), (source) => ({
+                type: "skill",
+                refType: "registry",
+                source,
+                owner: entry.owner,
+                publisherBindingId: entry.publisherBindingId,
+                name: entry.name,
+                version: entry.resolvedVersion,
+                integrity: entry.integrity.length > 0 ? Option.some(entry.integrity) : Option.none(),
+                packages: [],
+                skill: { name: extensionName, description: Option.none(), metadata: Option.none() },
+            }));
+        case "local": {
+            const skillSourcePath = localLockEntryPath(deps, entry.path);
+            return Effect.succeed({
+                type: "skill",
+                refType: "local",
+                ...(entry.packageOwner === undefined ? {} : { owner: entry.packageOwner }),
+                name: entry.packageName,
+                source: { type: "local", path: skillSourcePath },
+                location: fileHref(skillSourcePath),
+                sourcePath: entry.path,
+                portable: entry.packageFormat === "agent-skill",
+                skill: { name: extensionName, description: Option.none(), metadata: Option.none() },
+            });
+        }
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos":
+        case "git":
+            return Effect.map(gitBasedSourceFromEntry(entry, deps.getConfiguredSourceByName), (source) => ({
+                type: "skill",
+                refType: "git-hosted",
+                ...(entry.packageOwner === undefined ? {} : { owner: entry.packageOwner }),
+                name: entry.packageName,
+                source,
+                ...(entry.path === undefined ? {} : { sourcePath: entry.path }),
+                portable: entry.packageFormat === "agent-skill",
+                location: lockEntryLocation(deps, entry),
+                gitTreeSha: entry.resolvedTree,
+                gitCommitSha: entry.resolvedCommit,
+                skill: { name: extensionName, description: Option.none(), metadata: Option.none() },
+            }));
+    }
+});
+export const mcpServerLockEntryToRef = (name, entry, deps) => Effect.flatMap(decodeLockEntryName(name), (extensionName) => {
+    switch (entry.type) {
+        case "registry":
+            return Effect.map(registrySourceFromEntry(entry, deps.getConfiguredSourceByName), (source) => ({
+                type: "mcp-server",
+                refType: "registry",
+                source,
+                owner: entry.owner,
+                publisherBindingId: entry.publisherBindingId,
+                name: entry.name,
+                version: entry.resolvedVersion,
+                integrity: entry.integrity.length > 0 ? Option.some(entry.integrity) : Option.none(),
+                packages: [],
+                server: { name: extensionName },
+            }));
+        case "local": {
+            const mcpServerSourcePath = localLockEntryPath(deps, entry.path);
+            return Effect.succeed({
+                type: "mcp-server",
+                refType: "local",
+                owner: entry.packageOwner,
+                name: entry.packageName,
+                source: { type: "local", path: mcpServerSourcePath },
+                location: fileHref(mcpServerSourcePath),
+                sourcePath: entry.path,
+                server: { name: extensionName },
+            });
+        }
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos":
+        case "git":
+            return Effect.map(gitBasedSourceFromEntry(entry, deps.getConfiguredSourceByName), (source) => ({
+                type: "mcp-server",
+                refType: "git-hosted",
+                owner: entry.packageOwner,
+                name: entry.packageName,
+                source,
+                ...(entry.path === undefined ? {} : { sourcePath: entry.path }),
+                location: lockEntryLocation(deps, entry),
+                gitTreeSha: entry.resolvedTree,
+                gitCommitSha: entry.resolvedCommit,
+                server: { name: extensionName },
+            }));
+    }
+});
+export const subagentLockEntryToRef = (name, entry, deps) => Effect.flatMap(decodeLockEntryName(name), (extensionName) => {
+    switch (entry.type) {
+        case "registry":
+            return Effect.map(registrySourceFromEntry(entry, deps.getConfiguredSourceByName), (source) => ({
+                type: "subagent",
+                refType: "registry",
+                source,
+                owner: entry.owner,
+                publisherBindingId: entry.publisherBindingId,
+                name: entry.name,
+                version: entry.resolvedVersion,
+                integrity: entry.integrity.length > 0 ? Option.some(entry.integrity) : Option.none(),
+                packages: [],
+                subagent: { name: extensionName, description: Option.none() },
+            }));
+        case "local": {
+            const subagentSourcePath = localLockEntryPath(deps, entry.path);
+            return Effect.succeed({
+                type: "subagent",
+                refType: "local",
+                owner: entry.packageOwner,
+                name: entry.packageName,
+                source: { type: "local", path: subagentSourcePath },
+                location: fileHref(subagentSourcePath),
+                sourcePath: entry.path,
+                subagent: { name: extensionName, description: Option.none() },
+            });
+        }
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos":
+        case "git":
+            return Effect.map(gitBasedSourceFromEntry(entry, deps.getConfiguredSourceByName), (source) => ({
+                type: "subagent",
+                refType: "git-hosted",
+                owner: entry.packageOwner,
+                name: entry.packageName,
+                source,
+                ...(entry.path === undefined ? {} : { sourcePath: entry.path }),
+                location: lockEntryLocation(deps, entry),
+                gitTreeSha: entry.resolvedTree,
+                gitCommitSha: entry.resolvedCommit,
+                subagent: { name: extensionName, description: Option.none() },
+            }));
+    }
+});
+export const ruleLockEntryToRef = (name, entry, deps) => Effect.flatMap(decodeLockEntryName(name), (extensionName) => {
+    switch (entry.type) {
+        case "registry":
+            return Effect.map(registrySourceFromEntry(entry, deps.getConfiguredSourceByName), (source) => ({
+                type: "rule",
+                refType: "registry",
+                source,
+                owner: entry.owner,
+                publisherBindingId: entry.publisherBindingId,
+                name: entry.name,
+                version: entry.resolvedVersion,
+                integrity: entry.integrity.length > 0 ? Option.some(entry.integrity) : Option.none(),
+                packages: [],
+                rule: { name: extensionName },
+            }));
+        case "local": {
+            const sourcePath = localLockEntryPath(deps, entry.path);
+            return Effect.succeed({
+                type: "rule",
+                refType: "local",
+                owner: entry.packageOwner,
+                name: entry.packageName,
+                source: { type: "local", path: sourcePath },
+                location: fileHref(sourcePath),
+                sourcePath: entry.path,
+                rule: { name: extensionName },
+            });
+        }
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos":
+        case "git":
+            return Effect.map(gitBasedSourceFromEntry(entry, deps.getConfiguredSourceByName), (source) => ({
+                type: "rule",
+                refType: "git-hosted",
+                owner: entry.packageOwner,
+                name: entry.packageName,
+                source,
+                ...(entry.path === undefined ? {} : { sourcePath: entry.path }),
+                location: lockEntryLocation(deps, entry),
+                gitTreeSha: entry.resolvedTree,
+                gitCommitSha: entry.resolvedCommit,
+                rule: { name: extensionName },
+            }));
+    }
+});
+export const hookLockEntryToRef = (name, entry, deps) => Effect.flatMap(decodeLockEntryName(name), (extensionName) => {
+    switch (entry.type) {
+        case "registry":
+            return Effect.map(registrySourceFromEntry(entry, deps.getConfiguredSourceByName), (source) => ({
+                type: "hook",
+                refType: "registry",
+                source,
+                owner: entry.owner,
+                publisherBindingId: entry.publisherBindingId,
+                name: entry.name,
+                version: entry.resolvedVersion,
+                integrity: entry.integrity.length > 0 ? Option.some(entry.integrity) : Option.none(),
+                packages: [],
+                hook: { name: extensionName },
+            }));
+        case "local": {
+            const sourcePath = localLockEntryPath(deps, entry.path);
+            return Effect.succeed({
+                type: "hook",
+                refType: "local",
+                owner: entry.packageOwner,
+                name: entry.packageName,
+                source: { type: "local", path: sourcePath },
+                location: fileHref(sourcePath),
+                sourcePath: entry.path,
+                hook: { name: extensionName },
+            });
+        }
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos":
+        case "git":
+            return Effect.map(gitBasedSourceFromEntry(entry, deps.getConfiguredSourceByName), (source) => ({
+                type: "hook",
+                refType: "git-hosted",
+                owner: entry.packageOwner,
+                name: entry.packageName,
+                source,
+                ...(entry.path === undefined ? {} : { sourcePath: entry.path }),
+                location: lockEntryLocation(deps, entry),
+                gitTreeSha: entry.resolvedTree,
+                gitCommitSha: entry.resolvedCommit,
+                hook: { name: extensionName },
+            }));
+    }
+});
+export const knowledgeLockEntryToRef = (name, entry, deps) => Effect.flatMap(decodeLockEntryName(name), (extensionName) => {
+    switch (entry.type) {
+        case "registry":
+            return Effect.map(registrySourceFromEntry(entry, deps.getConfiguredSourceByName), (source) => ({
+                type: "knowledge",
+                refType: "registry",
+                source,
+                owner: entry.owner,
+                publisherBindingId: entry.publisherBindingId,
+                name: entry.name,
+                version: entry.resolvedVersion,
+                integrity: entry.integrity.length > 0 ? Option.some(entry.integrity) : Option.none(),
+                packages: [],
+                knowledge: { name: extensionName },
+            }));
+        case "local": {
+            const sourcePath = localLockEntryPath(deps, entry.path);
+            return Effect.succeed({
+                type: "knowledge",
+                refType: "local",
+                owner: entry.packageOwner,
+                name: entry.packageName,
+                source: { type: "local", path: sourcePath },
+                location: fileHref(sourcePath),
+                sourcePath: entry.path,
+                knowledge: { name: extensionName },
+            });
+        }
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos":
+        case "git":
+            return Effect.map(gitBasedSourceFromEntry(entry, deps.getConfiguredSourceByName), (source) => ({
+                type: "knowledge",
+                refType: "git-hosted",
+                owner: entry.packageOwner,
+                name: entry.packageName,
+                source,
+                ...(entry.path === undefined ? {} : { sourcePath: entry.path }),
+                location: lockEntryLocation(deps, entry),
+                gitTreeSha: entry.resolvedTree,
+                gitCommitSha: entry.resolvedCommit,
+                knowledge: { name: extensionName },
+            }));
+    }
+});
+export const packLockEntryToRef = (name, entry, deps) => Effect.flatMap(decodeLockEntryName(name), (extensionName) => {
+    return Effect.map(registrySourceFromEntry(entry, deps.getConfiguredSourceByName), (source) => ({
+        type: "pack",
+        refType: "registry",
+        source,
+        owner: entry.owner,
+        publisherBindingId: entry.publisherBindingId,
+        name: entry.name,
+        version: entry.resolvedVersion,
+        integrity: entry.integrity.length > 0 ? Option.some(entry.integrity) : Option.none(),
+        packages: [],
+        pack: { name: extensionName, dependencies: {} },
+    }));
+});
+//# sourceMappingURL=lock-entry-to-ref.js.map

package/dist/src/workspace/lock-entry-to-source-params.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Lock entry to source-params conversion and lock-locator printing.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { McpServerLockEntry, PackLockEntry, HookLockEntry, KnowledgeLockEntry, RuleLockEntry, SkillLockEntry, SubagentLockEntry } from "../lockfile/schema.js";
+import type { SourceParams } from "@agentxm/extension-model/unstable/sources/types";
+type SourceLockEntry = SkillLockEntry | McpServerLockEntry | RuleLockEntry | HookLockEntry | KnowledgeLockEntry | SubagentLockEntry | PackLockEntry;
+/**
+ * Convert a skill lock entry back to a SourceParams.
+ * Inverse of sourceToLockEntry (lock entry optional fields -> Option).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const lockEntryToSourceParams: (entry: SourceLockEntry) => SourceParams;
+/**
+ * Print the exact source locator represented by an accepted Skill resolution.
+ * Registry rows include their immutable identity and resolved version; other
+ * rows round-trip through their source-specific shorthand.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const printSkillLockSourceLocator: (_lockName: string, entry: SkillLockEntry) => string;
+export {};
+//# sourceMappingURL=lock-entry-to-source-params.d.ts.map

package/dist/src/workspace/lock-entry-to-source-params.js

@@ -0,0 +1,81 @@
+/**
+ * Lock entry to source-params conversion and lock-locator printing.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Option from "effect/Option";
+import { formatFqn } from "@agentxm/extension-model/unstable/extensions";
+import { printSourceParams } from "@agentxm/extension-model/unstable/sources/printer";
+/**
+ * Convert a skill lock entry back to a SourceParams.
+ * Inverse of sourceToLockEntry (lock entry optional fields -> Option).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const lockEntryToSourceParams = (entry) => {
+    switch (entry.type) {
+        case "github":
+            return {
+                type: "github",
+                sourceName: entry.sourceName,
+                owner: entry.owner,
+                repo: entry.repo,
+                ref: Option.fromUndefinedOr(entry.ref),
+                subPath: Option.fromUndefinedOr(entry.path),
+            };
+        case "gitlab":
+            return {
+                type: "gitlab",
+                sourceName: entry.sourceName,
+                owner: entry.owner,
+                repo: entry.repo,
+                ref: Option.fromUndefinedOr(entry.ref),
+                subPath: Option.fromUndefinedOr(entry.path),
+            };
+        case "bitbucket":
+            return {
+                type: "bitbucket",
+                sourceName: entry.sourceName,
+                owner: entry.owner,
+                repo: entry.repo,
+                ref: Option.fromUndefinedOr(entry.ref),
+                subPath: Option.fromUndefinedOr(entry.path),
+            };
+        case "azurerepos":
+            return {
+                type: "azurerepos",
+                sourceName: entry.sourceName,
+                organization: entry.organization,
+                project: entry.project,
+                repo: entry.repo,
+                ref: Option.fromUndefinedOr(entry.ref),
+                subPath: Option.fromUndefinedOr(entry.path),
+            };
+        case "git":
+            return {
+                type: "git",
+                url: new URL(entry.url),
+                ref: Option.fromUndefinedOr(entry.ref),
+            };
+        case "local":
+            return { type: "local", path: entry.path };
+        case "registry":
+            return {
+                type: "registry",
+                sourceName: entry.sourceName,
+                owner: Option.none(),
+            };
+    }
+};
+/**
+ * Print the exact source locator represented by an accepted Skill resolution.
+ * Registry rows include their immutable identity and resolved version; other
+ * rows round-trip through their source-specific shorthand.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const printSkillLockSourceLocator = (_lockName, entry) => entry.type === "registry"
+    ? `${entry.sourceName}:${formatFqn({ owner: entry.owner, type: "skill", name: entry.name })}@${entry.resolvedVersion}`
+    : printSourceParams(lockEntryToSourceParams(entry));
+//# sourceMappingURL=lock-entry-to-source-params.js.map

package/dist/src/workspace/locked-entries.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Per-type lockfile reads, keyed by catalog extension type.
+ *
+ * `WorkspaceMutationsService` exposes one `getLockedX()` accessor per type. The
+ * table here is the single place that maps a type id onto its accessor, so
+ * callers that work over the whole catalog — installed-identifier resolution,
+ * `<type> show` — stay total without a switch of their own.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type * as Effect from "effect/Effect";
+import type { CatalogExtensionType } from "@agentxm/extension-model/unstable/extension-types/schema";
+import type { HookLockEntry, KnowledgeLockEntry, KnowledgeLockMap, McpServerLockEntry, RuleLockEntry, SkillLockEntry, SubagentLockEntry } from "../lockfile/index.js";
+import type { WorkspaceLockfileReadFailure, WorkspaceMutationsService } from "./service-interface.js";
+/**
+ * Any per-type lock entry. Every arm of every lock union comes from the same
+ * factory, so narrowing to `type === "registry"` yields `owner`, `name`, and
+ * `resolvedVersion` uniformly no matter which type produced the entry.
+ */
+export type AnyLockEntry = SkillLockEntry | SubagentLockEntry | McpServerLockEntry | RuleLockEntry | HookLockEntry | KnowledgeLockEntry;
+export type AnyLockMap = {
+    readonly [name: string]: AnyLockEntry;
+};
+/** Read the whole lock map for one catalog extension type. */
+export declare const getLockedEntries: (ws: WorkspaceMutationsService, type: CatalogExtensionType) => Effect.Effect<AnyLockMap, WorkspaceLockfileReadFailure>;
+/** Read accepted external Knowledge resolutions from the workspace lockfile. */
+export declare const getKnowledgeLockEntries: (ws: WorkspaceMutationsService) => Effect.Effect<KnowledgeLockMap, WorkspaceLockfileReadFailure>;
+/** Resolved version for a lock entry, when its source arm carries one. */
+export declare const lockEntryVersion: (entry: AnyLockEntry) => string | null;
+//# sourceMappingURL=locked-entries.d.ts.map

package/dist/src/workspace/locked-entries.js

@@ -0,0 +1,34 @@
+/**
+ * Per-type lockfile reads, keyed by catalog extension type.
+ *
+ * `WorkspaceMutationsService` exposes one `getLockedX()` accessor per type. The
+ * table here is the single place that maps a type id onto its accessor, so
+ * callers that work over the whole catalog — installed-identifier resolution,
+ * `<type> show` — stay total without a switch of their own.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/**
+ * The `satisfies Record<CatalogExtensionType, …>` is load-bearing: a new
+ * catalog type fails compile here until it is wired, instead of silently
+ * resolving to an empty lock map.
+ */
+const lockedEntryReaders = {
+    skill: (ws) => ws.getLockedSkills(),
+    "mcp-server": (ws) => ws.getLockedMcpServers(),
+    subagent: (ws) => ws.getLockedSubagents(),
+    rule: (ws) => ws.getLockedRules(),
+    hook: (ws) => ws.getLockedHooks(),
+    knowledge: (ws) => ws.getLockedKnowledge(),
+};
+/** Read the whole lock map for one catalog extension type. */
+export const getLockedEntries = (ws, type) => lockedEntryReaders[type](ws);
+/** Read accepted external Knowledge resolutions from the workspace lockfile. */
+export const getKnowledgeLockEntries = (ws) => ws.getLockedKnowledge();
+/** Resolved version for a lock entry, when its source arm carries one. */
+export const lockEntryVersion = (entry) => {
+    if (entry.type === "registry")
+        return entry.resolvedVersion;
+    return null;
+};
+//# sourceMappingURL=locked-entries.js.map

package/dist/src/workspace/materialized-file-target.d.ts

@@ -0,0 +1,14 @@
+import * as Schema from "effect/Schema";
+/**
+ * Ephemeral result of one Rule or Hook projection reconciliation. This is the
+ * extensibility axis for placement and materialization mode; grammar-level
+ * changes belong to the managed-file ownership contract referenced by
+ * `projection/marker-grammar.ts`.
+ */
+export declare const MaterializedFileTargetSchema: Schema.Struct<{
+    readonly target: Schema.brand<Schema.String, "RelativePath">;
+    readonly mode: Schema.Literals<readonly ["sync-once", "sync-always", "managed-region"]>;
+    readonly region: Schema.optional<Schema.NonEmptyString>;
+}>;
+export type MaterializedFileTarget = typeof MaterializedFileTargetSchema.Type;
+//# sourceMappingURL=materialized-file-target.d.ts.map

package/dist/src/workspace/materialized-file-target.js

@@ -0,0 +1,14 @@
+import * as Schema from "effect/Schema";
+import { RelativePathSchema } from "@agentxm/extension-model/unstable/path-types";
+/**
+ * Ephemeral result of one Rule or Hook projection reconciliation. This is the
+ * extensibility axis for placement and materialization mode; grammar-level
+ * changes belong to the managed-file ownership contract referenced by
+ * `projection/marker-grammar.ts`.
+ */
+export const MaterializedFileTargetSchema = Schema.Struct({
+    target: RelativePathSchema,
+    mode: Schema.Literals(["sync-once", "sync-always", "managed-region"]),
+    region: Schema.optional(Schema.NonEmptyString),
+});
+//# sourceMappingURL=materialized-file-target.js.map

package/dist/src/workspace/materialized-tree.d.ts

@@ -0,0 +1,23 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+export declare const TreeIntegritySchema: Schema.brand<Schema.String, "TreeIntegrity">;
+export type TreeIntegrity = Schema.Schema.Type<typeof TreeIntegritySchema>;
+declare const MaterializedTreeInvalid_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: "MaterializedTreeInvalid";
+} & Readonly<A>;
+/**
+ * A materialized package tree failed strict integrity walking: unreadable,
+ * unsafe, colliding, or unsupported entries. `reason` carries the walk's fact
+ * sentence.
+ */
+export declare class MaterializedTreeInvalid extends MaterializedTreeInvalid_base<{
+    readonly root: string;
+    readonly reason: string;
+    readonly cause?: unknown;
+}> {
+}
+export declare const computeMaterializedTreeIntegrity: (root: string) => Effect.Effect<TreeIntegrity, MaterializedTreeInvalid, FileSystem.FileSystem | Path.Path>;
+export {};
+//# sourceMappingURL=materialized-tree.d.ts.map