@sweny-ai/core 0.1.63 → 0.1.65

package/dist/cli/new.js

@@ -291,7 +291,7 @@ export function detectGitRemote(cwd) {
 /**
  * Infer source-control-provider from git remote detection.
  */
-function inferSourceControl(gitInfo) {
+export function inferSourceControl(gitInfo) {
     return gitInfo?.provider ?? "github";
 }
 /**
@@ -302,7 +302,7 @@ function inferSourceControl(gitInfo) {
  * provider (yet), and `github-issues` is a sensible "use the same platform
  * as source control" default for the supported case.
  */
-function inferIssueTracker(skills, _sourceControl) {
+export function inferIssueTracker(skills, _sourceControl) {
     if (skills.includes("linear"))
         return "linear";
     if (skills.includes("jira"))
@@ -312,7 +312,7 @@ function inferIssueTracker(skills, _sourceControl) {
 /**
  * Infer observability-provider from skills in the workflow.
  */
-function inferObservability(skills) {
+export function inferObservability(skills) {
     if (skills.includes("datadog"))
         return "datadog";
     if (skills.includes("sentry"))
@@ -396,6 +396,51 @@ export function buildActionWorkflow(credentials, cronExpression) {
     lines.push("");
     return lines.join("\n");
 }
+// ── Pure write helpers (exported for marketplace install path) ────────
+/** Write .sweny.yml if missing. Returns true if created, false if file existed. */
+export function writeSwenyYmlIfMissing(cwd, sourceControl, observability, issueTracker) {
+    const configPath = path.join(cwd, ".sweny.yml");
+    if (fs.existsSync(configPath))
+        return false;
+    fs.writeFileSync(configPath, buildSwenyYml(sourceControl, observability, issueTracker), "utf-8");
+    return true;
+}
+/** Append credential keys to .env that aren't already present. Returns count appended. */
+export function appendMissingEnvKeys(cwd, credentials) {
+    const envPath = path.join(cwd, ".env");
+    if (!fs.existsSync(envPath)) {
+        fs.writeFileSync(envPath, buildEnvTemplate(credentials), "utf-8");
+        return credentials.length;
+    }
+    const existing = fs.readFileSync(envPath, "utf-8");
+    const definedKeys = new Set();
+    for (const rawLine of existing.split("\n")) {
+        const line = rawLine.trimStart().replace(/^#\s*/, "");
+        const eq = line.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = line.slice(0, eq).trim();
+        if (/^[A-Z_][A-Z0-9_]*$/i.test(key))
+            definedKeys.add(key);
+    }
+    const newKeys = credentials.filter((c) => !definedKeys.has(c.key));
+    if (newKeys.length === 0)
+        return 0;
+    fs.appendFileSync(envPath, "\n" + buildEnvTemplate(newKeys), "utf-8");
+    return newKeys.length;
+}
+/** Write workflow YAML into .sweny/workflows/<id>.yml. Returns info about what happened. */
+export function writeWorkflowFile(cwd, id, yaml, options) {
+    const dir = path.join(cwd, ".sweny", "workflows");
+    fs.mkdirSync(dir, { recursive: true });
+    const target = path.join(dir, `${id}.yml`);
+    const overwrite = options?.overwrite ?? false;
+    if (fs.existsSync(target) && !overwrite) {
+        return { written: false, exists: true, path: target };
+    }
+    fs.writeFileSync(target, yaml, "utf-8");
+    return { written: true, path: target };
+}
 // ── Interactive wizard ────────────────────────────────────────────────
 function cancel() {
     p.cancel("Setup cancelled.");
@@ -406,7 +451,8 @@ function cancel() {
  *
  * Flow:
  * 1. Detect git remote (used to infer source-control provider)
- * 2. Pick one of four branches:
+ * 2. Pick one of five branches:
+ *    - `__marketplace` → browse published workflows at swenyai/workflows, then delegate to `installMarketplaceWorkflow`
  *    - A built-in `WORKFLOW_TEMPLATES` entry → write that workflow file
  *    - `__custom` → LLM generates a workflow from a user description
  *    - `__e2e` → delegate to the e2e browser-testing wizard in `./e2e.ts`
@@ -420,8 +466,63 @@ function cancel() {
  *
  * Safe to re-run in an existing project to add additional workflows.
  */
-export async function runNew() {
+export async function runNew(options) {
     const cwd = process.cwd();
+    // ── Marketplace install fast path ───────────────────────────────────
+    if (options?.marketplaceId) {
+        const { installMarketplaceWorkflow } = await import("./marketplace.js");
+        const allSkills = configuredSkills(process.env, cwd);
+        const hasAgent = !!process.env.ANTHROPIC_API_KEY;
+        const claude = hasAgent ? new ClaudeClient({ maxTurns: 3, cwd, logger: consoleLogger }) : null;
+        if (!options.skipIntro)
+            p.intro(`Installing ${options.marketplaceId} from marketplace`);
+        // Pre-compute source-control from git-remote (same method as the wizard path).
+        // Don't pre-compute issue-tracker / observability — those are skill-based,
+        // and marketplace.ts infers them after the workflow is fetched.
+        const gitInfo = detectGitRemote(cwd);
+        const inferredSourceControl = inferSourceControl(gitInfo);
+        // Check for existing workflow file and prompt before fetching.
+        const existingWorkflowPath = path.join(cwd, ".sweny", "workflows", `${options.marketplaceId}.yml`);
+        let overwrite = false;
+        if (fs.existsSync(existingWorkflowPath)) {
+            const confirmed = await p.confirm({
+                message: `.sweny/workflows/${options.marketplaceId}.yml already exists. Overwrite?`,
+                initialValue: false,
+            });
+            if (p.isCancel(confirmed) || !confirmed) {
+                p.log.info(`Workflow already exists at ${path.relative(cwd, existingWorkflowPath)}. Not overwritten.`);
+                p.cancel("Setup cancelled.");
+                process.exit(0);
+            }
+            overwrite = true;
+        }
+        let result;
+        try {
+            result = await installMarketplaceWorkflow(options.marketplaceId, {
+                cwd,
+                availableSkills: allSkills,
+                claude,
+                logger: consoleLogger,
+                inferredSourceControl,
+                overwrite,
+            });
+        }
+        catch (err) {
+            p.log.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+        if (!result.installed) {
+            p.cancel("Setup cancelled.");
+            process.exit(0);
+        }
+        if (result.adapted)
+            p.log.success("Adapted workflow for your project");
+        if (result.addedEnvKeys > 0)
+            p.log.success(`Appended ${result.addedEnvKeys} key(s) to .env`);
+        p.log.success(`Created ${path.relative(cwd, result.workflowPath)}`);
+        p.outro("Workflow installed!");
+        return;
+    }
     // ── Fresh vs existing detection ─────────────────────────────────────
     const configPath = path.join(cwd, ".sweny.yml");
     const hasExistingConfig = fs.existsSync(configPath);
@@ -441,6 +542,11 @@ export async function runNew() {
     const templateChoice = await p.select({
         message: "What do you want to do?",
         options: [
+            {
+                value: "__marketplace",
+                label: "Browse marketplace",
+                hint: "install a published workflow from swenyai/workflows",
+            },
             ...WORKFLOW_TEMPLATES.map((t) => ({
                 value: t.id,
                 label: t.name,
@@ -453,6 +559,35 @@ export async function runNew() {
     });
     if (p.isCancel(templateChoice))
         cancel();
+    // ── Marketplace short-circuit: fetch index, pick, delegate ──────────
+    if (templateChoice === "__marketplace") {
+        const { fetchMarketplaceIndex } = await import("./marketplace.js");
+        const spinner = p.spinner();
+        spinner.start("Fetching marketplace index…");
+        let entries;
+        try {
+            entries = await fetchMarketplaceIndex();
+            spinner.stop(`Found ${entries.length} workflow(s)`);
+        }
+        catch (err) {
+            spinner.stop("Failed");
+            p.log.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+        const pick = await p.select({
+            message: "Which workflow?",
+            options: entries.map((e) => ({
+                value: e.id,
+                label: e.name,
+                hint: e.description,
+            })),
+        });
+        if (p.isCancel(pick))
+            cancel();
+        // Delegate to the marketplace install path
+        // Wizard already showed its intro — skip the fast-path intro to avoid doubling.
+        return runNew({ marketplaceId: pick, skipIntro: true });
+    }
     // ── E2E short-circuit: delegate to the e2e wizard ────────────────────
     if (templateChoice === "__e2e") {
         await runE2eInit({ skipIntro: true });
@@ -519,60 +654,30 @@ export async function runNew() {
         process.exit(0);
     }
     // ── Step 4: Write files ─────────────────────────────────────────────
-    // 1. Write .sweny.yml (only if fresh — never clobber existing config)
-    if (!hasExistingConfig) {
-        fs.writeFileSync(configPath, buildSwenyYml(sourceControl, observability, issueTracker), "utf-8");
+    // 1. Write .sweny.yml (only if fresh)
+    if (writeSwenyYmlIfMissing(cwd, sourceControl, observability, issueTracker)) {
         p.log.success("Created .sweny.yml");
     }
     else {
         p.log.info(".sweny.yml already exists — keeping existing config");
     }
-    // 2. Write .env (append-only: safe for both fresh and existing repos)
-    let addedNewKeys = false;
-    const envPath = path.join(cwd, ".env");
-    if (fs.existsSync(envPath)) {
-        const existing = fs.readFileSync(envPath, "utf-8");
-        // A key is "present" if it appears as either an active `KEY=...` line
-        // or a commented `# KEY=...` placeholder. Either way appending the same
-        // key would create a duplicate the user has to reconcile.
-        const definedKeys = new Set();
-        for (const rawLine of existing.split("\n")) {
-            const line = rawLine.trimStart().replace(/^#\s*/, "");
-            const eq = line.indexOf("=");
-            if (eq <= 0)
-                continue;
-            const key = line.slice(0, eq).trim();
-            if (/^[A-Z_][A-Z0-9_]*$/i.test(key)) {
-                definedKeys.add(key);
-            }
-        }
-        const newKeys = [];
-        for (const cred of credentials) {
-            if (!definedKeys.has(cred.key)) {
-                newKeys.push(cred);
-            }
-        }
-        if (newKeys.length > 0) {
-            const appendBlock = "\n" + buildEnvTemplate(newKeys);
-            fs.appendFileSync(envPath, appendBlock, "utf-8");
-            p.log.success(`Appended ${newKeys.length} new key(s) to .env`);
-            addedNewKeys = true;
-        }
-        else {
-            p.log.info(".env already contains all required keys — skipped");
-        }
+    // 2. Append missing .env keys
+    const envExistedBefore = fs.existsSync(path.join(cwd, ".env"));
+    const addedCount = appendMissingEnvKeys(cwd, credentials);
+    const addedNewKeys = addedCount > 0;
+    if (!envExistedBefore) {
+        p.log.success("Created .env");
+    }
+    else if (addedCount > 0) {
+        p.log.success(`Appended ${addedCount} new key(s) to .env`);
     }
     else {
-        fs.writeFileSync(envPath, buildEnvTemplate(credentials), "utf-8");
-        p.log.success("Created .env");
-        addedNewKeys = true;
+        p.log.info(".env already contains all required keys — skipped");
     }
-    // 3. Workflow template (prompt per-file if it already exists)
+    // 3. Workflow template
     if (template) {
-        const workflowDir = path.join(cwd, ".sweny", "workflows");
-        fs.mkdirSync(workflowDir, { recursive: true });
-        const templatePath = path.join(workflowDir, `${template.id}.yml`);
-        if (fs.existsSync(templatePath)) {
+        const firstAttempt = writeWorkflowFile(cwd, template.id, template.yaml, { overwrite: false });
+        if (firstAttempt.exists) {
             const overwrite = await p.confirm({
                 message: `.sweny/workflows/${template.id}.yml already exists. Overwrite?`,
                 initialValue: false,
@@ -584,8 +689,8 @@ export async function runNew() {
                 p.outro("Done.");
                 return;
             }
+            writeWorkflowFile(cwd, template.id, template.yaml, { overwrite: true });
         }
-        fs.writeFileSync(templatePath, template.yaml, "utf-8");
         p.log.success(`Created .sweny/workflows/${template.id}.yml`);
     }
     // 4. .gitignore check

package/dist/cli/new.test.js

@@ -1,9 +1,9 @@
-import { describe, it, expect, afterEach } from "vitest";
+import { describe, it, expect, afterEach, vi } from "vitest";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 import { parse as parseYaml } from "yaml";
-import { collectCredentials, collectCredentialsForSkills, extractSkillsFromYaml, detectGitRemote, buildSwenyYml, buildEnvTemplate, buildActionWorkflow, PROVIDER_CREDENTIALS, SKILL_CREDENTIALS, } from "./new.js";
+import { collectCredentials, collectCredentialsForSkills, extractSkillsFromYaml, detectGitRemote, buildSwenyYml, buildEnvTemplate, buildActionWorkflow, runNew, PROVIDER_CREDENTIALS, SKILL_CREDENTIALS, writeSwenyYmlIfMissing, appendMissingEnvKeys, writeWorkflowFile, } from "./new.js";
 // ── detectGitRemote ────────────────────────────────────────────────────
 describe("detectGitRemote", () => {
     const tmpDirs = [];
@@ -828,3 +828,216 @@ describe("SKILL_CREDENTIALS", () => {
         }
     });
 });
+describe("writeSwenyYmlIfMissing", () => {
+    const tmpDirs = [];
+    afterEach(() => {
+        for (const d of tmpDirs)
+            fs.rmSync(d, { recursive: true, force: true });
+        tmpDirs.length = 0;
+    });
+    it("creates .sweny.yml when missing", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-writer-"));
+        tmpDirs.push(dir);
+        const created = writeSwenyYmlIfMissing(dir, "github", "datadog", "github-issues");
+        expect(created).toBe(true);
+        expect(fs.existsSync(path.join(dir, ".sweny.yml"))).toBe(true);
+    });
+    it("does not overwrite existing .sweny.yml", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-writer-"));
+        tmpDirs.push(dir);
+        fs.writeFileSync(path.join(dir, ".sweny.yml"), "custom: value\n");
+        const created = writeSwenyYmlIfMissing(dir, "github", null, "github-issues");
+        expect(created).toBe(false);
+        expect(fs.readFileSync(path.join(dir, ".sweny.yml"), "utf-8")).toBe("custom: value\n");
+    });
+});
+describe("appendMissingEnvKeys", () => {
+    const tmpDirs = [];
+    afterEach(() => {
+        for (const d of tmpDirs)
+            fs.rmSync(d, { recursive: true, force: true });
+        tmpDirs.length = 0;
+    });
+    it("creates .env from scratch", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-writer-"));
+        tmpDirs.push(dir);
+        const creds = [{ key: "FOO", hint: "set FOO" }];
+        const added = appendMissingEnvKeys(dir, creds);
+        expect(added).toBe(1);
+        expect(fs.readFileSync(path.join(dir, ".env"), "utf-8")).toContain("FOO=");
+    });
+    it("skips already-present keys (including commented placeholders)", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-writer-"));
+        tmpDirs.push(dir);
+        fs.writeFileSync(path.join(dir, ".env"), "# FOO=set-me\nBAR=baz\n");
+        const creds = [{ key: "FOO" }, { key: "BAR" }, { key: "QUUX" }];
+        const added = appendMissingEnvKeys(dir, creds);
+        expect(added).toBe(1);
+        const final = fs.readFileSync(path.join(dir, ".env"), "utf-8");
+        expect(final).toContain("QUUX=");
+    });
+});
+describe("writeWorkflowFile", () => {
+    const tmpDirs = [];
+    afterEach(() => {
+        for (const d of tmpDirs)
+            fs.rmSync(d, { recursive: true, force: true });
+        tmpDirs.length = 0;
+    });
+    it("writes a new workflow file", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-writer-"));
+        tmpDirs.push(dir);
+        const result = writeWorkflowFile(dir, "pr-review", "id: pr-review\n");
+        expect(result).toEqual({ written: true, path: path.join(dir, ".sweny", "workflows", "pr-review.yml") });
+        expect(fs.existsSync(result.path)).toBe(true);
+    });
+    it("returns exists=true when file already present and overwrite=false", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-writer-"));
+        tmpDirs.push(dir);
+        fs.mkdirSync(path.join(dir, ".sweny", "workflows"), { recursive: true });
+        fs.writeFileSync(path.join(dir, ".sweny", "workflows", "pr-review.yml"), "old\n");
+        const result = writeWorkflowFile(dir, "pr-review", "new\n", { overwrite: false });
+        expect(result).toEqual({ written: false, exists: true, path: expect.any(String) });
+        expect(fs.readFileSync(result.path, "utf-8")).toBe("old\n");
+    });
+    it("overwrites when overwrite=true", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-writer-"));
+        tmpDirs.push(dir);
+        fs.mkdirSync(path.join(dir, ".sweny", "workflows"), { recursive: true });
+        fs.writeFileSync(path.join(dir, ".sweny", "workflows", "pr-review.yml"), "old\n");
+        const result = writeWorkflowFile(dir, "pr-review", "new\n", { overwrite: true });
+        expect(result).toEqual({ written: true, path: expect.any(String) });
+        expect(fs.readFileSync(result.path, "utf-8")).toBe("new\n");
+    });
+});
+vi.mock("./marketplace.js", async () => {
+    const actual = await vi.importActual("./marketplace.js");
+    return {
+        ...actual,
+        installMarketplaceWorkflow: vi.fn(),
+        fetchMarketplaceIndex: vi.fn(),
+    };
+});
+vi.mock("@clack/prompts", async () => {
+    const actual = await vi.importActual("@clack/prompts");
+    return {
+        ...actual,
+        intro: vi.fn(),
+        outro: vi.fn(),
+        cancel: vi.fn(),
+        isCancel: vi.fn(() => false),
+        select: vi.fn(),
+        confirm: vi.fn(),
+        text: vi.fn(),
+        spinner: vi.fn(() => ({ start: vi.fn(), stop: vi.fn() })),
+        log: {
+            info: vi.fn(),
+            success: vi.fn(),
+            warn: vi.fn(),
+            error: vi.fn(),
+            message: vi.fn(),
+        },
+        note: vi.fn(),
+    };
+});
+describe("runNew with marketplaceId", () => {
+    const tmpDirs = [];
+    afterEach(() => {
+        for (const d of tmpDirs)
+            fs.rmSync(d, { recursive: true, force: true });
+        tmpDirs.length = 0;
+        vi.restoreAllMocks();
+        vi.clearAllMocks();
+    });
+    function tmp() {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-new-mkt-"));
+        tmpDirs.push(dir);
+        return dir;
+    }
+    it("calls installMarketplaceWorkflow with pre-computed provider fields and overwrite:false when file absent", async () => {
+        const cwd = tmp();
+        vi.spyOn(process, "cwd").mockReturnValue(cwd);
+        const mkt = await import("./marketplace.js");
+        mkt.installMarketplaceWorkflow.mockResolvedValueOnce({
+            installed: true,
+            adapted: false,
+            workflowPath: path.join(cwd, ".sweny", "workflows", "pr-review.yml"),
+            mismatches: [],
+            addedEnvKeys: 0,
+        });
+        await runNew({ marketplaceId: "pr-review" });
+        expect(mkt.installMarketplaceWorkflow).toHaveBeenCalledWith("pr-review", expect.objectContaining({
+            cwd,
+            inferredSourceControl: expect.any(String),
+            overwrite: false,
+        }));
+        // inferredIssueTracker / inferredObservability are skill-based — runNew
+        // must NOT pre-compute them (it has no skills list), so marketplace.ts
+        // can fall back to skill-based inference after fetching the workflow.
+        const callArgs = mkt.installMarketplaceWorkflow.mock.calls[0][1];
+        expect("inferredIssueTracker" in callArgs).toBe(false);
+        expect("inferredObservability" in callArgs).toBe(false);
+    });
+    it("passes overwrite:true to installMarketplaceWorkflow when user confirms overwrite", async () => {
+        const cwd = tmp();
+        vi.spyOn(process, "cwd").mockReturnValue(cwd);
+        // Pre-create the workflow file so the exists check triggers
+        const wfDir = path.join(cwd, ".sweny", "workflows");
+        fs.mkdirSync(wfDir, { recursive: true });
+        fs.writeFileSync(path.join(wfDir, "pr-review.yml"), "# existing\n", "utf-8");
+        const mkt = await import("./marketplace.js");
+        const p = await import("@clack/prompts");
+        mkt.installMarketplaceWorkflow.mockResolvedValueOnce({
+            installed: true,
+            adapted: false,
+            workflowPath: path.join(wfDir, "pr-review.yml"),
+            mismatches: [],
+            addedEnvKeys: 0,
+        });
+        // User confirms overwrite
+        p.confirm.mockResolvedValueOnce(true);
+        await runNew({ marketplaceId: "pr-review" });
+        expect(p.confirm).toHaveBeenCalled();
+        expect(mkt.installMarketplaceWorkflow).toHaveBeenCalledWith("pr-review", expect.objectContaining({ overwrite: true }));
+    });
+    it("exits without installing when user declines overwrite for existing workflow", async () => {
+        const cwd = tmp();
+        vi.spyOn(process, "cwd").mockReturnValue(cwd);
+        // Pre-create the workflow file so the exists check triggers
+        const wfDir = path.join(cwd, ".sweny", "workflows");
+        fs.mkdirSync(wfDir, { recursive: true });
+        fs.writeFileSync(path.join(wfDir, "pr-review.yml"), "# existing\n", "utf-8");
+        const mkt = await import("./marketplace.js");
+        const p = await import("@clack/prompts");
+        // User declines overwrite
+        p.confirm.mockResolvedValueOnce(false);
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => {
+            throw new Error("process.exit called");
+        });
+        await expect(runNew({ marketplaceId: "pr-review" })).rejects.toThrow("process.exit called");
+        expect(exitSpy).toHaveBeenCalledWith(0);
+        // installMarketplaceWorkflow must NOT have been called
+        expect(mkt.installMarketplaceWorkflow).not.toHaveBeenCalled();
+    });
+});
+describe("runNew wizard — browse marketplace branch", () => {
+    afterEach(() => vi.restoreAllMocks());
+    it("fetches index and delegates to installMarketplaceWorkflow when user picks a marketplace entry", async () => {
+        const p = await import("@clack/prompts");
+        const mkt = await import("./marketplace.js");
+        p.select.mockResolvedValueOnce("__marketplace").mockResolvedValueOnce("pr-review");
+        mkt.fetchMarketplaceIndex.mockResolvedValueOnce([
+            { id: "pr-review", name: "PR Review", description: "Review PRs", skills: ["github"] },
+        ]);
+        mkt.installMarketplaceWorkflow.mockResolvedValueOnce({
+            installed: true,
+            adapted: false,
+            workflowPath: "/tmp/.sweny/workflows/pr-review.yml",
+            mismatches: [],
+            addedEnvKeys: 0,
+        });
+        await runNew();
+        expect(mkt.fetchMarketplaceIndex).toHaveBeenCalled();
+        expect(mkt.installMarketplaceWorkflow).toHaveBeenCalledWith("pr-review", expect.any(Object));
+    });
+});

package/dist/executor.js

@@ -13,7 +13,7 @@
  * This replaces ~8k lines of engine + recipe step code.
  */
 import { consoleLogger } from "./types.js";
-import { resolveSources } from "./sources.js";
+import { resolveSources } from "./source-resolver.js";
 /**
  * Execute a workflow from entry to completion.
  *

package/dist/source-resolver.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Source resolution (Node-only).
+ *
+ * Runtime helpers that read files, hash content, and fetch URLs. These are
+ * separated from `./sources.ts` so the browser-safe bits of the Source type
+ * (Zod schema, classifier, types) can be imported without pulling `node:fs`
+ * or `node:crypto` into bundlers that target the browser.
+ */
+import type { ResolvedSource, Source, SourceResolutionContext, SourceResolutionMap } from "./sources.js";
+/**
+ * Produce a stable 16-hex-char hash of `content` for use as a cache key /
+ * change-detection ID.
+ *
+ * Intentionally avoids `node:crypto` so this module can be bundled for the
+ * browser (studio SPA's in-browser simulator reaches this via the inline
+ * Source resolver). `cyrb64` is a well-known non-crypto 64-bit hash — fine
+ * for cache keys, not fine for security. Deterministic across Node and
+ * browser (both operate on UTF-16 code units).
+ */
+export declare function hashContent(content: string): string;
+export declare function resolveSource(source: Source, fieldPath: string, ctx: SourceResolutionContext): Promise<ResolvedSource>;
+export declare function resolveSources(sources: Record<string, Source>, ctx: SourceResolutionContext): Promise<SourceResolutionMap>;