@agentxm/workspace-state 0.28.4-bootstrap.0

package/dist/src/workspace/read-model/scanners/canonical-extensions.js

@@ -0,0 +1,237 @@
+/**
+ * Canonical-extensions scanner: enumerates authored project type roots and
+ * source-qualified acquired packages beneath `agent_extensions/` or the
+ * corresponding user-scope `agent_extensions/` root.
+ *
+ * Per Decision 5 of the workspace read-model design, scanner output is
+ * occurrence-shaped. Each emitted occurrence carries the scanner-tier origin
+ * discriminator (`canonical-axm` | `external-axm`) plus the extension type;
+ * Phase 7 maps these into per-subject origin unions.
+ *
+ * Each occurrence carries structural fields the subject modules need for
+ * cross-platform path handling — `pathSegments` (the absolute path split via
+ * the `Path` service) and `subjectFile` (the canonical primary content file
+ * for the subject type, e.g., `<dir>/SKILL.md` for skills) — plus a probed
+ * `subjectFileExists` flag so subject modules do not hardcode presence.
+ *
+ * Scanner contract:
+ *
+ * - Public effect carries no `FileSystem | Path` requirement. Construction
+ *   takes a deps record and returns an `Effect<ReadonlyArray<…>>`.
+ * - Per-file partial failures (a directory we cannot enumerate) become
+ *   diagnostic warnings, not errors. The error channel stays empty.
+ * - WorkspaceMutations-root path-escape is checked at provider construction (Phase 9),
+ *   not inside the scanner.
+ *
+ * The scanner avoids `fs.stat` and uses only `fs.exists` / `fs.readDirectory`
+ * so it remains compatible with the fixture builder's in-memory `FileSystem`.
+ * "Is this a directory" is decided by whether `readDirectory` returns
+ * successfully; non-directory entries are silently ignored.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { decodeExtensionNameSync, ExtensionNameSchema, ExtensionTypeSchema, } from "@agentxm/extension-model/unstable/extensions/common";
+import { HandleSchema } from "@agentxm/extension-model/unstable/extensions/handle";
+import { MANIFEST_FILENAME_BY_TYPE } from "@agentxm/registry-protocol/unstable/publish/manifest-policy";
+import { parseSkillMd } from "@agentxm/registry-protocol/unstable/content/skill-content";
+import { DISCOVERY_SKIPPED_DIRECTORIES } from "@agentxm/extension-model/unstable/discovery-walk";
+import { makeAbsolutePath } from "@agentxm/extension-model/unstable/path-types";
+import { childEntries, fileExists, filterDirectories, splitAbsolutePathSegments, } from "./fs-helpers.js";
+const SCANNER_NAME = "canonical-extensions";
+/**
+ * Closure helper: returns the dependency-closed scanner effect.
+ */
+export const makeCanonicalExtensionsScanner = (deps) => scanCanonicalExtensions(deps);
+// ---------------------------------------------------------------------------
+// Subject file mapping
+// ---------------------------------------------------------------------------
+/**
+ * Map an extension type + name to the canonical primary content file name
+ * inside the subject's directory, when the subject has one. Subject types
+ * without a fixed primary file return `null`.
+ *
+ * - `skill` → `SKILL.md` (fixed)
+ * - `subagent` → `${name}.md` (e.g., `code-reviewer.md`)
+ */
+const subjectFileNameFor = (type, name) => {
+    switch (type) {
+        case "skill":
+            return "SKILL.md";
+        case "subagent":
+            return `${name}.md`;
+        default:
+            return null;
+    }
+};
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Build one occurrence record from a discovered subject directory. Probes
+ * the canonical subject file (e.g., `SKILL.md`) when applicable.
+ */
+const buildOccurrence = (deps, args) => Effect.gen(function* () {
+    const { fs, path, layout, diagnostics } = deps;
+    const resolvedName = args.name ?? path.basename(args.nameDir);
+    const subjectFileName = subjectFileNameFor(args.extensionType, resolvedName);
+    const subjectFile = subjectFileName === null
+        ? Option.none()
+        : Option.some(makeAbsolutePath(path, path.join(args.nameDir, subjectFileName)));
+    const subjectFileExists = Option.isSome(subjectFile)
+        ? yield* fileExists(SCANNER_NAME, fs, diagnostics, subjectFile.value)
+        : false;
+    const contentLocation = makeAbsolutePath(path, args.nameDir);
+    const occurrence = {
+        _tag: "canonical-extension",
+        scope: layout.scope,
+        type: args.extensionType,
+        origin: args.origin,
+        name: decodeExtensionNameSync(resolvedName),
+        owner: args.owner,
+        contentLocation,
+        pathSegments: splitAbsolutePathSegments(path, args.nameDir),
+        subjectFile,
+        subjectFileExists,
+    };
+    return occurrence;
+});
+const manifestFilenames = new Set(Object.values(MANIFEST_FILENAME_BY_TYPE));
+const ScannableManifestIdentitySchema = Schema.Struct({
+    owner: HandleSchema,
+    type: ExtensionTypeSchema,
+    name: ExtensionNameSchema,
+});
+const extensionTypeForManifest = (filename) => {
+    switch (filename) {
+        case "skill.json":
+            return "skill";
+        case "mcp.json":
+            return "mcp-server";
+        case "subagent.json":
+            return "subagent";
+        case "rule.json":
+            return "rule";
+        case "hook.json":
+            return "hook";
+        case "knowledge.json":
+            return "knowledge";
+        case "pack.json":
+            return "pack";
+        default:
+            return undefined;
+    }
+};
+const readNativeIdentity = (deps, dir, entries) => Effect.gen(function* () {
+    const filename = entries.find((entry) => manifestFilenames.has(entry));
+    if (filename === undefined)
+        return Option.none();
+    const filenameType = extensionTypeForManifest(filename);
+    if (filenameType === undefined)
+        return Option.none();
+    const raw = yield* deps.fs.readFileString(deps.path.join(dir, filename)).pipe(Effect.option);
+    if (Option.isNone(raw)) {
+        return Option.some({
+            type: filenameType,
+            name: decodeExtensionNameSync(deps.path.basename(dir)),
+            owner: null,
+        });
+    }
+    const identity = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(ScannableManifestIdentitySchema))(raw.value).pipe(Effect.option);
+    if (Option.isNone(identity) || MANIFEST_FILENAME_BY_TYPE[identity.value.type] !== filename) {
+        return Option.some({
+            type: filenameType,
+            name: decodeExtensionNameSync(deps.path.basename(dir)),
+            owner: null,
+        });
+    }
+    return identity;
+});
+const scanAcquiredDirectory = (deps, dir) => Effect.gen(function* () {
+    const childPaths = yield* childEntries(SCANNER_NAME, deps.fs, deps.diagnostics, deps.path, dir);
+    const entries = childPaths.map((childPath) => deps.path.basename(childPath));
+    const nativeIdentity = yield* readNativeIdentity(deps, dir, entries);
+    if (Option.isSome(nativeIdentity)) {
+        const identity = nativeIdentity.value;
+        const contentDir = identity.type === "pack" || identity.type === "mcp-server"
+            ? dir
+            : deps.path.join(dir, "src");
+        const contentDirExists = yield* deps.fs.readDirectory(contentDir).pipe(Effect.as(true), Effect.catch(() => Effect.succeed(false)));
+        if (!contentDirExists)
+            return [];
+        return [
+            yield* buildOccurrence(deps, {
+                extensionType: identity.type,
+                origin: "canonical-axm",
+                nameDir: contentDir,
+                name: identity.name,
+                owner: identity.owner,
+            }),
+        ];
+    }
+    if (entries.includes("SKILL.md")) {
+        const raw = yield* deps.fs
+            .readFileString(deps.path.join(dir, "SKILL.md"))
+            .pipe(Effect.option);
+        const parsed = Option.flatMap(raw, (content) => parseSkillMd(content, deps.path.basename(dir)));
+        if (Option.isSome(parsed)) {
+            return [
+                yield* buildOccurrence(deps, {
+                    extensionType: "skill",
+                    origin: "external-axm",
+                    nameDir: dir,
+                    name: parsed.value.name,
+                    owner: null,
+                }),
+            ];
+        }
+    }
+    const childCandidates = entries
+        .filter((entry) => !DISCOVERY_SKIPPED_DIRECTORIES.has(entry))
+        .map((entry) => deps.path.join(dir, entry));
+    const childDirs = yield* filterDirectories(deps.fs, childCandidates);
+    const nested = yield* Effect.forEach(childDirs, (childDir) => scanAcquiredDirectory(deps, childDir), { concurrency: "unbounded" });
+    return nested.flat();
+});
+const authoredTypeDirectories = [
+    { type: "skill", localDir: "skills" },
+    { type: "mcp-server", localDir: "mcps" },
+    { type: "subagent", localDir: "subagents" },
+    { type: "rule", localDir: "rules" },
+    { type: "hook", localDir: "hooks" },
+    { type: "knowledge", localDir: "knowledge" },
+    { type: "pack", localDir: "packs" },
+];
+const scanAuthoredType = (deps, extensionType) => Effect.gen(function* () {
+    if (deps.layout.scope !== "project" || deps.layout.owner === undefined)
+        return [];
+    const root = deps.layout.authoredRoot(extensionType);
+    const packageCandidates = yield* childEntries(SCANNER_NAME, deps.fs, deps.diagnostics, deps.path, root);
+    const packageDirs = yield* filterDirectories(deps.fs, packageCandidates);
+    const occurrences = yield* Effect.forEach(packageDirs, (packageDir) => {
+        const nameDir = extensionType === "pack" || extensionType === "mcp-server"
+            ? packageDir
+            : deps.path.join(packageDir, "src");
+        return deps.fs.readDirectory(nameDir).pipe(Effect.flatMap(() => buildOccurrence(deps, {
+            extensionType,
+            origin: "canonical-axm",
+            nameDir,
+            name: deps.path.basename(packageDir),
+            owner: deps.layout.scope === "project" ? (deps.layout.owner ?? null) : null,
+        })), Effect.map((occurrence) => [occurrence]), Effect.catch(() => Effect.succeed([])));
+    }, { concurrency: "unbounded" });
+    return occurrences.flat();
+});
+// ---------------------------------------------------------------------------
+// Scanner body
+// ---------------------------------------------------------------------------
+const scanCanonicalExtensions = Effect.fn("workspace.read-model.scanner.canonical-extensions")(function* (deps) {
+    const { layout } = deps;
+    const extensionsRoot = layout.acquiredRoot;
+    const acquired = yield* scanAcquiredDirectory(deps, extensionsRoot);
+    if (layout.scope !== "project")
+        return acquired;
+    const authored = yield* Effect.forEach(authoredTypeDirectories, ({ type }) => scanAuthoredType(deps, type), { concurrency: "unbounded" });
+    return [...acquired, ...authored.flat()];
+});
+//# sourceMappingURL=canonical-extensions.js.map

