comisai 1.0.11 → 1.0.12

package/node_modules/@comis/core/dist/config/immutable-keys.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@comis/core/dist/config/immutable-keys.test.js

@@ -1,283 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { IMMUTABLE_CONFIG_PREFIXES, MUTABLE_CONFIG_OVERRIDES, isImmutableConfigPath, matchesOverridePattern, } from "./immutable-keys.js";
-describe("IMMUTABLE_CONFIG_PREFIXES", () => {
-    it("contains original prefixes: security, gateway.tls, gateway.tokens", () => {
-        expect(IMMUTABLE_CONFIG_PREFIXES).toContain("security");
-        expect(IMMUTABLE_CONFIG_PREFIXES).toContain("gateway.tls");
-        expect(IMMUTABLE_CONFIG_PREFIXES).toContain("gateway.tokens");
-    });
-    it("contains SHR-04 prefixes: agents, channels, gateway.host, gateway.port, integrations", () => {
-        expect(IMMUTABLE_CONFIG_PREFIXES).toContain("agents");
-        expect(IMMUTABLE_CONFIG_PREFIXES).toContain("channels");
-        expect(IMMUTABLE_CONFIG_PREFIXES).toContain("gateway.host");
-        expect(IMMUTABLE_CONFIG_PREFIXES).toContain("gateway.port");
-        expect(IMMUTABLE_CONFIG_PREFIXES).toContain("integrations");
-    });
-    it("contains CFG-07 prefixes: providers, approvals, browser.noSandbox", () => {
-        expect(IMMUTABLE_CONFIG_PREFIXES).toContain("providers");
-        expect(IMMUTABLE_CONFIG_PREFIXES).toContain("approvals");
-        expect(IMMUTABLE_CONFIG_PREFIXES).toContain("browser.noSandbox");
-    });
-    it("contains INFRA-05 prefix: daemon.logging", () => {
-        expect(IMMUTABLE_CONFIG_PREFIXES).toContain("daemon.logging");
-    });
-    it("has exactly 12 entries", () => {
-        expect(IMMUTABLE_CONFIG_PREFIXES).toHaveLength(12);
-    });
-});
-describe("isImmutableConfigPath", () => {
-    // Original prefixes (Phase 38)
-    it("rejects exact prefix match: security", () => {
-        expect(isImmutableConfigPath("security")).toBe(true);
-    });
-    it("rejects child path: security.audit.enabled", () => {
-        expect(isImmutableConfigPath("security", "audit.enabled")).toBe(true);
-    });
-    it("rejects gateway.tls child: gateway tls.certPath", () => {
-        expect(isImmutableConfigPath("gateway", "tls.certPath")).toBe(true);
-    });
-    it("rejects exact gateway.tokens: gateway tokens", () => {
-        expect(isImmutableConfigPath("gateway", "tokens")).toBe(true);
-    });
-    it("rejects gateway.tokens child: gateway tokens.0.name", () => {
-        expect(isImmutableConfigPath("gateway", "tokens.0.name")).toBe(true);
-    });
-    // SHR-04: agents (top-level section is immutable)
-    it("rejects exact agents section", () => {
-        expect(isImmutableConfigPath("agents")).toBe(true);
-    });
-    it("rejects agents child: agents default.model", () => {
-        expect(isImmutableConfigPath("agents", "default.model")).toBe(true);
-    });
-    it("rejects agents deep child: agents default.budgets.maxDailyUsd", () => {
-        expect(isImmutableConfigPath("agents", "default.budgets.maxDailyUsd")).toBe(true);
-    });
-    it("rejects agents model routes: agents default.modelRoutes.default", () => {
-        expect(isImmutableConfigPath("agents", "default.modelRoutes.default")).toBe(true);
-    });
-    // SHR-04: channels
-    it("rejects exact channels section", () => {
-        expect(isImmutableConfigPath("channels")).toBe(true);
-    });
-    it("rejects channels child: channels slack.botToken", () => {
-        expect(isImmutableConfigPath("channels", "slack.botToken")).toBe(true);
-    });
-    it("rejects channels deep child: channels discord.guildId", () => {
-        expect(isImmutableConfigPath("channels", "discord.guildId")).toBe(true);
-    });
-    // SHR-04: gateway.host
-    it("rejects gateway.host exact match", () => {
-        expect(isImmutableConfigPath("gateway", "host")).toBe(true);
-    });
-    // SHR-04: gateway.port
-    it("rejects gateway.port exact match", () => {
-        expect(isImmutableConfigPath("gateway", "port")).toBe(true);
-    });
-    // SHR-04: integrations
-    it("rejects exact integrations section", () => {
-        expect(isImmutableConfigPath("integrations")).toBe(true);
-    });
-    it("rejects integrations child: integrations github.token", () => {
-        expect(isImmutableConfigPath("integrations", "github.token")).toBe(true);
-    });
-    it("rejects integrations deep child: integrations openai.apiKey", () => {
-        expect(isImmutableConfigPath("integrations", "openai.apiKey")).toBe(true);
-    });
-    // CFG-07: providers
-    it("rejects exact providers section", () => {
-        expect(isImmutableConfigPath("providers")).toBe(true);
-    });
-    it("rejects providers child: providers entries.anthropic.apiKeyName", () => {
-        expect(isImmutableConfigPath("providers", "entries.anthropic.apiKeyName")).toBe(true);
-    });
-    // CFG-07: approvals
-    it("rejects exact approvals section", () => {
-        expect(isImmutableConfigPath("approvals")).toBe(true);
-    });
-    it("rejects approvals child: approvals rules", () => {
-        expect(isImmutableConfigPath("approvals", "rules")).toBe(true);
-    });
-    it("rejects approvals deep child: approvals defaultMode", () => {
-        expect(isImmutableConfigPath("approvals", "defaultMode")).toBe(true);
-    });
-    // CFG-07: browser.noSandbox
-    it("rejects browser.noSandbox exact match", () => {
-        expect(isImmutableConfigPath("browser", "noSandbox")).toBe(true);
-    });
-    // INFRA-05: daemon.logging
-    it("rejects daemon.logging exact match", () => {
-        expect(isImmutableConfigPath("daemon", "logging")).toBe(true);
-    });
-    it("rejects daemon.logging.filePath child", () => {
-        expect(isImmutableConfigPath("daemon", "logging.filePath")).toBe(true);
-    });
-    it("rejects daemon.logging.maxSize child", () => {
-        expect(isImmutableConfigPath("daemon", "logging.maxSize")).toBe(true);
-    });
-    it("rejects daemon.logging.maxFiles child", () => {
-        expect(isImmutableConfigPath("daemon", "logging.maxFiles")).toBe(true);
-    });
-    it("rejects daemon.logging.compress child", () => {
-        expect(isImmutableConfigPath("daemon", "logging.compress")).toBe(true);
-    });
-    it("allows daemon top-level (not immutable)", () => {
-        expect(isImmutableConfigPath("daemon")).toBe(false);
-    });
-    it("allows daemon.watchdogIntervalMs (not logging)", () => {
-        expect(isImmutableConfigPath("daemon", "watchdogIntervalMs")).toBe(false);
-    });
-    it("allows daemon.logLevels (mutable at runtime, not file logging)", () => {
-        expect(isImmutableConfigPath("daemon", "logLevels")).toBe(false);
-    });
-    // CFG-07: Mutable paths (not immutable)
-    it("allows browser section (top-level)", () => {
-        expect(isImmutableConfigPath("browser")).toBe(false);
-    });
-    it("allows browser.headless (mutable at runtime)", () => {
-        expect(isImmutableConfigPath("browser", "headless")).toBe(false);
-    });
-    it("allows browser.viewport.width (mutable at runtime)", () => {
-        expect(isImmutableConfigPath("browser", "viewport.width")).toBe(false);
-    });
-    it("allows models section (mutable at runtime)", () => {
-        expect(isImmutableConfigPath("models")).toBe(false);
-    });
-    it("allows models.aliases (mutable at runtime)", () => {
-        expect(isImmutableConfigPath("models", "aliases")).toBe(false);
-    });
-    it("allows messages section (mutable at runtime)", () => {
-        expect(isImmutableConfigPath("messages")).toBe(false);
-    });
-    it("allows messages.splitMaxChars (mutable at runtime)", () => {
-        expect(isImmutableConfigPath("messages", "splitMaxChars")).toBe(false);
-    });
-    // Non-immutable paths
-    it("allows scheduler section", () => {
-        expect(isImmutableConfigPath("scheduler")).toBe(false);
-    });
-    it("allows memory section (top-level)", () => {
-        expect(isImmutableConfigPath("memory")).toBe(false);
-    });
-    it("allows memory key: memory maxEntries", () => {
-        expect(isImmutableConfigPath("memory", "maxEntries")).toBe(false);
-    });
-    it("allows gateway non-sensitive key: gateway maxBatchSize", () => {
-        expect(isImmutableConfigPath("gateway", "maxBatchSize")).toBe(false);
-    });
-    it("allows gateway non-sensitive key: gateway rateLimit.maxRequests", () => {
-        expect(isImmutableConfigPath("gateway", "rateLimit.maxRequests")).toBe(false);
-    });
-    // Partial prefix protection
-    it("does not match partial prefix: securityExtra", () => {
-        expect(isImmutableConfigPath("securityExtra")).toBe(false);
-    });
-    it("does not match partial prefix with key: securityExtra foo", () => {
-        expect(isImmutableConfigPath("securityExtra", "foo")).toBe(false);
-    });
-    it("does not match partial prefix: channelsExtra", () => {
-        expect(isImmutableConfigPath("channelsExtra")).toBe(false);
-    });
-    it("does not match partial prefix: integrationsExtra", () => {
-        expect(isImmutableConfigPath("integrationsExtra")).toBe(false);
-    });
-    // Mutable overrides: operational agent settings
-    it("allows agents.default.skills.watchEnabled (mutable override)", () => {
-        expect(isImmutableConfigPath("agents", "default.skills.watchEnabled")).toBe(false);
-    });
-    it("allows agents.default.skills.watchDebounceMs (mutable override)", () => {
-        expect(isImmutableConfigPath("agents", "default.skills.watchDebounceMs")).toBe(false);
-    });
-    it("allows agents.default.skills.discoveryPaths (mutable override)", () => {
-        expect(isImmutableConfigPath("agents", "default.skills.discoveryPaths")).toBe(false);
-    });
-    it("allows agents.default.maxSteps (mutable override)", () => {
-        expect(isImmutableConfigPath("agents", "default.maxSteps")).toBe(false);
-    });
-    it("allows agents.default.persona (mutable override)", () => {
-        expect(isImmutableConfigPath("agents", "default.persona")).toBe(false);
-    });
-    it("allows agents.default.persona.name (child of mutable override)", () => {
-        expect(isImmutableConfigPath("agents", "default.persona.name")).toBe(false);
-    });
-    it("allows agents.default.persona.tone (child of mutable override)", () => {
-        expect(isImmutableConfigPath("agents", "default.persona.tone")).toBe(false);
-    });
-    // Mutable overrides: promptTimeout runtime tuning
-    it("allows agents.*.promptTimeout.promptTimeoutMs (mutable override for timeout tuning)", () => {
-        expect(isImmutableConfigPath("agents", "default.promptTimeout.promptTimeoutMs")).toBe(false);
-    });
-    it("allows agents.*.promptTimeout.retryPromptTimeoutMs (mutable override for retry timeout tuning)", () => {
-        expect(isImmutableConfigPath("agents", "default.promptTimeout.retryPromptTimeoutMs")).toBe(false);
-    });
-    // Mutable overrides: per-channel media processing toggles
-    it("allows channels.telegram.mediaProcessing (mutable override)", () => {
-        expect(isImmutableConfigPath("channels", "telegram.mediaProcessing")).toBe(false);
-    });
-    it("allows channels.telegram.mediaProcessing.describeVideos (child of mutable override)", () => {
-        expect(isImmutableConfigPath("channels", "telegram.mediaProcessing.describeVideos")).toBe(false);
-    });
-    it("allows channels.discord.mediaProcessing.transcribeAudio (mutable override)", () => {
-        expect(isImmutableConfigPath("channels", "discord.mediaProcessing.transcribeAudio")).toBe(false);
-    });
-    // Channel credentials remain immutable despite mediaProcessing override
-    it("rejects channels.telegram.botToken (NOT overridden, still immutable)", () => {
-        expect(isImmutableConfigPath("channels", "telegram.botToken")).toBe(true);
-    });
-    // Security-sensitive agent settings remain immutable despite overrides
-    it("rejects agents.default.model (NOT overridden, still immutable)", () => {
-        expect(isImmutableConfigPath("agents", "default.model")).toBe(true);
-    });
-    it("rejects agents.default.budgets.maxDailyUsd (NOT overridden, still immutable)", () => {
-        expect(isImmutableConfigPath("agents", "default.budgets.maxDailyUsd")).toBe(true);
-    });
-    it("rejects agents.default.toolPolicy (NOT overridden, still immutable)", () => {
-        expect(isImmutableConfigPath("agents", "default.toolPolicy")).toBe(true);
-    });
-    it("rejects agents.default.modelRoutes.default (NOT overridden, still immutable)", () => {
-        expect(isImmutableConfigPath("agents", "default.modelRoutes.default")).toBe(true);
-    });
-    it("rejects agents.default.provider (NOT overridden, still immutable)", () => {
-        expect(isImmutableConfigPath("agents", "default.provider")).toBe(true);
-    });
-    // Mutable override: MCP server management
-    it("allows integrations.mcp.servers (mutable override for MCP management)", () => {
-        expect(isImmutableConfigPath("integrations", "mcp.servers")).toBe(false);
-    });
-    // Other integrations remain immutable
-    it("rejects integrations.mcp (parent path still immutable)", () => {
-        expect(isImmutableConfigPath("integrations", "mcp")).toBe(true);
-    });
-});
-describe("MUTABLE_CONFIG_OVERRIDES", () => {
-    it("contains exactly 10 override patterns", () => {
-        expect(MUTABLE_CONFIG_OVERRIDES).toHaveLength(10);
-    });
-    it("agent/channel patterns use * wildcard for second segment", () => {
-        const wildcardPatterns = MUTABLE_CONFIG_OVERRIDES.filter((p) => p.startsWith("agents.") || p.startsWith("channels."));
-        for (const pattern of wildcardPatterns) {
-            const parts = pattern.split(".");
-            expect(parts[1]).toBe("*");
-        }
-    });
-});
-describe("matchesOverridePattern", () => {
-    it("matches exact path to pattern", () => {
-        expect(matchesOverridePattern("agents.default.persona", "agents.*.persona")).toBe(true);
-    });
-    it("matches child path of pattern", () => {
-        expect(matchesOverridePattern("agents.default.persona.name", "agents.*.persona")).toBe(true);
-    });
-    it("rejects path shorter than pattern", () => {
-        expect(matchesOverridePattern("agents.default", "agents.*.persona")).toBe(false);
-    });
-    it("rejects path with wrong literal segment", () => {
-        expect(matchesOverridePattern("agents.default.model", "agents.*.persona")).toBe(false);
-    });
-    it("wildcard matches any single segment", () => {
-        expect(matchesOverridePattern("agents.mybot.maxSteps", "agents.*.maxSteps")).toBe(true);
-        expect(matchesOverridePattern("agents.production-bot.maxSteps", "agents.*.maxSteps")).toBe(true);
-    });
-    it("rejects path missing intermediate segment", () => {
-        expect(matchesOverridePattern("agents.persona", "agents.*.persona")).toBe(false);
-    });
-});

