@iowarp/clio-coder 0.3.0

package/dist/chunk-UHTSULZS.js

@@ -0,0 +1,461 @@
+// src/core/guardrails.ts
+var GUARDRAIL_DEFAULTS = {
+  turnToolCallBudget: 60,
+  workerToolCallCap: 150,
+  maxDispatchRuns: 1e3,
+  readMaxBytes: 50 * 1024,
+  observationTurnBudgetBytes: 192 * 1024,
+  internalDispatchTimeoutMs: 15 * 60 * 1e3
+};
+var GUARDRAIL_ENV_VARS = {
+  turnToolCallBudget: "CLIO_CODER_TURN_TOOL_CALL_BUDGET",
+  workerToolCallCap: "CLIO_CODER_WORKER_TOOL_CALL_CAP",
+  maxDispatchRuns: "CLIO_CODER_MAX_RUNS",
+  readMaxBytes: "CLIO_CODER_READ_MAX_BYTES",
+  observationTurnBudgetBytes: "CLIO_CODER_OBSERVATION_TURN_BUDGET_BYTES",
+  internalDispatchTimeoutMs: "CLIO_CODER_INTERNAL_DISPATCH_TIMEOUT_MS"
+};
+function workerSynthesisReserveDirective(remaining, cap) {
+  return `budget reserve: only ${remaining} of your ${cap} tool calls remain, and they are reserved for verification reads and synthesis. Stop broad exploration now: re-read the locations you will cite, then answer in prose. Calls that are not reads will be blocked.`;
+}
+function workerSynthesisReserveBlockReason(tool, remaining, cap) {
+  return `workerToolCallReserve: only ${remaining} of ${cap} tool calls remain and they are reserved for verification reads and synthesis; ${tool} is not a read. Re-read any locations you will cite, then answer in prose from what you have gathered.`;
+}
+function workerToolCallCapExceededReason(cap) {
+  return `workerToolCallCap reached (${cap}); abort run`;
+}
+function isWorkerToolCallCapExceededReason(reason) {
+  return /^workerToolCallCap reached \([1-9]\d*\); abort run$/.test(reason);
+}
+function workerToolCallCapSynthesisReason(cap) {
+  return `workerToolCallCap reached (${cap}); tool calls are now disabled for the rest of this run. Everything you retrieved is already in the conversation above. Answer the operator now, in plain prose, from what you have gathered. Do not write tool-call markup such as <tool_call> blocks; tool calls are disabled and will not run.`;
+}
+function isWorkerToolCallCapSynthesisReason(reason) {
+  return /^workerToolCallCap reached \([1-9]\d*\); tool calls are now disabled/.test(reason);
+}
+function mentionsWorkerToolCallCap(text) {
+  return typeof text === "string" && /workerToolCallCap reached \([1-9]\d*\)/.test(text);
+}
+var configured = {};
+function configureGuardrails(values) {
+  configured = { ...values ?? {} };
+}
+function parsePositiveSafeInt(raw) {
+  if (raw === void 0) return void 0;
+  const normalized = raw.trim();
+  if (!/^[1-9]\d*$/.test(normalized)) return void 0;
+  const parsed = Number(normalized);
+  return Number.isSafeInteger(parsed) ? parsed : void 0;
+}
+function resolveGuardrail(key, env = process.env) {
+  return parsePositiveSafeInt(env[GUARDRAIL_ENV_VARS[key]]) ?? configured[key] ?? GUARDRAIL_DEFAULTS[key];
+}
+
+// src/core/defaults.ts
+var THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var DEFAULT_DELEGATION_CONNECT_TIMEOUT_MS = 3e4;
+var DEFAULT_DELEGATION_TURN_TIMEOUT_MS = 3e5;
+var DEFAULT_DELEGATION_PERMISSION_TIMEOUT_MS = 12e4;
+var ACTIVE_ROUTING_ROLES = ["researcher", "verifier", "reviewer", "judge"];
+var ACTIVE_ROUTING_POSTURES = ["quality", "balanced", "latency", "economy"];
+var ACTIVE_AGENT_AUTOMATION_ROLES = ["builder", "researcher", "verifier", "reviewer", "judge"];
+var DEFAULT_SETTINGS = {
+  version: 1,
+  identity: "clio",
+  autonomy: "auto-edit",
+  targets: [],
+  runtimePlugins: [],
+  orchestrator: {
+    target: null,
+    model: null,
+    thinkingLevel: "off"
+  },
+  // Optional small-model plane for task-memory maintenance. An unset target
+  // keeps proactive memory in its deterministic rules-only tier.
+  background: {
+    target: null,
+    model: null,
+    thinkingLevel: "off"
+  },
+  memory: {
+    intervention: {
+      enabled: true,
+      everyNTools: 10,
+      windowSteps: 8,
+      maxTokens: 400,
+      // A memory step runs detached from the turn that triggered it, so a
+      // generous deadline costs no interactive latency. Measured steps on a
+      // small local route ranged past two minutes, and a deadline shorter than
+      // the model discards finished work as a timeout.
+      timeoutMs: 18e4
+    }
+  },
+  workers: {
+    default: {
+      target: null,
+      model: null,
+      thinkingLevel: "off"
+    },
+    profiles: {},
+    agentBindings: {},
+    maxRetries: 2,
+    onPermission: "deny",
+    escalation: { timeoutMs: 12e4, fallback: "deny" },
+    resilienceCooldownMs: 15e3
+  },
+  fleet: {
+    nodes: []
+  },
+  routing: {
+    activeRoles: [],
+    activePostures: [],
+    agentAutomation: { activeAgentRoles: [] }
+  },
+  scope: [],
+  modelSelector: {
+    favorites: [],
+    recentLimit: 12
+  },
+  budget: {
+    sessionCeilingUsd: 5,
+    concurrency: "auto"
+  },
+  defaults: {
+    // Output tokens requested per turn, applied to every target. The value is
+    // always clamped down to the model's known max-output cap and the
+    // remaining context window at request time, so a model that supports less
+    // automatically gets less. 0 disables the global default and falls back to
+    // per-model caps only.
+    maxTokens: 32768
+  },
+  theme: "default",
+  terminal: {
+    showTerminalProgress: false,
+    outputVerbosity: "default"
+  },
+  skills: {
+    trustProjectCompatRoots: false
+  },
+  delegation: {
+    agents: [],
+    defaults: {
+      connectTimeoutMs: DEFAULT_DELEGATION_CONNECT_TIMEOUT_MS,
+      turnTimeoutMs: DEFAULT_DELEGATION_TURN_TIMEOUT_MS,
+      permissionTimeoutMs: DEFAULT_DELEGATION_PERMISSION_TIMEOUT_MS,
+      toolGovernance: "clio-policy"
+    }
+  },
+  // User keybinding overrides. Each id maps to a single KeyId string or a
+  // list of KeyIds. The interactive keybinding manager reads this table
+  // and layers it on top of CLIO_KEYBINDINGS defaults (src/domains/config/
+  // keybindings.ts).
+  keybindings: {},
+  compaction: {
+    auto: true,
+    threshold: 0.8,
+    excludeLastTurns: 6
+  },
+  retry: {
+    enabled: true,
+    maxRetries: 3,
+    baseDelayMs: 2e3,
+    maxDelayMs: 6e4
+  },
+  // Numeric backstops that bound runaway agent behavior. Settings are the
+  // primary home; each value also has a per-process env override for CI and
+  // one-off experiments (core/guardrails.ts documents both).
+  guardrails: { ...GUARDRAIL_DEFAULTS }
+};
+var DEFAULT_SETTINGS_YAML = `# Clio Coder settings. Written once on first install.
+# The file is machine-owned: \`clio-coder configure\`, \`clio-coder targets\`, and the TUI
+# rewrite it whole, and comments (including these) do not survive that write.
+# Docs: https://github.com/iowarp/clio-coder
+#
+# Default location:
+#   Linux:   ~/.config/clio-coder/settings.yaml
+#   macOS:   ~/Library/Application Support/clio-coder/config/settings.yaml
+#   Windows: %APPDATA%/clio-coder/config/settings.yaml
+# Set CLIO_CODER_HOME for a single-tree install, or CLIO_CODER_CONFIG_DIR / CLIO_CODER_DATA_DIR /
+# CLIO_CODER_STATE_DIR / CLIO_CODER_CACHE_DIR to override each directory separately.
+#
+# Common first run after installation:
+#   1. Repair/create local state: clio-coder doctor --fix
+#   2. List runtimes: clio-coder configure --list
+#   3. Configure one target with your runtime/model (examples below).
+#   4. Select and probe it: clio-coder targets use <id> && clio-coder targets --probe
+#   5. Launch: clio-coder
+
+version: 1
+identity: clio
+autonomy: auto-edit         # read-only | suggest | auto-edit | full-auto
+
+# Inference targets. Each entry becomes selectable for chat and workers.
+# Add entries via \`clio-coder configure\` or \`clio-coder targets add\`
+# or hand-edit. \`runtime\` must match an id registered in the runtime registry
+# (cloud APIs, local HTTP engines, or third-party plugins in the \`runtimes/\`
+# directory next to this file).
+targets: []
+# Local runtime examples (uncomment/adapt one; replace your-model-id):
+#   clio-coder configure --id local-lmstudio --runtime lmstudio-native --url http://localhost:1234 --model your-model-id --set-orchestrator --set-fleet-default
+#   clio-coder configure --id local-ollama --runtime ollama-native --url http://localhost:11434 --model your-model-id --set-orchestrator --set-fleet-default
+#   clio-coder configure --id local-llamacpp --runtime llamacpp --url http://127.0.0.1:8080 --model your-model-id --set-orchestrator --set-fleet-default
+#   clio-coder configure --id local-vllm --runtime vllm --url http://localhost:8000 --model your-model-id --set-orchestrator --set-fleet-default
+#   clio-coder configure --id local-sglang --runtime sglang --url http://localhost:30000 --model your-model-id --set-orchestrator --set-fleet-default
+# Add --context-window <tokens>, --max-tokens <tokens>, or --reasoning true
+# only when you have runtime/model-specific values to override probe results.
+#
+# Example target block equivalent to one configured local runtime:
+# targets:
+#   - id: local-lmstudio
+#     runtime: lmstudio-native
+#     url: http://localhost:1234
+#     defaultModel: your-model-id
+#     capabilities:
+#       reasoning: true
+
+# Optional npm packages that export clioRuntimes: RuntimeDescriptor[].
+runtimePlugins: []
+
+# Orchestrator target for the interactive loop. \`target\` refers to
+# targets[].id; \`model\` is the wire model id to request.
+# Keep thinkingLevel off unless a target/model supports explicit reasoning levels.
+orchestrator:
+  target: null
+  model: null
+  thinkingLevel: off
+
+# Optional background target for proactive task memory. Leave unset for the
+# zero-cost rules-only tier; setting it opts this session into LLM memory steps.
+background:
+  target: null
+  model: null
+  thinkingLevel: off
+
+memory:
+  intervention:
+    enabled: true
+    everyNTools: 10
+    windowSteps: 8
+    maxTokens: 400
+    timeoutMs: 180000
+
+# Worker targets for dispatch. \`default\` preserves the legacy behavior when a
+# recipe or request does not specify an override. \`profiles\` are named
+# target/model/thinking choices. \`agentBindings\` pins native Clio agents,
+# including shadow agents such as scout/researcher/provenance, to a profile.
+workers:
+  default:
+    target: null
+    model: null
+    thinkingLevel: off
+  profiles: {}
+  # Example profile entry:
+  # profiles:
+  #   fast-local:
+  #     target: local-lmstudio
+  #     model: your-model-id
+  #     thinkingLevel: off
+  # agentBindings maps agent id -> profiles key, e.g. scout: fast-local.
+  agentBindings: {}
+  maxRetries: 2
+  # onPermission: what a worker does when a tool call needs interactive
+  # permission. "deny" turns it into a structured tool denial and the run
+  # continues; "fail" finalizes the run as failed/permission_required;
+  # "escalate" hands the ask to the interactive operator (timeout fallback
+  # below keeps the run non-stall).
+  onPermission: deny
+  # escalation: bounds for the escalate posture. A parked ask with no operator
+  # decision within timeoutMs applies the fallback deny/fail.
+  escalation:
+    timeoutMs: 120000
+    fallback: deny
+  resilienceCooldownMs: 15000
+
+# Fleet worker nodes reachable over SSH. The implicit \`local\` node always
+# exists and is never declared. A node becomes dispatch-eligible only after
+# \`clio-coder doctor\` verifies SSH reachability, a version-matched clio-coder, path
+# parity for the project root (shared filesystem), and a writable state dir.
+# residency defaults to observe: remote workers never evict models resident
+# on their node (set manage per node to opt into the reconciler).
+fleet:
+  nodes: []
+  # - id: node-a
+  #   host: node-a.example.net
+  #   user: me
+  #   identityFile: ~/.ssh/id_fleet
+  #   labels: [cpu]
+  #   maxWorkers: 2
+  # - id: node-b
+  #   host: node-b.example.net
+  #   maxWorkers: 1
+  #   residency: observe
+
+# Joint route selection is shadow-only unless both the execution role and the
+# requested posture are named here. Manual pins remain exact and fail closed.
+routing:
+  activeRoles: []       # researcher | verifier | reviewer | judge
+  activePostures: []    # quality | balanced | latency | economy
+  # Agent changes remain advisory unless the concrete agent/role pair appears
+  # here. Exact pairs avoid implicitly approving an agents \xD7 roles cross-product.
+  agentAutomation:
+    activeAgentRoles: []
+
+# Alt+J / Alt+K cycling order: plain target ids or "target/model" refs.
+scope: []
+
+# /models focused picker. Favorites are exact "target/model" refs shown before
+# the full search catalog. Recently selected models are runtime state and live
+# in the state dir (recent-models.json), not in this file.
+modelSelector:
+  favorites: []
+  recentLimit: 12
+
+# Session budget guardrails.
+budget:
+  sessionCeilingUsd: 5
+  concurrency: auto           # auto or a positive integer
+
+# Global request defaults applied to every target.
+#   maxTokens  output tokens requested per turn. Always clamped down to the
+#              model's known max-output cap and the remaining context window,
+#              so models that support less automatically get less. Set 0 to
+#              fall back to per-model caps only.
+defaults:
+  maxTokens: 32768
+
+theme: default
+terminal:
+  # OSC 9;4 terminal progress badges are opt-in; some terminals surface these
+  # in taskbars/tabs and keep them visible for long-running agent work.
+  showTerminalProgress: false
+  # Transcript detail: minimal, default, or verbose. Also changeable with /output.
+  outputVerbosity: default
+
+# Skills are local prompt resources. Project-local compatibility roots such as
+# .agents/skills, .claude/skills, .codex/skills, .github/skills, and
+# .opencode/skills stay hidden from model invocation unless this is true or
+# CLIO_CODER_TRUST_PROJECT_SKILLS=1 is set for the process.
+skills:
+  trustProjectCompatRoots: false
+
+# External coding agents that speak Agent Client Protocol v1 over stdio.
+# These are delegated harnesses, not model targets, so they stay outside
+# targets[], orchestrator, workers, and model pickers.
+delegation:
+  defaults:
+    connectTimeoutMs: ${DEFAULT_DELEGATION_CONNECT_TIMEOUT_MS}
+    turnTimeoutMs: ${DEFAULT_DELEGATION_TURN_TIMEOUT_MS}
+    permissionTimeoutMs: ${DEFAULT_DELEGATION_PERMISSION_TIMEOUT_MS}
+    toolGovernance: clio-policy   # clio-policy | agent-managed | deny-all
+  agents: []
+  # OpenCode native ACP:
+  # - id: opencode
+  #   command: opencode
+  #   args: [acp, --cwd, .]
+  #   toolGovernance: clio-policy
+  #   labels:
+  #     specialty: coding
+  #
+  # Codex via an ACP adapter:
+  # - id: codex
+  #   command: npx
+  #   args: [-y, "@agentclientprotocol/codex-acp"]
+  #   toolGovernance: clio-policy
+  #   labels:
+  #     specialty: coding
+  #
+  # Claude Code via its ACP adapter (runs on your Claude Pro/Max subscription;
+  # the claude CLI has no ACP of its own, so this adapter bridges the Claude
+  # Code SDK). Tool calls are gated by Clio safety under clio-policy; switch to
+  # agent-managed to let Claude Code govern its own tools.
+  # - id: claude-code
+  #   command: npx
+  #   args: [-y, "@zed-industries/claude-code-acp"]
+  #   toolGovernance: clio-policy
+  #   labels:
+  #     specialty: coding
+
+keybindings: {}
+
+# Context compaction controls.
+#   auto              master switch for the pre-request compaction trigger.
+#                     Manual /compact always runs the LLM summary.
+#   threshold         pressure = estimated_tokens / context_window. Crossing
+#                     it masks stale tool observations first, then runs a
+#                     full LLM summary if pressure stays above the threshold.
+#   excludeLastTurns  recent user turns protected from observation masking.
+#   model             optional pattern (e.g. provider/summary-model-id) for a
+#                     dedicated summarization model. Absent \u21D2 orchestrator target.
+#   systemPrompt      optional path to a prompt-override file.
+compaction:
+  auto: true
+  threshold: 0.8
+  excludeLastTurns: 6
+  # model: provider/summary-model-id
+  # systemPrompt: ~/.config/clio-coder/prompts/compaction.md
+
+# Transient provider/stream retry controls for interactive chat.
+# Retryable errors include overloads, rate limits, 5xx responses, network
+# resets, and timeouts. Context overflow uses compaction recovery instead.
+# Dispatched worker runs retry under workers.maxRetries, not this block.
+retry:
+  enabled: true
+  maxRetries: 3
+  baseDelayMs: 2000
+  maxDelayMs: 60000
+
+# Guardrails: numeric backstops that bound runaway agent behavior.
+#   turnToolCallBudget          orchestrator per-turn soft tool-call budget;
+#                               the hard interrupt ceiling sits 15 above it.
+#   workerToolCallCap           ceiling on tool calls a dispatched worker may
+#                               execute; the agent recipe's own budget is what
+#                               normally binds, and refused calls never spend it.
+#   maxDispatchRuns             dispatch run-ledger retention cap.
+#   readMaxBytes                per-call byte cap for the read tool.
+#   observationTurnBudgetBytes  shared per-turn byte pool for observation tools.
+#   internalDispatchTimeoutMs   wall-clock cap for one internal generator
+#                               dispatch (wiki documenter, bootstrap scout).
+# Each value also has a per-process env override (CLIO_CODER_TURN_TOOL_CALL_BUDGET,
+# CLIO_CODER_WORKER_TOOL_CALL_CAP, CLIO_CODER_MAX_RUNS, CLIO_CODER_READ_MAX_BYTES,
+# CLIO_CODER_OBSERVATION_TURN_BUDGET_BYTES, CLIO_CODER_INTERNAL_DISPATCH_TIMEOUT_MS) meant
+# for CI and one-off experiments.
+guardrails:
+  turnToolCallBudget: 60
+  workerToolCallCap: 150
+  maxDispatchRuns: 1000
+  readMaxBytes: 51200
+  observationTurnBudgetBytes: 196608
+  internalDispatchTimeoutMs: 900000
+`;
+
+export {
+  GUARDRAIL_DEFAULTS,
+  GUARDRAIL_ENV_VARS,
+  workerSynthesisReserveDirective,
+  workerSynthesisReserveBlockReason,
+  workerToolCallCapExceededReason,
+  isWorkerToolCallCapExceededReason,
+  workerToolCallCapSynthesisReason,
+  isWorkerToolCallCapSynthesisReason,
+  mentionsWorkerToolCallCap,
+  configureGuardrails,
+  resolveGuardrail,
+  THINKING_LEVELS,
+  DEFAULT_DELEGATION_CONNECT_TIMEOUT_MS,
+  DEFAULT_DELEGATION_TURN_TIMEOUT_MS,
+  DEFAULT_DELEGATION_PERMISSION_TIMEOUT_MS,
+  ACTIVE_ROUTING_ROLES,
+  ACTIVE_ROUTING_POSTURES,
+  ACTIVE_AGENT_AUTOMATION_ROLES,
+  DEFAULT_SETTINGS,
+  DEFAULT_SETTINGS_YAML
+};
+//# sourceMappingURL=chunk-UHTSULZS.js.map