package/dist/src/workspace/read-model/scanners/fs-helpers.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Shared filesystem helpers used by the workspace read-model scanners.
+ *
+ * Each scanner needs the same handful of resilient `FileSystem` probes:
+ * "does this file exist", "list this directory's children", "filter to
+ * subdirectories only", and "split an absolute path by the platform
+ * separator". Before this module they were duplicated nearly verbatim across
+ * `agent-dir.ts`, `agent-settings.ts`, and `canonical-extensions.ts`, with
+ * subtle drift in their diagnostic-message prefixes and in whether
+ * `filterDirectories` accepted a `diagnostics` argument.
+ *
+ * Helpers in this module:
+ *
+ * - Take a `scannerName` so each scanner's diagnostics carry its own prefix
+ *   (`canonical-extensions:`, `agent-dir:`, etc.) — matching the call-site
+ *   strings the existing scanner tests assert on.
+ * - Return `Option<T>` from probe-style helpers (`fileExists`,
+ *   `directoryCandidate`) so callers can compose with `Array.getSomes`
+ *   instead of `null` sentinels. Boolean wrappers stay available where the
+ *   caller cares about presence directly.
+ * - Carry no `R` requirement: each helper takes `fs` / `path` / `diagnostics`
+ *   directly as arguments and the resulting `Effect` is dependency-closed.
+ */
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import type { Diagnostics } from "../diagnostics.js";
+/**
+ * Probe a path with `fs.exists`. Returns `true` when the file exists,
+ * `false` when it does not, and emits a `scanner-io` diagnostic and returns
+ * `false` when the probe itself errors.
+ */
+export declare const fileExists: (scannerName: string, fs: FileSystem.FileSystem, diagnostics: Diagnostics, filePath: string) => Effect.Effect<boolean>;
+/**
+ * Enumerate the immediate children of `parent` and return their absolute
+ * paths. When `parent` is absent, returns `[]`. When `parent` exists but
+ * cannot be enumerated, emits a `scanner-io` diagnostic and returns `[]`.
+ *
+ * Callers feed the result into `filterDirectories` to keep only
+ * subdirectories, or treat each entry as a candidate file to probe.
+ */
+export declare const childEntries: (scannerName: string, fs: FileSystem.FileSystem, diagnostics: Diagnostics, path: Path.Path, parent: string) => Effect.Effect<ReadonlyArray<string>>;
+/**
+ * Filter `candidates` down to entries that are directories. Directory
+ * detection uses a successful `readDirectory` call so the helper stays
+ * compatible with the v1 fixture builder's in-memory `FileSystem`, which
+ * does not implement `fs.stat`.
+ *
+ * Failures (file or unreadable directory) are silently dropped: an explicit
+ * warning here would fire on every regular file inside a scanned tree
+ * (`README.md`, `SKILL.md`, etc.). The shared scanner test still asserts
+ * that failing-fs cases surface warnings via the parent `readDirectory`.
+ */
+export declare const filterDirectories: (fs: FileSystem.FileSystem, candidates: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<string>>;
+/**
+ * Split an absolute path into its constituent segments using the `Path`
+ * service's platform separator. Subject modules consume the array so they do
+ * not re-parse the string with a hard-coded `/` separator. POSIX
+ * `/ws/.claude/skills/x` → `["", "ws", ".claude", "skills", "x"]`; Windows
+ * `C:\\ws\\.claude\\skills\\x` → `["C:", "ws", ".claude", "skills", "x"]`.
+ */
+export declare const splitAbsolutePathSegments: (path: Path.Path, absolute: string) => ReadonlyArray<string>;
+//# sourceMappingURL=fs-helpers.d.ts.map

package/dist/src/workspace/read-model/scanners/fs-helpers.js

@@ -0,0 +1,106 @@
+/**
+ * Shared filesystem helpers used by the workspace read-model scanners.
+ *
+ * Each scanner needs the same handful of resilient `FileSystem` probes:
+ * "does this file exist", "list this directory's children", "filter to
+ * subdirectories only", and "split an absolute path by the platform
+ * separator". Before this module they were duplicated nearly verbatim across
+ * `agent-dir.ts`, `agent-settings.ts`, and `canonical-extensions.ts`, with
+ * subtle drift in their diagnostic-message prefixes and in whether
+ * `filterDirectories` accepted a `diagnostics` argument.
+ *
+ * Helpers in this module:
+ *
+ * - Take a `scannerName` so each scanner's diagnostics carry its own prefix
+ *   (`canonical-extensions:`, `agent-dir:`, etc.) — matching the call-site
+ *   strings the existing scanner tests assert on.
+ * - Return `Option<T>` from probe-style helpers (`fileExists`,
+ *   `directoryCandidate`) so callers can compose with `Array.getSomes`
+ *   instead of `null` sentinels. Boolean wrappers stay available where the
+ *   caller cares about presence directly.
+ * - Carry no `R` requirement: each helper takes `fs` / `path` / `diagnostics`
+ *   directly as arguments and the resulting `Effect` is dependency-closed.
+ */
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+/**
+ * Probe a path with `fs.exists`. Returns `true` when the file exists,
+ * `false` when it does not, and emits a `scanner-io` diagnostic and returns
+ * `false` when the probe itself errors.
+ */
+export const fileExists = (scannerName, fs, diagnostics, filePath) => Effect.gen(function* () {
+    const exists = yield* Effect.result(fs.exists(filePath));
+    if (exists._tag === "Failure") {
+        yield* diagnostics.append({
+            source: "scanner",
+            message: `${scannerName}: cannot stat ${filePath}`,
+            path: filePath,
+            code: "scanner-io",
+        });
+        return false;
+    }
+    return exists.success;
+});
+/**
+ * Enumerate the immediate children of `parent` and return their absolute
+ * paths. When `parent` is absent, returns `[]`. When `parent` exists but
+ * cannot be enumerated, emits a `scanner-io` diagnostic and returns `[]`.
+ *
+ * Callers feed the result into `filterDirectories` to keep only
+ * subdirectories, or treat each entry as a candidate file to probe.
+ */
+export const childEntries = (scannerName, fs, diagnostics, path, parent) => Effect.gen(function* () {
+    const exists = yield* Effect.result(fs.exists(parent));
+    if (exists._tag === "Failure") {
+        yield* diagnostics.append({
+            source: "scanner",
+            message: `${scannerName}: cannot stat ${parent}`,
+            path: parent,
+            code: "scanner-io",
+        });
+        return [];
+    }
+    if (!exists.success)
+        return [];
+    const entries = yield* Effect.result(fs.readDirectory(parent));
+    if (entries._tag === "Failure") {
+        yield* diagnostics.append({
+            source: "scanner",
+            message: `${scannerName}: cannot read directory ${parent}`,
+            path: parent,
+            code: "scanner-io",
+        });
+        return [];
+    }
+    return entries.success.map((entry) => path.join(parent, entry));
+});
+/**
+ * Filter `candidates` down to entries that are directories. Directory
+ * detection uses a successful `readDirectory` call so the helper stays
+ * compatible with the v1 fixture builder's in-memory `FileSystem`, which
+ * does not implement `fs.stat`.
+ *
+ * Failures (file or unreadable directory) are silently dropped: an explicit
+ * warning here would fire on every regular file inside a scanned tree
+ * (`README.md`, `SKILL.md`, etc.). The shared scanner test still asserts
+ * that failing-fs cases surface warnings via the parent `readDirectory`.
+ */
+export const filterDirectories = (fs, candidates) => Effect.gen(function* () {
+    const checks = yield* Effect.forEach(candidates, (candidate) => Effect.gen(function* () {
+        const result = yield* Effect.result(fs.readDirectory(candidate));
+        if (result._tag === "Failure")
+            return Option.none();
+        return Option.some(candidate);
+    }), { concurrency: "unbounded" });
+    return Array.getSomes(checks);
+});
+/**
+ * Split an absolute path into its constituent segments using the `Path`
+ * service's platform separator. Subject modules consume the array so they do
+ * not re-parse the string with a hard-coded `/` separator. POSIX
+ * `/ws/.claude/skills/x` → `["", "ws", ".claude", "skills", "x"]`; Windows
+ * `C:\\ws\\.claude\\skills\\x` → `["C:", "ws", ".claude", "skills", "x"]`.
+ */
+export const splitAbsolutePathSegments = (path, absolute) => absolute.split(path.sep);
+//# sourceMappingURL=fs-helpers.js.map

package/dist/src/workspace/read-model/scanners/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Scanner barrel: re-exports every per-scanner factory and the shared
+ * occurrence-shape types from one entry point so `context.ts` can pull
+ * scanner wiring from a single module.
+ *
+ * Each scanner module owns its own deps interface, occurrence shape, and
+ * partial-failure semantics; this barrel only re-exports — no logic.
+ */
+export { makeCanonicalExtensionsScanner, type CanonicalExtensionsScannerDeps, } from "./canonical-extensions.js";
+export { makeAgentDirScanner, type AgentDirScannerDeps } from "./agent-dir.js";
+export { makeMcpConfigScanner, type McpConfigScannerDeps } from "./mcp-config.js";
+export { makeAgentSettingsScanner, type AgentSettingsScannerDeps } from "./agent-settings.js";
+export { agentRootSegment, detectAgentRootCollisions, makeAgentRootResolverState, type AgentRootResolverState, } from "./agent-root.js";
+export { dedupeByIdentity, occurrenceIdentity, occurrenceIdentityKey, type AgentDirOccurrence, type AgentDirSubjectType, type AgentSettingsOccurrence, type CanonicalExtensionOccurrence, type CanonicalExtensionOriginKind, type McpConfigOccurrence, type McpConfigSurface, type OccurrenceIdentity, type ScannerOccurrence, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/workspace/read-model/scanners/index.js

@@ -0,0 +1,34 @@
+/**
+ * Scanner barrel: re-exports every per-scanner factory and the shared
+ * occurrence-shape types from one entry point so `context.ts` can pull
+ * scanner wiring from a single module.
+ *
+ * Each scanner module owns its own deps interface, occurrence shape, and
+ * partial-failure semantics; this barrel only re-exports — no logic.
+ */
+// ---------------------------------------------------------------------------
+// Canonical-extensions scanner
+// ---------------------------------------------------------------------------
+export { makeCanonicalExtensionsScanner, } from "./canonical-extensions.js";
+// ---------------------------------------------------------------------------
+// Agent-directory scanner
+// ---------------------------------------------------------------------------
+export { makeAgentDirScanner } from "./agent-dir.js";
+// ---------------------------------------------------------------------------
+// MCP-config scanner (workspace + per-agent)
+// ---------------------------------------------------------------------------
+export { makeMcpConfigScanner } from "./mcp-config.js";
+// ---------------------------------------------------------------------------
+// Agent-settings scanner
+// ---------------------------------------------------------------------------
+export { makeAgentSettingsScanner } from "./agent-settings.js";
+// ---------------------------------------------------------------------------
+// Shared agent-root resolver used by both the agent-settings and mcp-config
+// scanners.
+// ---------------------------------------------------------------------------
+export { agentRootSegment, detectAgentRootCollisions, makeAgentRootResolverState, } from "./agent-root.js";
+// ---------------------------------------------------------------------------
+// Shared occurrence-shape types and identity helpers
+// ---------------------------------------------------------------------------
+export { dedupeByIdentity, occurrenceIdentity, occurrenceIdentityKey, } from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/src/workspace/read-model/scanners/mcp-config.d.ts

@@ -0,0 +1,47 @@
+/**
+ * MCP-config scanner: plans physical targets from the capability catalog,
+ * reads each physical file once, and emits one occurrence per declared server.
+ * Shared targets remain shared observations; agent-native targets retain the
+ * exact agent id whose private surface supplied the observation.
+ *
+ * Per-file partial failures (unreadable config, bad JSON, schema-incompatible
+ * payload) become diagnostic warnings rather than errors. The error channel
+ * stays empty.
+ *
+ * MCP config layout:
+ *
+ * ```json
+ * {
+ *   "mcpServers": {
+ *     "<server-name>": { ... }
+ *   }
+ * }
+ * ```
+ *
+ * The scanner emits one occurrence per `<server-name>` and captures each
+ * record-shaped server payload for import/adoption flows.
+ */
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import type { AgentDescriptor, AgentId } from "@agentxm/extension-model/unstable/agents/types";
+import type { Diagnostics } from "../diagnostics.js";
+import type { Scope } from "../types.js";
+import type { McpConfigOccurrence } from "./types.js";
+/**
+ * Inputs the live layer captures before invoking the scanner. The optional
+ * `agentRegistry` mirrors the agent-dir scanner.
+ */
+export interface McpConfigScannerDeps {
+    readonly fs: FileSystem.FileSystem;
+    readonly path: Path.Path;
+    readonly workspaceRoot: string;
+    readonly scope: Scope;
+    readonly diagnostics: Diagnostics;
+    readonly agentRegistry?: Readonly<Partial<Record<AgentId, AgentDescriptor>>>;
+}
+/**
+ * Closure helper: returns the dependency-closed scanner effect.
+ */
+export declare const makeMcpConfigScanner: (deps: McpConfigScannerDeps) => Effect.Effect<ReadonlyArray<McpConfigOccurrence>>;
+//# sourceMappingURL=mcp-config.d.ts.map