@dawn-ai/core 0.1.8 → 0.2.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Dawn contributors
+Copyright (c) Brian Love
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -6,7 +6,7 @@
 
 Filesystem-based route discovery, app config loading, state-field resolution, and typegen primitives that the Dawn CLI builds on.
 
-This is an internal Dawn workspace package. For Dawn documentation, see <https://dawn-ai.org>.
+This is an internal Dawn workspace package. For Dawn documentation, see <https://github.com/cacheplane/dawnai/tree/main/apps/web/content/docs>.
 
 ## License
 

package/dist/capabilities/built-in/agents-md.d.ts

@@ -0,0 +1,9 @@
+import type { CapabilityMarker } from "../types.js";
+/**
+ * Auto-injects the contents of <process.cwd()>/workspace/AGENTS.md into the
+ * agent's system prompt under a "# Memory" heading. Always-on: the presence
+ * of the file IS the opt-in. Re-reads the file on every model turn so the
+ * agent sees its own updated memory immediately after it calls writeFile.
+ */
+export declare function createAgentsMdMarker(): CapabilityMarker;
+//# sourceMappingURL=agents-md.d.ts.map

package/dist/capabilities/built-in/agents-md.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents-md.d.ts","sourceRoot":"","sources":["../../../src/capabilities/built-in/agents-md.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AASnD;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,gBAAgB,CAWvD"}

package/dist/capabilities/built-in/agents-md.js

@@ -0,0 +1,54 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+const MAX_MEMORY_BYTES = 64 * 1024;
+const MEMORY_HEADER = `# Memory
+
+The block below is the live contents of \`workspace/AGENTS.md\`, re-read on every turn. This IS your persistent memory — do NOT re-read this file with any tool; the content here is always current. Update it by calling \`writeFile({ path: "AGENTS.md", content: "..." })\` when you learn something worth remembering.
+
+---`;
+/**
+ * Auto-injects the contents of <process.cwd()>/workspace/AGENTS.md into the
+ * agent's system prompt under a "# Memory" heading. Always-on: the presence
+ * of the file IS the opt-in. Re-reads the file on every model turn so the
+ * agent sees its own updated memory immediately after it calls writeFile.
+ */
+export function createAgentsMdMarker() {
+    return {
+        name: "agents-md",
+        detect: async (_routeDir, _context) => true,
+        load: async (_routeDir, _context) => ({
+            promptFragment: {
+                placement: "after_user_prompt",
+                render: () => renderMemoryFragment(workspaceAgentsMdPath()),
+            },
+        }),
+    };
+}
+function workspaceAgentsMdPath() {
+    return resolve(process.cwd(), "workspace", "AGENTS.md");
+}
+function renderMemoryFragment(path) {
+    if (!existsSync(path))
+        return "";
+    let size;
+    try {
+        size = statSync(path).size;
+    }
+    catch {
+        return "";
+    }
+    if (size > MAX_MEMORY_BYTES) {
+        return `${MEMORY_HEADER}\n\n(workspace/AGENTS.md is ${size} bytes; exceeds 64 KiB limit — not loaded)`;
+    }
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch {
+        return "";
+    }
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return "";
+    return `${MEMORY_HEADER}\n\n${trimmed}`;
+}

package/dist/capabilities/built-in/frontmatter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Minimal YAML-frontmatter parser. Sufficient for Dawn's skill files,
+ * which use a flat `key: value` block at the top delimited by `---` lines.
+ *
+ * Supports: keys, double-quoted values, single-quoted values, `#` comments,
+ * blank lines, CRLF endings, leading/trailing whitespace.
+ *
+ * Does NOT support: nested objects, arrays, multi-line strings, anchors,
+ * any other real YAML feature. If a skill needs full YAML, swap to the
+ * `yaml` npm package without changing this module's contract.
+ */
+export interface ParsedFrontmatter {
+    readonly frontmatter: Readonly<Record<string, string>>;
+    readonly body: string;
+}
+export declare function parseFrontmatter(input: string): ParsedFrontmatter;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/capabilities/built-in/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../../src/capabilities/built-in/frontmatter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACtD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAKD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAejE"}

package/dist/capabilities/built-in/frontmatter.js