package/dist/chunk-UU3R62TT.js

@@ -0,0 +1,128 @@
+import {
+  settingsPath,
+  validateSettings
+} from "./chunk-JWHCJDCI.js";
+
+// src/core/settings-layers.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+var CREDENTIAL_KEYS = /* @__PURE__ */ new Set(["auth", "apikey", "api_key", "token", "secret", "password"]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readRawLayer(origin, path, issues) {
+  if (!existsSync(path)) return { origin, path, blob: void 0 };
+  let parsed;
+  try {
+    parsed = parseYaml(readFileSync(path, "utf8"));
+  } catch (err) {
+    issues.push({ origin, path, message: `invalid YAML: ${err instanceof Error ? err.message : String(err)}` });
+    return { origin, path, blob: void 0 };
+  }
+  if (parsed === null || parsed === void 0) return { origin, path, blob: {} };
+  if (!isRecord(parsed)) {
+    issues.push({ origin, path, message: "settings file must be a mapping at the root" });
+    return { origin, path, blob: void 0 };
+  }
+  return { origin, path, blob: parsed };
+}
+function stripCredentials(value, origin, path, issues) {
+  if (Array.isArray(value)) {
+    return value.map((item, index) => stripCredentials(item, origin, `${path}[${index}]`, issues));
+  }
+  if (!isRecord(value)) return value;
+  const out = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (CREDENTIAL_KEYS.has(key.toLowerCase())) {
+      issues.push({
+        origin,
+        path: path ? `${path}.${key}` : key,
+        message: "credentials are not allowed in project settings; key ignored"
+      });
+      continue;
+    }
+    out[key] = stripCredentials(child, origin, path ? `${path}.${key}` : key, issues);
+  }
+  return out;
+}
+function mergeLayersWithSources(layers) {
+  const merged = {};
+  const sources = {};
+  for (const layer of layers) {
+    if (layer.blob === void 0) continue;
+    mergeInto(merged, layer.blob, layer.origin, "", sources);
+  }
+  return { merged, sources };
+}
+function mergeInto(target, source, origin, prefix, sources) {
+  for (const [key, value] of Object.entries(source)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (isRecord(value)) {
+      const existing = target[key];
+      const nested = isRecord(existing) ? existing : {};
+      mergeInto(nested, value, origin, path, sources);
+      target[key] = nested;
+      sources[path] = origin;
+    } else {
+      target[key] = Array.isArray(value) ? [...value] : value;
+      sources[path] = origin;
+    }
+  }
+}
+function readLayeredSettings(cwd, options = {}) {
+  const issues = [];
+  const userFile = options.userPath ?? settingsPath();
+  const projectFile = join(cwd, ".clio-coder", "settings.yaml");
+  const localFile = join(cwd, ".clio-coder", "settings.local.yaml");
+  const user = readRawLayer("user", userFile, issues);
+  const projectRaw = readRawLayer("project", projectFile, issues);
+  const localRaw = readRawLayer("project.local", localFile, issues);
+  const project = {
+    ...projectRaw,
+    blob: projectRaw.blob === void 0 ? void 0 : stripCredentials(projectRaw.blob, "project", "", issues)
+  };
+  const local = {
+    ...localRaw,
+    blob: localRaw.blob === void 0 ? void 0 : stripCredentials(localRaw.blob, "project.local", "", issues)
+  };
+  const { merged, sources } = mergeLayersWithSources([user, project, local]);
+  const validation = validateSettings(merged);
+  for (const issue of validation.issues) {
+    issues.push({ origin: settingsSourceFor(sources, issue.path), path: issue.path, message: issue.message });
+  }
+  return {
+    settings: validation.settings,
+    sources,
+    issues,
+    layers: [
+      { origin: "built-in", path: "(defaults)", present: true },
+      { origin: "user", path: userFile, present: user.blob !== void 0 },
+      { origin: "project", path: projectFile, present: projectRaw.blob !== void 0 },
+      { origin: "project.local", path: localFile, present: localRaw.blob !== void 0 }
+    ]
+  };
+}
+function settingsSourceFor(sources, keyPath) {
+  let prefix = keyPath;
+  while (prefix.length > 0) {
+    const direct = sources[prefix];
+    if (direct) return direct;
+    const bracket = prefix.lastIndexOf("[");
+    if (bracket >= 0) {
+      const arrayKey = prefix.slice(0, bracket);
+      const hit = sources[arrayKey];
+      if (hit) return hit;
+    }
+    const dot = prefix.lastIndexOf(".");
+    if (dot < 0) break;
+    prefix = prefix.slice(0, dot);
+  }
+  return "built-in";
+}
+
+export {
+  readLayeredSettings,
+  settingsSourceFor
+};
+//# sourceMappingURL=chunk-UU3R62TT.js.map