package/node_modules/@comis/core/dist/config/include-resolver.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@comis/core/dist/config/include-resolver.test.js

@@ -1,292 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ok, err } from "@comis/shared";
-import { resolveIncludes } from "./include-resolver.js";
-/**
- * Helper to create mock deps with a virtual filesystem.
- * Files are keyed by absolute path, values are raw YAML/JSON strings.
- */
-function createMockDeps(files) {
-    return {
-        readFile(absPath) {
-            if (absPath in files) {
-                return ok(files[absPath]);
-            }
-            return err({
-                code: "FILE_NOT_FOUND",
-                message: `File not found: ${absPath}`,
-                path: absPath,
-            });
-        },
-        parseFn(raw, _filePath) {
-            try {
-                // Simple JSON parse for tests (YAML is a superset of JSON)
-                const parsed = JSON.parse(raw);
-                if (parsed === null || parsed === undefined) {
-                    return ok({});
-                }
-                if (typeof parsed !== "object" || Array.isArray(parsed)) {
-                    return err({
-                        code: "PARSE_ERROR",
-                        message: `Expected object, got ${typeof parsed}`,
-                    });
-                }
-                return ok(parsed);
-            }
-            catch (e) {
-                return err({
-                    code: "PARSE_ERROR",
-                    message: `Parse error: ${e.message}`,
-                });
-            }
-        },
-        resolvePath(basePath, includePath) {
-            // Simple path join for tests — in production this uses safePath()
-            // Reject traversal attempts in tests too
-            if (includePath.includes("..")) {
-                return err({
-                    code: "INCLUDE_ERROR",
-                    message: `Path traversal blocked: "${includePath}" escapes base "${basePath}"`,
-                    path: includePath,
-                });
-            }
-            const resolved = basePath + "/" + includePath;
-            return ok(resolved);
-        },
-    };
-}
-describe("config/include-resolver", () => {
-    describe("resolveIncludes", () => {
-        it("resolves simple $include and deep-merges included content", () => {
-            const deps = createMockDeps({
-                "/config/base.json": JSON.stringify({
-                    logLevel: "debug",
-                    agents: { default: { name: "BaseBot" } },
-                }),
-            });
-            const obj = {
-                $include: "base.json",
-                tenantId: "my-tenant",
-            };
-            const result = resolveIncludes(obj, "/config", deps);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                // Included content is base, sibling keys override
-                expect(val.logLevel).toBe("debug");
-                expect(val.tenantId).toBe("my-tenant");
-                const agents = val.agents;
-                expect(agents.default.name).toBe("BaseBot");
-                // $include key should be removed
-                expect(val.$include).toBeUndefined();
-            }
-        });
-        it("resolves nested includes (included file includes another file)", () => {
-            const deps = createMockDeps({
-                "/config/a.json": JSON.stringify({
-                    $include: "b.json",
-                    fromA: true,
-                }),
-                "/config/b.json": JSON.stringify({
-                    fromB: true,
-                    shared: "from-b",
-                }),
-            });
-            const obj = {
-                $include: "a.json",
-                topLevel: "value",
-            };
-            const result = resolveIncludes(obj, "/config", deps);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                expect(val.fromB).toBe(true);
-                expect(val.fromA).toBe(true);
-                expect(val.topLevel).toBe("value");
-            }
-        });
-        it("detects circular reference: A includes B includes A", () => {
-            const deps = createMockDeps({
-                "/config/a.json": JSON.stringify({ $include: "b.json" }),
-                "/config/b.json": JSON.stringify({ $include: "a.json" }),
-            });
-            const obj = { $include: "a.json" };
-            const result = resolveIncludes(obj, "/config", deps);
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("CIRCULAR_INCLUDE");
-                expect(result.error.message).toContain("Circular");
-            }
-        });
-        it("returns INCLUDE_ERROR when depth limit (MAX_INCLUDE_DEPTH = 10) is exceeded", () => {
-            // Create a chain of 12 files, each including the next
-            const files = {};
-            for (let i = 0; i < 12; i++) {
-                files[`/config/f${i}.json`] = JSON.stringify({
-                    $include: `f${i + 1}.json`,
-                    [`key${i}`]: i,
-                });
-            }
-            files["/config/f12.json"] = JSON.stringify({ leaf: true });
-            const deps = createMockDeps(files);
-            const obj = { $include: "f0.json" };
-            const result = resolveIncludes(obj, "/config", deps);
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("INCLUDE_ERROR");
-                expect(result.error.message).toContain("depth");
-            }
-        });
-        it("rejects include path traversal attempt via resolvePath", () => {
-            const deps = createMockDeps({});
-            const obj = { $include: "../../../etc/passwd" };
-            const result = resolveIncludes(obj, "/config", deps);
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("INCLUDE_ERROR");
-                expect(result.error.message).toContain("traversal");
-            }
-        });
-        it("returns INCLUDE_ERROR for non-existent included file", () => {
-            const deps = createMockDeps({});
-            const obj = { $include: "missing.json" };
-            const result = resolveIncludes(obj, "/config", deps);
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("INCLUDE_ERROR");
-                expect(result.error.message).toContain("missing.json");
-            }
-        });
-        it("deep-merges sibling keys alongside $include (siblings override included content)", () => {
-            const deps = createMockDeps({
-                "/config/base.json": JSON.stringify({
-                    agents: { default: { name: "Base", model: "gpt-4" } },
-                    logLevel: "info",
-                }),
-            });
-            const obj = {
-                $include: "base.json",
-                agents: { default: { name: "Override" } },
-            };
-            const result = resolveIncludes(obj, "/config", deps);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                const agents = val.agents;
-                // Sibling overrides included
-                expect(agents.default.name).toBe("Override");
-                // Included fields preserved where not overridden
-                expect(agents.default.model).toBe("gpt-4");
-                expect(val.logLevel).toBe("info");
-            }
-        });
-        it("resolves $include at nested object levels (not just top-level)", () => {
-            const deps = createMockDeps({
-                "/config/memory-defaults.json": JSON.stringify({
-                    walMode: true,
-                    compaction: { enabled: true, threshold: 500 },
-                }),
-            });
-            const obj = {
-                tenantId: "test",
-                memory: {
-                    $include: "memory-defaults.json",
-                    dbPath: "/custom/path.db",
-                },
-            };
-            const result = resolveIncludes(obj, "/config", deps);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                expect(val.tenantId).toBe("test");
-                const memory = val.memory;
-                expect(memory.walMode).toBe(true);
-                expect(memory.dbPath).toBe("/custom/path.db");
-                const compaction = memory.compaction;
-                expect(compaction.enabled).toBe(true);
-                expect(compaction.threshold).toBe(500);
-            }
-        });
-        it("resolves multiple $include directives across different nested paths", () => {
-            const deps = createMockDeps({
-                "/config/agent-defaults.json": JSON.stringify({
-                    name: "DefaultAgent",
-                    model: "gpt-4",
-                }),
-                "/config/memory-defaults.json": JSON.stringify({
-                    walMode: true,
-                    embeddingModel: "text-embedding-3-small",
-                }),
-            });
-            const obj = {
-                tenantId: "multi",
-                agents: {
-                    default: {
-                        $include: "agent-defaults.json",
-                        maxSteps: 25,
-                    },
-                },
-                memory: {
-                    $include: "memory-defaults.json",
-                    dbPath: "/var/db.sqlite",
-                },
-            };
-            const result = resolveIncludes(obj, "/config", deps);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                expect(val.tenantId).toBe("multi");
-                const agents = val.agents;
-                expect(agents.default.name).toBe("DefaultAgent");
-                expect(agents.default.model).toBe("gpt-4");
-                expect(agents.default.maxSteps).toBe(25);
-                const memory = val.memory;
-                expect(memory.walMode).toBe(true);
-                expect(memory.embeddingModel).toBe("text-embedding-3-small");
-                expect(memory.dbPath).toBe("/var/db.sqlite");
-            }
-        });
-        it("passes through non-object values unchanged", () => {
-            const deps = createMockDeps({});
-            // Primitives and arrays should pass through
-            const result1 = resolveIncludes("hello", "/config", deps);
-            expect(result1.ok).toBe(true);
-            if (result1.ok) {
-                expect(result1.value).toBe("hello");
-            }
-            const result2 = resolveIncludes(42, "/config", deps);
-            expect(result2.ok).toBe(true);
-            if (result2.ok) {
-                expect(result2.value).toBe(42);
-            }
-            const result3 = resolveIncludes([1, 2, 3], "/config", deps);
-            expect(result3.ok).toBe(true);
-            if (result3.ok) {
-                expect(result3.value).toEqual([1, 2, 3]);
-            }
-        });
-        it("resolves $include in array elements that are objects", () => {
-            const deps = createMockDeps({
-                "/config/item.json": JSON.stringify({
-                    name: "from-include",
-                    value: 42,
-                }),
-            });
-            const obj = {
-                items: [
-                    { $include: "item.json", extra: "data" },
-                    { plain: "object" },
-                ],
-            };
-            const result = resolveIncludes(obj, "/config", deps);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                const items = val.items;
-                expect(items[0].name).toBe("from-include");
-                expect(items[0].value).toBe(42);
-                expect(items[0].extra).toBe("data");
-                expect(items[1].plain).toBe("object");
-            }
-        });
-    });
-});

package/node_modules/@comis/core/dist/config/layered.test.d.ts

@@ -1 +0,0 @@
-export {};