@@ -0,0 +1,47 @@
+const OPEN_MARKER = /^---\r?\n/;
+const CLOSE_MARKER = /\r?\n---\r?\n?/;
+export function parseFrontmatter(input) {
+    if (!OPEN_MARKER.test(input)) {
+        return { frontmatter: {}, body: input };
+    }
+    const openLen = OPEN_MARKER.exec(input)?.[0].length ?? 0;
+    const afterOpen = input.slice(openLen);
+    const closeMatch = CLOSE_MARKER.exec(afterOpen);
+    if (!closeMatch) {
+        return { frontmatter: {}, body: input };
+    }
+    const block = afterOpen.slice(0, closeMatch.index);
+    const bodyStart = closeMatch.index + closeMatch[0].length;
+    const body = afterOpen.slice(bodyStart).replace(/^\r?\n/, "");
+    const frontmatter = parseFrontmatterBlock(block);
+    return { frontmatter, body };
+}
+function parseFrontmatterBlock(block) {
+    const out = {};
+    for (const rawLine of block.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (line.length === 0)
+            continue;
+        if (line.startsWith("#"))
+            continue;
+        const colonIdx = line.indexOf(":");
+        if (colonIdx < 0)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        if (key.length === 0)
+            continue;
+        const rawValue = line.slice(colonIdx + 1).trim();
+        out[key] = stripQuotes(rawValue);
+    }
+    return out;
+}
+function stripQuotes(value) {
+    if (value.length >= 2) {
+        const first = value[0];
+        const last = value[value.length - 1];
+        if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+            return value.slice(1, -1);
+        }
+    }
+    return value;
+}

package/dist/capabilities/built-in/plan-md-parser.d.ts

@@ -0,0 +1,6 @@
+export interface PlanTodo {
+    readonly content: string;
+    readonly status: "pending" | "completed";
+}
+export declare function parsePlanMarkdown(input: string): PlanTodo[];
+//# sourceMappingURL=plan-md-parser.d.ts.map

package/dist/capabilities/built-in/plan-md-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-md-parser.d.ts","sourceRoot":"","sources":["../../../src/capabilities/built-in/plan-md-parser.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,WAAW,CAAA;CACzC;AAID,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,EAAE,CAc3D"}

package/dist/capabilities/built-in/plan-md-parser.js

@@ -0,0 +1,18 @@
+const CHECKLIST_LINE = /^\s*-\s*\[([ xX])\]\s*(.*)$/;
+export function parsePlanMarkdown(input) {
+    const todos = [];
+    for (const line of input.split(/\r?\n/)) {
+        const match = CHECKLIST_LINE.exec(line);
+        if (!match)
+            continue;
+        const checkChar = match[1] ?? " ";
+        const content = (match[2] ?? "").trim();
+        if (content.length === 0)
+            continue;
+        todos.push({
+            content,
+            status: checkChar === " " ? "pending" : "completed",
+        });
+    }
+    return todos;
+}

package/dist/capabilities/built-in/planning.d.ts

@@ -0,0 +1,7 @@
+import type { CapabilityMarker } from "../types.js";
+export interface RuntimeTodo {
+    readonly content: string;
+    readonly status: "pending" | "in_progress" | "completed";
+}
+export declare function createPlanningMarker(): CapabilityMarker;
+//# sourceMappingURL=planning.d.ts.map

package/dist/capabilities/built-in/planning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planning.d.ts","sourceRoot":"","sources":["../../../src/capabilities/built-in/planning.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAqC,MAAM,aAAa,CAAA;AAMtF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,CAAA;CACzD;AAkBD,wBAAgB,oBAAoB,IAAI,gBAAgB,CAwEvD"}

package/dist/capabilities/built-in/planning.js

