@akira-tl/forgerelay 1.1.2 → 1.2.0

package/dist/runtime/config/definition/general-config.js

@@ -0,0 +1,258 @@
+import * as z from "zod/v4";
+import { defineConfigDomain } from "./definition.js";
+const USER_RUNTIME_SCOPES = ["runtime", "user", "built-in"];
+const USER_SCOPES = ["user", "built-in"];
+const USER_ONLY_SCOPES = ["user"];
+const LEGACY_REMOVAL_VERSION = "1.4.0";
+const commandShellSchema = z.object({
+    mode: z.enum(["follow-launcher", "pinned"]),
+    family: z.enum(["bash", "zsh", "fish", "sh", "pwsh", "powershell", "cmd"]),
+    executable: z.string().min(1),
+}).strict();
+const retentionSchema = z.object({
+    historyDays: z.number().int().min(1).max(36_500).optional(),
+    orphanedAdministrativeState: z.boolean().optional(),
+}).strict();
+export const generalConfigDefinition = defineConfigDomain({
+    domain: "config",
+    title: "ForgeRelay general configuration",
+    description: "Canonical ForgeRelay general configuration. Domain-specific MCP, Language Server, Hook, Subagent, and credential settings use separate sources.",
+    fields: {
+        host: field(z.string().min(1), "Local bind host.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: literal("127.0.0.1"),
+            reload: "restart-required",
+            runtimeOverride: runtimeEnv("HOST", (env) => env.HOST),
+        }),
+        port: field(z.number().int().min(1).max(65535), "Local listening port.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: literal(7676),
+            reload: "restart-required",
+            runtimeOverride: runtimeEnv("PORT", (env) => readIntegerEnv(env, "PORT", 1, 65535)),
+        }),
+        allowedRoots: field(z.array(z.string()), "Filesystem roots that Workspaces may open.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: computed("The process working directory when no roots are configured."),
+            reload: "restart-required",
+            runtimeOverride: runtimeEnv("FORGERELAY_ALLOWED_ROOTS", (env) => readListEnv(env, "FORGERELAY_ALLOWED_ROOTS")),
+        }),
+        publicBaseUrl: field(z.union([z.string().min(1), z.array(z.string().min(1)).min(1), z.null()]), "Canonical public base URL or ordered public base URL list.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: computed("A local HTTP URL derived from the effective bind host and port."),
+            reload: "restart-required",
+            runtimeOverride: runtimeEnv("FORGERELAY_PUBLIC_BASE_URL", (env) => readRequiredTextEnv(env, "FORGERELAY_PUBLIC_BASE_URL")),
+        }),
+        allowedHosts: field(z.array(z.string()), "Explicit Host-header allowlist.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: computed("Derived from loopback, bind host, and configured public base URL hostnames."),
+            reload: "restart-required",
+            runtimeOverride: runtimeEnv("FORGERELAY_ALLOWED_HOSTS", (env) => readListEnv(env, "FORGERELAY_ALLOWED_HOSTS")),
+        }),
+        trustedProxies: field(z.array(z.string()), "Trusted proxy IP addresses, CIDRs, or the internal loopback alias.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: computed("No trusted proxy unless the deployment shape safely derives loopback trust."),
+            reload: "restart-required",
+            runtimeOverride: runtimeEnv("FORGERELAY_TRUSTED_PROXIES", (env) => readListEnv(env, "FORGERELAY_TRUSTED_PROXIES")),
+        }),
+        stateDir: field(z.string().min(1), "ForgeRelay durable state directory.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: computed("~/.local/share/forgerelay"),
+            reload: "restart-required",
+            runtimeOverride: runtimeEnv("FORGERELAY_STATE_DIR", (env) => env.FORGERELAY_STATE_DIR),
+        }),
+        worktreeRoot: field(z.string().min(1), "Managed worktree directory.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: computed("~/.forgerelay/worktrees"),
+            reload: "restart-required",
+            runtimeOverride: runtimeEnv("FORGERELAY_WORKTREE_ROOT", (env) => env.FORGERELAY_WORKTREE_ROOT),
+        }),
+        artifactsEnabled: field(z.boolean(), "Enable ForgeRelay Artifact capability support.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: literal(false),
+            runtimeOverride: runtimeEnv("FORGERELAY_ARTIFACTS", (env) => readBooleanEnv(env, "FORGERELAY_ARTIFACTS")),
+        }),
+        artifactMaxFileBytes: field(z.number().int().min(1), "Maximum bytes accepted for one downloaded Artifact file.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: literal(100 * 1024 * 1024),
+            runtimeOverride: runtimeEnv("FORGERELAY_ARTIFACT_MAX_FILE_BYTES", (env) => readIntegerEnv(env, "FORGERELAY_ARTIFACT_MAX_FILE_BYTES", 1)),
+        }),
+        mediaMaxBytes: field(z.number().int().min(1), "Maximum aggregate decoded inline image bytes in one Host-facing result.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: literal(20 * 1024 * 1024),
+            runtimeOverride: runtimeEnv("FORGERELAY_MEDIA_MAX_BYTES", (env) => readIntegerEnv(env, "FORGERELAY_MEDIA_MAX_BYTES", 1)),
+        }),
+        taskReminderInterval: field(z.number().int().min(0), "Semantic-work interval for Workspace Task reminders; zero disables reminders.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: literal(30),
+            runtimeOverride: runtimeEnv("FORGERELAY_TASK_REMINDER_INTERVAL", (env) => readIntegerEnv(env, "FORGERELAY_TASK_REMINDER_INTERVAL", 0)),
+        }),
+        retention: field(retentionSchema, "Owner-authorized durable history and orphaned administrative-state retention policy.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: computed("Unlimited durable history and no orphaned administrative cleanup authorization."),
+            runtimeOverride: runtimeEnv(["FORGERELAY_RETENTION_HISTORY_DAYS", "FORGERELAY_RETENTION_ORPHANED_ADMIN"], readRetentionEnv),
+        }),
+        activityPanelExpanded: field(z.boolean(), "Whether the Activity Panel opens expanded by default.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: literal(false),
+            runtimeOverride: runtimeEnv("FORGERELAY_ACTIVITY_PANEL_EXPANDED", (env) => readBooleanEnv(env, "FORGERELAY_ACTIVITY_PANEL_EXPANDED")),
+        }),
+        workflowInstructions: field(z.union([z.string(), z.literal(false)]), "Replace ForgeRelay built-in Agent workflow instructions while retaining the capability contract.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: computed("ForgeRelay built-in workflow instructions."),
+            runtimeOverride: runtimeEnv("FORGERELAY_WORKFLOW_INSTRUCTIONS", (env) => env.FORGERELAY_WORKFLOW_INSTRUCTIONS),
+        }),
+        appendInstructions: field(z.string(), "Append operator workflow instructions after the selected ForgeRelay workflow policy.", {
+            scopes: ["runtime", ...USER_ONLY_SCOPES],
+            builtIn: none(),
+            runtimeOverride: runtimeEnv("FORGERELAY_APPEND_INSTRUCTIONS", (env) => env.FORGERELAY_APPEND_INSTRUCTIONS),
+        }),
+        agentDir: field(z.string().min(1), "Agent runtime directory used by supported integrations.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: computed("~/.codex"),
+            reload: "restart-required",
+            runtimeOverride: runtimeEnv("FORGERELAY_AGENT_DIR", (env) => env.FORGERELAY_AGENT_DIR),
+        }),
+        systemInstructionsPath: field(z.string().min(1), "Global Agent instruction file consumed by ForgeRelay.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: computed("~/.agents/AGENTS.md"),
+            runtimeOverride: runtimeEnv("FORGERELAY_SYSTEM_INSTRUCTIONS_PATH", (env) => readNonEmptyPathEnv(env, "FORGERELAY_SYSTEM_INSTRUCTIONS_PATH")),
+        }),
+        commandShell: field(commandShellSchema, "Recorded command-shell preference for ForgeRelay command and Hook execution.", {
+            scopes: USER_SCOPES,
+            builtIn: computed("Detected launcher shell with the recorded compatibility fallback used when needed."),
+            reload: "restart-required",
+        }),
+        shellInstructions: field(z.boolean(), "Enable ForgeRelay-owned runtime shell instructions.", {
+            scopes: USER_SCOPES,
+            builtIn: literal(false),
+        }),
+        subagents: field(z.boolean(), "Enable Subagent Session support.", {
+            scopes: USER_RUNTIME_SCOPES,
+            builtIn: literal(false),
+            runtimeOverride: runtimeEnv("FORGERELAY_SUBAGENTS", (env) => readBooleanEnv(env, "FORGERELAY_SUBAGENTS")),
+        }),
+        allowAgentLanguageServerInstall: field(z.boolean(), "Allow Agents to install ForgeRelay-managed Language Servers.", {
+            scopes: USER_SCOPES,
+            builtIn: literal(false),
+        }),
+        languageServers: field(z.unknown(), "Deprecated inline Language Server configuration retained for v1.2 compatibility.", {
+            scopes: USER_ONLY_SCOPES,
+            builtIn: none(),
+            deprecation: legacyDeprecation("language-servers.json"),
+        }),
+        mcpServers: field(z.unknown(), "Deprecated inline External MCP configuration retained for v1.2 compatibility.", {
+            scopes: USER_ONLY_SCOPES,
+            builtIn: none(),
+            deprecation: legacyDeprecation("mcp.json"),
+        }),
+        hooks: field(z.unknown(), "Deprecated inline Hook configuration retained for v1.2 compatibility.", {
+            scopes: USER_ONLY_SCOPES,
+            builtIn: none(),
+            deprecation: legacyDeprecation("hooks/"),
+        }),
+    },
+});
+function field(schema, description, options) {
+    return {
+        schema,
+        description,
+        legalScopes: options.scopes,
+        merge: "replace",
+        reload: options.reload ?? "hot",
+        sensitivity: options.sensitivity ?? "public",
+        interpolation: options.interpolation ?? "none",
+        executionEffect: options.executionEffect ?? "none",
+        builtIn: options.builtIn,
+        ...(options.runtimeOverride ? { runtimeOverride: options.runtimeOverride } : {}),
+        ...(options.deprecation ? { deprecation: options.deprecation } : {}),
+    };
+}
+function literal(value) {
+    return { kind: "literal", value };
+}
+function computed(description) {
+    return { kind: "computed", description };
+}
+function none() {
+    return { kind: "none" };
+}
+function runtimeEnv(env, readEnv) {
+    return { env, readEnv };
+}
+function readBooleanEnv(env, name) {
+    const value = env[name];
+    if (value === undefined)
+        return undefined;
+    return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
+function readIntegerEnv(env, name, minimum, maximum = Number.MAX_SAFE_INTEGER) {
+    const value = env[name];
+    if (value === undefined || value === "")
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < minimum || parsed > maximum) {
+        const range = maximum === Number.MAX_SAFE_INTEGER
+            ? `an integer greater than or equal to ${minimum}`
+            : `an integer from ${minimum} to ${maximum}`;
+        throw new Error(`Invalid ${name}: expected ${range}.`);
+    }
+    return parsed;
+}
+function readListEnv(env, name) {
+    const value = env[name];
+    if (value === undefined)
+        return undefined;
+    return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function readRequiredTextEnv(env, name) {
+    const value = env[name];
+    if (value === undefined)
+        return undefined;
+    if (!value.split(",").some((entry) => entry.trim().length > 0)) {
+        throw new Error(`${name} must contain at least one public base URL.`);
+    }
+    return value;
+}
+function readNonEmptyPathEnv(env, name) {
+    const value = env[name];
+    if (value === undefined)
+        return undefined;
+    if (!value.trim())
+        throw new Error(`${name} must be one non-empty path`);
+    return value;
+}
+function readRetentionEnv(env) {
+    const rawHistoryDays = env.FORGERELAY_RETENTION_HISTORY_DAYS;
+    let historyDays;
+    if (rawHistoryDays !== undefined && rawHistoryDays !== "") {
+        const parsed = Number(rawHistoryDays);
+        if (!Number.isInteger(parsed) || parsed < 1 || parsed > 36_500) {
+            throw new Error("Retention historyDays must be an integer between 1 and 36500.");
+        }
+        historyDays = parsed;
+    }
+    const rawOrphaned = env.FORGERELAY_RETENTION_ORPHANED_ADMIN;
+    let orphanedAdministrativeState;
+    if (rawOrphaned !== undefined && rawOrphaned !== "") {
+        const normalized = rawOrphaned.trim().toLowerCase();
+        if (["1", "true", "yes", "on"].includes(normalized))
+            orphanedAdministrativeState = true;
+        else if (["0", "false", "no", "off"].includes(normalized))
+            orphanedAdministrativeState = false;
+        else
+            throw new Error("Retention orphanedAdministrativeState must be a boolean.");
+    }
+    if (historyDays === undefined && orphanedAdministrativeState === undefined)
+        return undefined;
+    return {
+        ...(historyDays === undefined ? {} : { historyDays }),
+        ...(orphanedAdministrativeState === undefined ? {} : { orphanedAdministrativeState }),
+    };
+}
+function legacyDeprecation(replacement) {
+    return {
+        since: "1.2.0",
+        removeIn: LEGACY_REMOVAL_VERSION,
+        replacement,
+    };
+}

package/dist/runtime/config/definition/language-servers.js

@@ -0,0 +1,116 @@
+import * as z from "zod/v4";
+import { defineConfigDomain } from "./definition.js";
+const LANGUAGE_SERVER_SCOPES = ["project-local", "project", "user", "built-in"];
+const ENV_REFERENCE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+export const languageServerDefinitionSchema = z.object({
+    command: z.string().min(1).optional(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    languages: z.array(z.string().min(1)).min(1).optional(),
+    extensions: z.array(z.string().regex(/^\./)).min(1).optional(),
+    languageIdByExtension: z.record(z.string().regex(/^\./), z.string().min(1)).optional(),
+    projectMarkers: z.array(z.string().min(1)).optional(),
+    disabled: z.literal(false).optional(),
+}).strict();
+export const languageServerDisabledSchema = z.object({ disabled: z.literal(true) }).strict();
+export const languageServerServersSchema = z.record(z.string().min(1), z.union([languageServerDisabledSchema, languageServerDefinitionSchema]));
+export const BUILTIN_LANGUAGE_SERVER_DEFINITIONS = {
+    typescript: {
+        args: ["--stdio"],
+        languages: ["typescript", "typescriptreact", "javascript", "javascriptreact"],
+        extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+        languageIdByExtension: {
+            ".ts": "typescript",
+            ".tsx": "typescriptreact",
+            ".js": "javascript",
+            ".jsx": "javascriptreact",
+            ".mjs": "javascript",
+            ".cjs": "javascript",
+        },
+        projectMarkers: ["tsconfig.json", "jsconfig.json", "package.json"],
+    },
+    pyright: {
+        args: ["--stdio"],
+        languages: ["python"],
+        extensions: [".py", ".pyi"],
+        languageIdByExtension: { ".py": "python", ".pyi": "python" },
+        projectMarkers: ["pyrightconfig.json", "pyproject.toml", "setup.cfg", "setup.py"],
+    },
+    "rust-analyzer": {
+        languages: ["rust"],
+        extensions: [".rs"],
+        languageIdByExtension: { ".rs": "rust" },
+        projectMarkers: ["Cargo.toml"],
+    },
+    gopls: {
+        languages: ["go"],
+        extensions: [".go"],
+        languageIdByExtension: { ".go": "go" },
+        projectMarkers: ["go.work", "go.mod"],
+    },
+    clangd: {
+        languages: ["c", "cpp", "objective-c", "objective-cpp"],
+        extensions: [".c", ".cc", ".cpp", ".cxx", ".h", ".hh", ".hpp", ".hxx", ".m", ".mm"],
+        languageIdByExtension: {
+            ".c": "c",
+            ".cc": "cpp",
+            ".cpp": "cpp",
+            ".cxx": "cpp",
+            ".h": "cpp",
+            ".hh": "cpp",
+            ".hpp": "cpp",
+            ".hxx": "cpp",
+            ".m": "objective-c",
+            ".mm": "objective-cpp",
+        },
+        projectMarkers: ["compile_commands.json", "compile_flags.txt", ".clangd"],
+    },
+};
+export const languageServersConfigDefinition = defineConfigDomain({
+    domain: "language-servers",
+    title: "ForgeRelay Language Server configuration",
+    description: "Language Server definitions used by Code Intelligence.",
+    fileShape: { kind: "keyed-root", field: "servers" },
+    fields: {
+        servers: {
+            schema: languageServerServersSchema,
+            description: "Language Server definitions keyed by stable server name.",
+            required: true,
+            legalScopes: LANGUAGE_SERVER_SCOPES,
+            merge: "keyed",
+            reload: "hot",
+            sensitivity: "sensitive",
+            interpolation: "env",
+            interpolateValue: interpolateLanguageServerEnvironment,
+            builtIn: { kind: "literal", value: BUILTIN_LANGUAGE_SERVER_DEFINITIONS },
+            executionEffect: (value) => isRecord(value) && value.disabled === true ? "none" : "process",
+        },
+    },
+});
+function interpolateLanguageServerEnvironment(value, environment) {
+    return Object.fromEntries(Object.entries(value).map(([name, entry]) => {
+        if (!("env" in entry) || !isRecord(entry.env))
+            return [name, entry];
+        return [name, {
+                ...entry,
+                env: Object.fromEntries(Object.entries(entry.env).map(([key, raw]) => [
+                    key,
+                    typeof raw === "string" ? interpolateString(raw, environment) : raw,
+                ])),
+            }];
+    }));
+}
+function interpolateString(value, environment) {
+    return value.replace(ENV_REFERENCE, (_match, name) => {
+        const resolved = environment[name];
+        if (resolved !== undefined)
+            return resolved;
+        const error = new Error(`Required environment variable ${name} is not available.`);
+        error.code = "missing_environment";
+        error.variable = name;
+        throw error;
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/runtime/config/definition/schema.js

@@ -0,0 +1,113 @@
+import * as z from "zod/v4";
+import { configSourceSchema } from "./definition.js";
+import { CONFIG_FILE_SCOPES, CONFIG_SCHEMA_CONTRACT_MAJOR, } from "./types.js";
+const DRAFT_7_SCHEMA = "http://json-schema.org/draft-07/schema#";
+const SCHEMA_RAW_BASE = "https://raw.githubusercontent.com/Akira-TL/forgerelay/main";
+export function configSchemaRelativePath(definition, scope) {
+    return `schemas/v${CONFIG_SCHEMA_CONTRACT_MAJOR}/${definition.domain}.${scope}.schema.json`;
+}
+export function configSchemaId(definition, scope) {
+    return `${SCHEMA_RAW_BASE}/${configSchemaRelativePath(definition, scope)}`;
+}
+export function generateConfigJsonSchema(definition, scope) {
+    if (definition.schemaOutput === "none") {
+        throw new Error(`Config domain ${definition.domain} does not expose a JSON file schema.`);
+    }
+    if (definition.fileShape?.kind === "keyed-root") {
+        return generateKeyedRootConfigJsonSchema(definition, scope);
+    }
+    if (definition.fileShape?.kind === "keyed-entry") {
+        return generateKeyedEntryConfigJsonSchema(definition, scope);
+    }
+    const schema = z.toJSONSchema(configSourceSchema(definition, scope), {
+        target: "draft-7",
+    });
+    applySchemaIdentity(schema, definition, scope);
+    const properties = asObject(schema.properties);
+    for (const [name, field] of Object.entries(definition.fields)) {
+        if (!field.legalScopes.includes(scope))
+            continue;
+        const property = asObject(properties[name]);
+        applyFieldMetadata(property, field);
+        properties[name] = property;
+    }
+    schema.properties = properties;
+    return schema;
+}
+function generateKeyedRootConfigJsonSchema(definition, scope) {
+    const fileShape = definition.fileShape;
+    if (!fileShape || fileShape.kind !== "keyed-root") {
+        throw new Error(`Config domain ${definition.domain} is not keyed-root.`);
+    }
+    const field = definition.fields[fileShape.field];
+    if (!field || !field.legalScopes.includes(scope)) {
+        throw new Error(`Config domain ${definition.domain} does not expose keyed-root field ${fileShape.field} at ${scope} scope.`);
+    }
+    const schema = z.toJSONSchema(field.schema, { target: "draft-7" });
+    applySchemaIdentity(schema, definition, scope);
+    const properties = asObject(schema.properties);
+    properties.$schema = {
+        type: "string",
+        description: "Editor-only JSON Schema URL. Ignored by ForgeRelay resolution.",
+    };
+    schema.properties = properties;
+    applyFieldMetadata(schema, field);
+    return schema;
+}
+function generateKeyedEntryConfigJsonSchema(definition, scope) {
+    const fileShape = definition.fileShape;
+    if (!fileShape || fileShape.kind !== "keyed-entry") {
+        throw new Error(`Config domain ${definition.domain} is not keyed-entry.`);
+    }
+    const field = definition.fields[fileShape.field];
+    if (!field || !field.legalScopes.includes(scope)) {
+        throw new Error(`Config domain ${definition.domain} does not expose keyed-entry field ${fileShape.field} at ${scope} scope.`);
+    }
+    const schema = z.toJSONSchema(fileShape.fileSchema, { target: "draft-7" });
+    applySchemaIdentity(schema, definition, scope);
+    applyFieldMetadata(schema, field);
+    return schema;
+}
+function applySchemaIdentity(schema, definition, scope) {
+    schema.$schema = DRAFT_7_SCHEMA;
+    schema.$id = configSchemaId(definition, scope);
+    schema.title = `${definition.title} (${scope})`;
+    schema.description = definition.description;
+}
+function applyFieldMetadata(target, field) {
+    if (field.builtIn.kind === "literal")
+        target.default = field.builtIn.value;
+    target["x-forgerelay-scopes"] = [...field.legalScopes];
+    target["x-forgerelay-merge"] = field.merge;
+    target["x-forgerelay-reload"] = field.reload;
+    target["x-forgerelay-sensitivity"] = field.sensitivity;
+    target["x-forgerelay-interpolation"] = field.interpolation;
+    target["x-forgerelay-execution-effect"] =
+        typeof field.executionEffect === "function" ? "dynamic" : field.executionEffect;
+    if (field.runtimeOverride) {
+        target["x-forgerelay-runtime-override"] = {
+            ...(field.runtimeOverride.cli ? { cli: field.runtimeOverride.cli } : {}),
+            ...(field.runtimeOverride.env ? { env: field.runtimeOverride.env } : {}),
+        };
+    }
+    if (field.builtIn.kind === "computed") {
+        target["x-forgerelay-computed-default"] = field.builtIn.description;
+    }
+    if (field.deprecation) {
+        target.deprecated = true;
+        target["x-forgerelay-deprecation"] = field.deprecation;
+    }
+}
+export function generateConfigSchemaFiles(definitions) {
+    return definitions.flatMap((definition) => definition.schemaOutput === "none"
+        ? []
+        : CONFIG_FILE_SCOPES.map((scope) => ({
+            relativePath: configSchemaRelativePath(definition, scope),
+            schema: generateConfigJsonSchema(definition, scope),
+        })));
+}
+function asObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}

package/dist/runtime/config/definition/types.js

@@ -0,0 +1,2 @@
+export const CONFIG_SCHEMA_CONTRACT_MAJOR = 1;
+export const CONFIG_FILE_SCOPES = ["user", "project-local", "project"];