@@ -0,0 +1,125 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { parsePlanMarkdown } from "./plan-md-parser.js";
+const PLAN_MD = "plan.md";
+const MAX_PLAN_BYTES = 64 * 1024;
+const TODO_STATUS = z.enum(["pending", "in_progress", "completed"]);
+const WRITE_TODOS_INPUT = z.object({
+    todos: z.array(z.object({
+        content: z.string().min(1),
+        status: TODO_STATUS,
+    })),
+});
+const PLANNING_PROMPT_HEADER = `# Planning
+
+For tasks with multiple steps, maintain a plan using \`writeTodos({ todos: [...] })\`.
+Mark items \`in_progress\` immediately before working on them and \`completed\` when
+finished. Always include the full list — \`writeTodos\` is full-replace, not incremental.`;
+export function createPlanningMarker() {
+    return {
+        name: "planning",
+        detect: async (routeDir, _context) => existsSync(join(routeDir, PLAN_MD)),
+        load: async (routeDir, _context) => {
+            const seedTodos = readSeedTodos(routeDir);
+            const writeTodos = {
+                name: "writeTodos",
+                description: "Replace the agent's plan with the given list of todos. Pass the full list every time; this tool is not incremental.",
+                schema: WRITE_TODOS_INPUT,
+                run: (input) => {
+                    const validated = validateWriteTodosInput(input);
+                    return {
+                        result: { todos: validated },
+                        state: { todos: validated },
+                    };
+                },
+            };
+            const promptFragment = {
+                placement: "after_user_prompt",
+                render: (state) => {
+                    const todos = state.todos ?? [];
+                    if (todos.length === 0) {
+                        return `${PLANNING_PROMPT_HEADER}\n\nCurrent plan: (empty)`;
+                    }
+                    const lines = todos.map((t) => `- [${t.status}] ${t.content}`).join("\n");
+                    return `${PLANNING_PROMPT_HEADER}\n\nCurrent plan:\n${lines}`;
+                },
+            };
+            const streamTransformer = {
+                observes: "tool_result",
+                transform: async function* (input) {
+                    if (input.toolName !== "writeTodos")
+                        return;
+                    // toolOutput shape depends on what the tool returned:
+                    //  - Bare object `{ todos }` (legacy / direct test invocation).
+                    //  - LangGraph Command instance whose `update.todos` carries the new todos
+                    //    (the {result, state} wrapped return path goes through the langchain
+                    //    bridge and arrives here as a Command).
+                    // Read defensively from both locations; future capability authors
+                    // shouldn't have to remember which one they're in.
+                    const out = input.toolOutput;
+                    const todos = out?.update?.todos ?? out?.todos ?? [];
+                    yield {
+                        event: "plan_update",
+                        data: { todos },
+                    };
+                },
+            };
+            return {
+                tools: [writeTodos],
+                stateFields: [
+                    {
+                        name: "todos",
+                        reducer: "replace",
+                        default: seedTodos,
+                    },
+                ],
+                promptFragment,
+                streamTransformers: [streamTransformer],
+            };
+        },
+    };
+}
+function readSeedTodos(routeDir) {
+    const planPath = join(routeDir, PLAN_MD);
+    if (!existsSync(planPath))
+        return [];
+    const size = statSync(planPath).size;
+    if (size > MAX_PLAN_BYTES)
+        return [];
+    let raw;
+    try {
+        raw = readFileSync(planPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const parsed = parsePlanMarkdown(raw);
+    return parsed.map((t) => ({ content: t.content, status: t.status }));
+}
+function validateWriteTodosInput(input) {
+    if (!isRecord(input)) {
+        throw new Error("writeTodos: input must be an object with a `todos` array");
+    }
+    const todos = input.todos;
+    if (!Array.isArray(todos)) {
+        throw new Error("writeTodos: `todos` must be an array");
+    }
+    return todos.map((t, i) => {
+        if (!isRecord(t)) {
+            throw new Error(`writeTodos: todos[${i}] must be an object`);
+        }
+        const content = t.content;
+        const status = t.status;
+        if (typeof content !== "string" || content.length === 0) {
+            throw new Error(`writeTodos: todos[${i}].content must be a non-empty string`);
+        }
+        if (status !== "pending" && status !== "in_progress" && status !== "completed") {
+            throw new Error(`writeTodos: todos[${i}].status must be one of pending, in_progress, completed`);
+        }
+        return { content, status };
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/capabilities/built-in/skills.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityMarker } from "../types.js";
+export declare function createSkillsMarker(): CapabilityMarker;
+//# sourceMappingURL=skills.d.ts.map

package/dist/capabilities/built-in/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../../src/capabilities/built-in/skills.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,aAAa,CAAA;AAwBnE,wBAAgB,kBAAkB,IAAI,gBAAgB,CA2CrD"}

package/dist/capabilities/built-in/skills.js

@@ -0,0 +1,114 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { parseFrontmatter } from "./frontmatter.js";
+const SKILLS_DIR = "skills";
+const SKILL_FILE = "SKILL.md";
+// Directory name must be a valid kebab-case-ish identifier. We exclude dotfiles,
+// spaces, and other punctuation that would make a poor agent-facing name.
+const VALID_DIR_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+const SKILLS_PROMPT_HEADER = `# Skills
+
+The following skills are available. To use one, call \`readSkill({ name: "<name>" })\` to load its full instructions before acting.`;
+const READ_SKILL_INPUT = z.object({
+    name: z.string().min(1),
+});
+export function createSkillsMarker() {
+    return {
+        name: "skills",
+        detect: async (routeDir, _context) => discoverSkillDirs(routeDir).length > 0,
+        load: async (routeDir, _context) => {
+            const skills = loadSkills(routeDir);
+            const readSkill = {
+                name: "readSkill",
+                description: "Load the full instructions for a named skill.",
+                schema: READ_SKILL_INPUT,
+                run: async (input) => {
+                    const { name } = READ_SKILL_INPUT.parse(input);
+                    const found = skills.find((s) => s.name === name);
+                    if (!found) {
+                        const available = skills
+                            .map((s) => s.name)
+                            .sort()
+                            .join(", ");
+                        return `Unknown skill: ${name}. Available: ${available}`;
+                    }
+                    return found.body;
+                },
+            };
+            const promptFragment = {
+                placement: "after_user_prompt",
+                render: () => {
+                    const lines = skills
+                        .slice()
+                        .sort((a, b) => a.name.localeCompare(b.name))
+                        .map((s) => `- **${s.name}** — ${s.description}`)
+                        .join("\n");
+                    return `${SKILLS_PROMPT_HEADER}\n\n${lines}`;
+                },
+            };
+            return {
+                tools: [readSkill],
+                promptFragment,
+            };
+        },
+    };
+}
+function discoverSkillDirs(routeDir) {
+    const skillsDir = join(routeDir, SKILLS_DIR);
+    if (!existsSync(skillsDir))
+        return [];
+    let entries;
+    try {
+        entries = readdirSync(skillsDir);
+    }
+    catch {
+        return [];
+    }
+    return entries.filter((name) => {
+        if (!VALID_DIR_NAME.test(name))
+            return false;
+        const full = join(skillsDir, name);
+        let stat;
+        try {
+            stat = statSync(full);
+        }
+        catch {
+            return false;
+        }
+        if (!stat.isDirectory())
+            return false;
+        return existsSync(join(full, SKILL_FILE));
+    });
+}
+function loadSkills(routeDir) {
+    const dirNames = discoverSkillDirs(routeDir);
+    const loaded = [];
+    const seenNames = new Set();
+    for (const dirName of dirNames) {
+        const path = join(routeDir, SKILLS_DIR, dirName, SKILL_FILE);
+        let raw;
+        try {
+            raw = readFileSync(path, "utf8");
+        }
+        catch (error) {
+            throw new Error(`Failed to read ${path}: ${error.message}`);
+        }
+        const { frontmatter, body } = parseFrontmatter(raw);
+        if (Object.keys(frontmatter).length === 0) {
+            throw new Error(`${path} is missing required frontmatter. Add a YAML block at the top with at least \`description: …\`.`);
+        }
+        const description = frontmatter.description;
+        if (!description || description.length === 0) {
+            throw new Error(`${path} frontmatter is missing required \`description\` field.`);
+        }
+        const name = frontmatter.name && frontmatter.name.length > 0 ? frontmatter.name : dirName;
+        if (seenNames.has(name)) {
+            const dupPath = loaded.find((s) => s.name === name)?.path;
+            throw new Error(`Duplicate skill name "${name}" — collision between ${dupPath} and ${path}. Each skill name must be unique.`);
+        }
+        seenNames.add(name);
+        loaded.push({ name, description, body, path });
+    }
+    return loaded;
+}

package/dist/capabilities/built-in/subagents.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityMarker } from "../types.js";
+export declare function createSubagentsMarker(): CapabilityMarker;
+//# sourceMappingURL=subagents.d.ts.map

package/dist/capabilities/built-in/subagents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagents.d.ts","sourceRoot":"","sources":["../../../src/capabilities/built-in/subagents.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAA2C,MAAM,aAAa,CAAA;AAuC5F,wBAAgB,qBAAqB,IAAI,gBAAgB,CAmFxD"}

package/dist/capabilities/built-in/subagents.js

@@ -0,0 +1,99 @@
+import { pathToFileURL } from "node:url";
+import { isDawnAgent } from "@dawn-ai/sdk";
+import { z } from "zod";
+const SUBAGENTS_PROMPT_HEADER = `# Subagents
+
+The following subagents are available. Call \`task({ subagent, input })\` to dispatch a sub-task. Use the description to choose the right subagent for each piece of work.`;
+function findConventionSubagents(routeDir, routeManifest) {
+    const prefix = `${routeDir}/subagents/`;
+    return routeManifest.routes.filter((r) => {
+        if (!r.routeDir.startsWith(prefix))
+            return false;
+        // immediate child of <routeDir>/subagents/ — no further slashes
+        const tail = r.routeDir.slice(prefix.length);
+        return tail.length > 0 && !tail.includes("/");
+    });
+}
+async function loadDescription(route) {
+    try {
+        const mod = (await import(pathToFileURL(route.entryFile).href));
+        if (isDawnAgent(mod.default) && typeof mod.default.description === "string") {
+            return mod.default.description;
+        }
+    }
+    catch {
+        // fall through to default — never fail capability composition over a description
+    }
+    return "No description provided.";
+}
+export function createSubagentsMarker() {
+    return {
+        name: "subagents",
+        detect: async (routeDir, context) => {
+            if (findConventionSubagents(routeDir, context.routeManifest).length > 0)
+                return true;
+            return (context.descriptor?.subagents?.length ?? 0) > 0;
+        },
+        load: async (routeDir, context) => {
+            const conventionRoutes = findConventionSubagents(routeDir, context.routeManifest);
+            const overrideDescriptors = context.descriptor?.subagents ?? [];
+            const overrideRoutes = [];
+            for (const desc of overrideDescriptors) {
+                const routeId = context.descriptorRouteMap?.get(desc);
+                if (!routeId) {
+                    console.warn(`subagents marker: could not resolve override descriptor for route at ${routeDir}`);
+                    continue;
+                }
+                const found = context.routeManifest.routes.find((r) => r.id === routeId);
+                if (found)
+                    overrideRoutes.push(found);
+            }
+            const allRoutes = [...conventionRoutes, ...overrideRoutes];
+            if (allRoutes.length === 0)
+                return {};
+            const conventionPrefix = `${routeDir}/subagents/`;
+            const discovered = [];
+            const seen = new Set();
+            for (const r of allRoutes) {
+                const lastSegment = r.segments.at(-1);
+                const lastSegmentName = typeof lastSegment === "string"
+                    ? lastSegment
+                    : (lastSegment?.raw ?? r.id.replace(/^\//, ""));
+                const leafName = r.routeDir.startsWith(conventionPrefix)
+                    ? r.routeDir.slice(conventionPrefix.length)
+                    : lastSegmentName;
+                if (seen.has(leafName)) {
+                    throw new Error(`subagents marker: duplicate leaf name "${leafName}" (collision between convention and override). Rename one of the subagent routes.`);
+                }
+                seen.add(leafName);
+                const description = await loadDescription(r);
+                discovered.push({ leafName, routeId: r.id, description });
+            }
+            const leafNames = discovered.map((d) => d.leafName);
+            const taskSchema = z.object({
+                subagent: z.enum(leafNames),
+                input: z.string().describe("The task description for the subagent to handle."),
+            });
+            const task = {
+                name: "task",
+                description: "Dispatch a sub-task to a specialized subagent. See the # Subagents section of your system prompt for available agents and when to use each.",
+                schema: taskSchema,
+                run: async (_input) => {
+                    throw new Error("subagents marker: task tool was invoked outside the langchain bridge (dispatcher not wired)");
+                },
+            };
+            const promptFragment = {
+                placement: "after_user_prompt",
+                render: () => {
+                    const lines = discovered
+                        .slice()
+                        .sort((a, b) => a.leafName.localeCompare(b.leafName))
+                        .map((s) => `- **${s.leafName}** — ${s.description}`)
+                        .join("\n");
+                    return `${SUBAGENTS_PROMPT_HEADER}\n\n${lines}`;
+                },
+            };
+            return { tools: [task], promptFragment };
+        },
+    };
+}

package/dist/capabilities/built-in/workspace.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityMarker } from "../types.js";
+export declare function createWorkspaceMarker(): CapabilityMarker;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/capabilities/built-in/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../../src/capabilities/built-in/workspace.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAsB,MAAM,aAAa,CAAA;AAsMvE,wBAAgB,qBAAqB,IAAI,gBAAgB,CAoBxD"}