@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-W5RM7YAH.js

@@ -1,78 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/core/bus-events.ts
-init_esm_shims();
-var BusChannels = {
-  SessionStart: "session.start",
-  SessionEnd: "session.end",
-  SessionParked: "session.parked",
-  SessionResumed: "session.resumed",
-  SessionTurnSwitched: "session.turn_switched",
-  DomainLoaded: "domain.loaded",
-  DomainFailed: "domain.failed",
-  ConfigHotReload: "config.hotReload",
-  ConfigNextTurn: "config.nextTurn",
-  ConfigRestartRequired: "config.restartRequired",
-  ConfigReloadFailed: "config.reloadFailed",
-  PermissionRequested: "permission.requested",
-  PermissionResolved: "permission.resolved",
-  SafetyClassified: "safety.classified",
-  SafetyBlocked: "safety.blocked",
-  SafetyAllowed: "safety.allowed",
-  LoopBlocked: "safety.loopBlocked",
-  ToolBudgetExceeded: "safety.toolBudgetExceeded",
-  ProviderHealth: "provider.health",
-  RuntimeNotice: "runtime.notice",
-  ResidencyMutation: "residency.mutation",
-  DispatchScopeNotice: "dispatch.scopeNotice",
-  DispatchEnqueued: "dispatch.enqueued",
-  DispatchStarted: "dispatch.started",
-  DispatchProgress: "dispatch.progress",
-  DispatchCompleted: "dispatch.completed",
-  DispatchFailed: "dispatch.failed",
-  AccountabilityEvidenceReady: "accountability.evidenceReady",
-  CompactionBegin: "compaction.begin",
-  CompactionEnd: "compaction.end",
-  MiddlewareHookFailed: "middleware.hookFailed",
-  ExtensionsReloaded: "extensions.reloaded",
-  PluginsReloaded: "plugins.reloaded",
-  ExtensionsLoadIssue: "extensions.loadIssue",
-  ContextActivity: "context.activity",
-  ContextSourcesChanged: "context.sourcesChanged",
-  ContextWarning: "context.warning",
-  ContextPruned: "context.pruned",
-  ContextRecalled: "context.recalled",
-  MemoryStepCompleted: "memory.stepCompleted",
-  AgentStatusChanged: "agent.status.changed",
-  RunAborted: "run.aborted",
-  BudgetAlert: "budget.alert",
-  ShutdownRequested: "shutdown.requested",
-  ShutdownDrained: "shutdown.drained",
-  ShutdownTerminated: "shutdown.terminated",
-  ShutdownPersisted: "shutdown.persisted"
-};
-var RUN_ABORT_SOURCES = /* @__PURE__ */ new Set([
-  "dispatch_abort",
-  "dispatch_drain",
-  "stream_cancel",
-  "loop_guard"
-]);
-function isRunAbortedPayload(value) {
-  if (!value || typeof value !== "object") return false;
-  const p = value;
-  if (typeof p.source !== "string" || !RUN_ABORT_SOURCES.has(p.source)) return false;
-  if (p.runId !== null && typeof p.runId !== "string") return false;
-  if (p.startedAt !== null && typeof p.startedAt !== "string") return false;
-  if (p.elapsedMs !== null && typeof p.elapsedMs !== "number") return false;
-  if (p.reason !== void 0 && typeof p.reason !== "string") return false;
-  return true;
-}
-
-export {
-  BusChannels,
-  isRunAbortedPayload
-};
-//# sourceMappingURL=chunk-W5RM7YAH.js.map

package/dist/chunk-W72LLZAV.js

@@ -1,243 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  captureProjectSurface,
-  projectSurfaceTrustNotice
-} from "./chunk-X6FLVUM5.js";
-import {
-  SettingsValidationError,
-  applySettingsDelta,
-  settingsPath,
-  updateSavedSettingsDocument,
-  validateSettings
-} from "./chunk-FPS4R2RN.js";
-import {
-  require_dist
-} from "./chunk-B5GGDIHT.js";
-import {
-  __toESM,
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/core/settings-layers.ts
-init_esm_shims();
-var import_yaml = __toESM(require_dist(), 1);
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-var STRICT_USER_ISSUES = /* @__PURE__ */ Symbol("strict-user-issues");
-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 deepEquals(a, b) {
-  if (a === b) return true;
-  if (Array.isArray(a) || Array.isArray(b)) {
-    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
-    return a.every((entry, index) => deepEquals(entry, b[index]));
-  }
-  if (!isRecord(a) || !isRecord(b)) return false;
-  const keys = Object.keys(a);
-  if (keys.length !== Object.keys(b).length) return false;
-  return keys.every((key) => key in b && deepEquals(a[key], b[key]));
-}
-function readRawLayer(origin, path, issues, capturedText) {
-  if (capturedText === void 0 && !existsSync(path)) return { origin, path, blob: void 0 };
-  let text;
-  try {
-    text = capturedText ?? readFileSync(path, "utf8");
-  } catch (err) {
-    issues.push({
-      origin,
-      path: "(root)",
-      message: `unreadable: ${err instanceof Error ? err.message : String(err)}`,
-      kind: "unreadable"
-    });
-    return { origin, path, blob: void 0 };
-  }
-  let parsed;
-  try {
-    parsed = (0, import_yaml.parse)(text);
-  } catch (err) {
-    issues.push({
-      origin,
-      path: "(root)",
-      message: `invalid YAML: ${err instanceof Error ? err.message : String(err)}`,
-      kind: "syntax"
-    });
-    return { origin, path, blob: void 0 };
-  }
-  if (parsed === null || parsed === void 0) return { origin, path, blob: {} };
-  if (!isRecord(parsed)) {
-    issues.push({ origin, path: "(root)", 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 prepareProjectLayers(cwd, issues) {
-  const projectFile = join(cwd, ".clio-coder", "settings.yaml");
-  const localFile = join(cwd, ".clio-coder", "settings.local.yaml");
-  const snapshot = captureProjectSurface(cwd, "settings");
-  const readProjectLayer = (origin, path, file) => {
-    if (file?.error !== void 0) issues.push({ origin, path, message: file.error, kind: "unreadable" });
-    if (file?.text === null || file === void 0) return { origin, path, blob: void 0 };
-    if (snapshot.verdict !== "trusted") {
-      issues.push({ origin, path, message: projectSurfaceTrustNotice(snapshot, file.path) });
-      return { origin, path, blob: void 0 };
-    }
-    return readRawLayer(origin, path, issues, file.text);
-  };
-  const projectRaw = readProjectLayer("project", projectFile, snapshot.files[0]);
-  const localRaw = readProjectLayer("project.local", localFile, snapshot.files[1]);
-  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)
-  };
-  return { projectFile, localFile, projectRaw, localRaw, project, local };
-}
-function validateLayerStack(user, prepared, issues) {
-  const { merged, sources } = mergeLayersWithSources([user, prepared.project, prepared.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 };
-}
-function readLayeredSettings(cwd, options = {}) {
-  const issues = [];
-  const userFile = options.userPath ?? settingsPath();
-  const user = readRawLayer("user", userFile, issues);
-  const prepared = prepareProjectLayers(cwd, issues);
-  const { settings, sources } = validateLayerStack(user, prepared, issues);
-  const strictUserIssues = user.blob === void 0 ? [] : validateSettings(user.blob).issues.map((issue) => ({
-    path: issue.path,
-    message: issue.message,
-    ...issue.kind ? { kind: issue.kind } : {}
-  }));
-  return {
-    settings,
-    sources,
-    issues,
-    layers: [
-      { origin: "built-in", path: "(defaults)", present: true },
-      { origin: "user", path: userFile, present: user.blob !== void 0 },
-      { origin: "project", path: prepared.projectFile, present: prepared.projectRaw.blob !== void 0 },
-      { origin: "project.local", path: prepared.localFile, present: prepared.localRaw.blob !== void 0 }
-    ],
-    [STRICT_USER_ISSUES]: strictUserIssues
-  };
-}
-function readStrictLayeredSettings(cwd, options = {}) {
-  const layered = readLayeredSettings(cwd, options);
-  const reportedUserIssues = layered.issues.filter((issue) => issue.origin === "user").map(({ path, message, kind }) => ({ path, message, ...kind ? { kind } : {} }));
-  const userIssues = [...reportedUserIssues, ...layered[STRICT_USER_ISSUES]].filter(
-    (issue, index, all) => all.findIndex(
-      (candidate) => candidate.path === issue.path && candidate.message === issue.message && candidate.kind === issue.kind
-    ) === index
-  );
-  if (userIssues.length > 0) throw new SettingsValidationError(userIssues);
-  return layered;
-}
-function updateLayeredSettings(cwd, mutate) {
-  let committed = null;
-  updateSavedSettingsDocument((saved) => {
-    const userValidation = validateSettings(saved);
-    if (userValidation.issues.length > 0) throw new SettingsValidationError(userValidation.issues);
-    const issues = [];
-    const prepared = prepareProjectLayers(cwd, issues);
-    const user = {
-      origin: "user",
-      path: settingsPath(),
-      blob: isRecord(saved) ? saved : {}
-    };
-    const before = validateLayerStack(user, prepared, issues).settings;
-    const candidate = structuredClone(before);
-    const next = mutate(candidate) ?? candidate;
-    const candidateValidation = validateSettings(JSON.parse(JSON.stringify(next)));
-    if (candidateValidation.issues.length > 0) throw new SettingsValidationError(candidateValidation.issues);
-    const nextSaved = applySettingsDelta(saved, before, candidateValidation.settings);
-    const finalIssues = [];
-    const final = validateLayerStack(
-      { origin: "user", path: settingsPath(), blob: isRecord(nextSaved) ? nextSaved : {} },
-      prepared,
-      finalIssues
-    ).settings;
-    if (!deepEquals(final, candidateValidation.settings)) {
-      throw new Error("a higher-precedence project setting prevents this settings update");
-    }
-    committed = final;
-    return nextSaved;
-  });
-  if (committed === null) throw new Error("layered settings update did not commit");
-  return committed;
-}
-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,
-  readStrictLayeredSettings,
-  updateLayeredSettings,
-  settingsSourceFor
-};
-//# sourceMappingURL=chunk-W72LLZAV.js.map

package/dist/chunk-WGRDABW7.js

@@ -1,207 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  loadSkills,
-  parseAgentRecipeSchema,
-  recipeIdFromPath
-} from "./chunk-7FBCRWVT.js";
-import {
-  enabledPluginResourceRoots,
-  parseFrontmatter,
-  resolvePackageReferences
-} from "./chunk-6UJ7RDI7.js";
-import {
-  assertAgentSpecPolicy,
-  isShadowAgent,
-  normalizeAgentSpec
-} from "./chunk-I47EJPYL.js";
-import {
-  readSettings
-} from "./chunk-FPS4R2RN.js";
-import {
-  clioConfigDir
-} from "./chunk-CTTI7G3T.js";
-import {
-  resolvePackageRoot
-} from "./chunk-E3LEPLQ2.js";
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/domains/agents/registry.ts
-init_esm_shims();
-import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
-import path from "node:path";
-var RESERVED_CUSTOM_AGENT_IDS = /* @__PURE__ */ new Set(["worker", "delegate", "auto"]);
-var MAX_AGENT_RECIPE_DIAGNOSTICS = 256;
-function recordDiagnostic(diagnostics, diagnostic) {
-  if (diagnostics.length < MAX_AGENT_RECIPE_DIAGNOSTICS) diagnostics.push(diagnostic);
-}
-function resolveBoundSkills(recipe, source) {
-  if (recipe.skills.length === 0) return { ...recipe, boundSkillPaths: [] };
-  const packageSkills = path.resolve(source.dir, "..", "..", "..", "..", "library", "skills");
-  if (source.source === "plugin" && source.skillRoot === void 0) {
-    throw new Error(
-      `agent recipe: ${recipe.filepath}: ${source.source} declares bound skills but no skills resource root`
-    );
-  }
-  const skills = source.source === "plugin" ? loadSkills({
-    cwd: source.cwd ?? process.cwd(),
-    trustProjectCompatRoots: readSettings().integrations.projectResources.trustProjectImports,
-    disableDiscovery: true,
-    explicitSkillPaths: source.skillRoot === void 0 ? [] : [source.skillRoot]
-  }) : loadSkills({
-    cwd: source.cwd ?? process.cwd(),
-    trustProjectCompatRoots: readSettings().integrations.projectResources.trustProjectImports,
-    ...source.source === "builtin" && existsSync(packageSkills) ? { explicitSkillPaths: [packageSkills] } : {}
-  });
-  if (source.source === "plugin" && source.skillRoot !== void 0) {
-    const canonicalRoot = realpathSync(source.skillRoot);
-    for (const skill of skills.items) {
-      const relative = path.relative(canonicalRoot, realpathSync(skill.filePath));
-      if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-        throw new Error(`agent recipe: ${recipe.filepath}: bound skill escapes its ${source.source}: ${skill.filePath}`);
-      }
-    }
-  }
-  const byName = new Map(skills.items.filter((skill) => skill.trusted).map((skill) => [skill.name, skill.filePath]));
-  const missing = recipe.skills.filter((skill) => !byName.has(skill));
-  if (missing.length > 0) {
-    throw new Error(`agent recipe: ${recipe.filepath}: bound skill(s) unavailable: ${missing.join(", ")}`);
-  }
-  const boundSkillPaths = recipe.skills.map((skill) => {
-    const filePath = byName.get(skill);
-    if (filePath === void 0) throw new Error(`agent recipe: ${recipe.filepath}: bound skill unavailable: ${skill}`);
-    return filePath;
-  });
-  return { ...recipe, boundSkillPaths };
-}
-function loadRecipesFromDir(source, diagnostics = []) {
-  let entries;
-  try {
-    entries = readdirSync(source.dir, { withFileTypes: true });
-  } catch (err) {
-    const error = err;
-    if (error.code === "ENOENT" || error.code === "ENOTDIR") return [];
-    throw err;
-  }
-  const recipes = [];
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filepath = path.join(source.dir, entry.name);
-    try {
-      const id = recipeIdFromPath(filepath, source.dir);
-      const raw = readFileSync(filepath, "utf8");
-      const { frontmatter, body: rawBody } = parseFrontmatter(raw, filepath);
-      const body = resolvePackageReferences(rawBody, {
-        ...source.rootPath ? { rootPath: source.rootPath } : {},
-        plugin: source.source === "plugin"
-      });
-      const parsedRecipe = parseAgentRecipeSchema({ id, source: source.source, filepath, body, frontmatter });
-      const recipe = resolveBoundSkills(parsedRecipe, source);
-      assertAgentSpecPolicy(normalizeAgentSpec(recipe));
-      recipes.push(recipe);
-    } catch (error) {
-      if (source.source === "builtin") throw error;
-      const message = error instanceof Error ? error.message : String(error);
-      recordDiagnostic(diagnostics, { kind: "quarantine", source: source.source, filepath, message });
-      process.stderr.write(`[clio-coder:agents] quarantine path=${filepath} source=${source.source} reason=${message}
-`);
-    }
-  }
-  recipes.sort((left, right) => left.id.localeCompare(right.id));
-  return recipes;
-}
-function mergeRecipes(diagnostics, ...sources) {
-  const ignored = (recipe, reason) => {
-    process.stderr.write(`[clio-coder:agents] ignore id=${recipe.id} by=${recipe.source} reason=${reason}
-`);
-    recordDiagnostic(diagnostics, {
-      kind: "ignored",
-      id: recipe.id,
-      source: recipe.source,
-      audience: recipe.audience,
-      filepath: recipe.filepath,
-      message: `agent recipe ${recipe.id} from ${recipe.source} ignored: ${reason}`
-    });
-  };
-  const byId = /* @__PURE__ */ new Map();
-  const builtinById = /* @__PURE__ */ new Map();
-  for (const group of sources) {
-    for (const recipe of group) {
-      if (recipe.source === "builtin") builtinById.set(recipe.id, recipe);
-    }
-  }
-  for (const group of sources) {
-    for (const recipe of group) {
-      if (recipe.source !== "builtin" && RESERVED_CUSTOM_AGENT_IDS.has(recipe.id)) {
-        ignored(recipe, "reserved-agent-id");
-        continue;
-      }
-      const builtin = builtinById.get(recipe.id);
-      if (recipe.source === "plugin" && builtin) {
-        ignored(recipe, "reserved-builtin");
-        continue;
-      }
-      if (recipe.source === "user" && builtin && isShadowAgent(normalizeAgentSpec(builtin))) {
-        ignored(recipe, "reserved-shadow");
-        continue;
-      }
-      if (recipe.source === "project" && builtin) {
-        ignored(recipe, "reserved-builtin");
-        continue;
-      }
-      const previous = byId.get(recipe.id);
-      if (previous) {
-        process.stderr.write(`[clio-coder:agents] override id=${recipe.id} by=${recipe.source}
-`);
-        recordDiagnostic(diagnostics, {
-          kind: "overridden",
-          id: previous.id,
-          source: previous.source,
-          audience: previous.audience,
-          by: recipe.source,
-          filepath: previous.filepath,
-          message: `agent recipe ${previous.id} from ${previous.source} overridden by ${recipe.source}`
-        });
-      }
-      byId.set(recipe.id, recipe);
-    }
-  }
-  return Array.from(byId.values()).sort((left, right) => left.id.localeCompare(right.id));
-}
-function discoverAgentRecipes(cwd = process.cwd(), diagnostics = []) {
-  const builtin = loadRecipesFromDir(
-    {
-      dir: path.join(resolvePackageRoot(), "src", "domains", "agents", "builtins"),
-      source: "builtin",
-      cwd
-    },
-    diagnostics
-  );
-  const skillRoots = new Map(enabledPluginResourceRoots("skills", cwd).map((root) => [root.source, root.path]));
-  const pluginRecipes = enabledPluginResourceRoots("agents", cwd).sort((left, right) => left.source.localeCompare(right.source)).map((root) => {
-    const skillRoot = skillRoots.get(root.source);
-    return loadRecipesFromDir(
-      {
-        dir: root.path,
-        source: "plugin",
-        rootPath: root.rootPath,
-        cwd,
-        origin: root.source,
-        ...skillRoot === void 0 ? {} : { skillRoot }
-      },
-      diagnostics
-    );
-  });
-  const user = loadRecipesFromDir({ dir: path.join(clioConfigDir(), "agents"), source: "user", cwd }, diagnostics);
-  const project = loadRecipesFromDir(
-    { dir: path.join(cwd, ".clio-coder", "agents"), source: "project", cwd },
-    diagnostics
-  );
-  return mergeRecipes(diagnostics, builtin, ...pluginRecipes, user, project);
-}
-
-export {
-  discoverAgentRecipes
-};
-//# sourceMappingURL=chunk-WGRDABW7.js.map

package/dist/chunk-WWRV5RJI.js

@@ -1,165 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  withStateFileLock
-} from "./chunk-DVJL77SO.js";
-import {
-  codewikiNeedsBackfill,
-  codewikiPath,
-  readCodewiki,
-  writeCodewiki
-} from "./chunk-W2RJEH6Q.js";
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/domains/context/codewiki/coordinator.ts
-init_esm_shims();
-import { existsSync } from "node:fs";
-import { createRequire } from "node:module";
-import { resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import { Worker } from "node:worker_threads";
-var BUILD_TIMEOUT_MS = 12e4;
-var workspaceTails = /* @__PURE__ */ new Map();
-var require2 = createRequire(import.meta.url);
-function buildWorkerUrl() {
-  if (!import.meta.url.endsWith(".ts")) return new URL("./codewiki/build-worker.js", import.meta.url);
-  const loaderApi = pathToFileURL(require2.resolve("tsx/esm/api")).href;
-  const source = new URL("./build-worker.ts", import.meta.url).href;
-  return new URL(
-    `data:text/javascript,${encodeURIComponent(`const { tsImport } = await import(${JSON.stringify(loaderApi)}); await tsImport(${JSON.stringify(source)}, import.meta.url);`)}`
-  );
-}
-function artifactRef(current) {
-  return {
-    source: "artifact",
-    needsBackfill: codewikiNeedsBackfill(current),
-    loc: current.files.reduce((sum, file) => file.lang === "config" ? sum : sum + file.loc, 0)
-  };
-}
-function byReference(request, held) {
-  if (request.kind === "build" || request.current === null || "source" in request.current) return request;
-  if (held === null || request.current !== held) return request;
-  return { ...request, current: artifactRef(held) };
-}
-async function executeInWorker(request) {
-  const worker = new Worker(buildWorkerUrl(), { workerData: request, execArgv: [] });
-  let exited = false;
-  const exit = new Promise((resolve2) => {
-    worker.once("exit", () => {
-      exited = true;
-      resolve2();
-    });
-  });
-  let timer;
-  try {
-    return await new Promise((resolve2, reject) => {
-      let settled = false;
-      const finish = (callback) => {
-        if (settled) return;
-        settled = true;
-        if (timer) clearTimeout(timer);
-        callback();
-      };
-      timer = setTimeout(() => {
-        finish(() => reject(new Error(`codewiki build worker exceeded ${BUILD_TIMEOUT_MS} ms`)));
-      }, BUILD_TIMEOUT_MS);
-      timer.unref();
-      worker.once("message", (message) => {
-        finish(() => {
-          if (message.ok) resolve2(message.result);
-          else {
-            const error = new Error(message.error);
-            if (message.stack) error.stack = message.stack;
-            reject(error);
-          }
-        });
-      });
-      worker.once(
-        "error",
-        (error) => finish(() => {
-          reject(error);
-        })
-      );
-      worker.once("exit", (code) => {
-        if (code !== 0)
-          finish(() => {
-            reject(new Error(`codewiki build worker exited with code ${code}`));
-          });
-      });
-    });
-  } finally {
-    if (timer) clearTimeout(timer);
-    if (!exited) {
-      await Promise.race([
-        exit,
-        new Promise((resolve2) => {
-          const grace = setTimeout(resolve2, 250);
-          grace.unref();
-        })
-      ]);
-    }
-    if (!exited) await worker.terminate().catch(() => void 0);
-  }
-}
-function enqueueWorkspace(cwd, task) {
-  const key = codewikiPath(cwd);
-  const previous = workspaceTails.get(key) ?? Promise.resolve();
-  const result = previous.catch(() => void 0).then(task);
-  const tail = result.then(
-    () => void 0,
-    () => void 0
-  );
-  workspaceTails.set(key, tail);
-  void tail.finally(() => {
-    if (workspaceTails.get(key) === tail) workspaceTails.delete(key);
-  });
-  return result;
-}
-function coordinateCodewikiWrite(cwd, select, options = {}) {
-  const workspace = resolve(cwd);
-  return enqueueWorkspace(workspace, () => {
-    if (options.requireExisting && !existsSync(codewikiPath(workspace))) return Promise.resolve(null);
-    return withStateFileLock(codewikiPath(workspace), async () => {
-      if (options.requireExisting && !existsSync(codewikiPath(workspace))) return null;
-      const current = options.readCurrent?.(workspace) ?? readCodewiki(workspace);
-      const request = await select(current, workspace);
-      if (!request) return null;
-      const outcome = await executeInWorker(byReference({ ...request, cwd: workspace }, current));
-      const codewiki = outcome.codewiki ?? current;
-      if (!codewiki) throw new Error("codewiki reconciliation returned no artifact");
-      const worker = { codewiki, fingerprint: outcome.fingerprint, changed: outcome.changed };
-      await options.beforeCommit?.(worker, workspace);
-      const wrote = worker.changed || !existsSync(codewikiPath(workspace));
-      if (wrote) writeCodewiki(workspace, worker.codewiki);
-      await options.afterCommit?.(worker, workspace);
-      return { codewiki: !worker.changed && current ? current : worker.codewiki, worker, wrote };
-    });
-  });
-}
-function coordinateCodewikiExclusive(cwd, task) {
-  const workspace = resolve(cwd);
-  return enqueueWorkspace(workspace, () => withStateFileLock(codewikiPath(workspace), () => task(workspace)));
-}
-async function buildCodewikiCandidate(cwd, language) {
-  const outcome = await executeInWorker({ kind: "build", cwd: resolve(cwd), language });
-  if (!outcome.codewiki) throw new Error("codewiki build returned no artifact");
-  return { codewiki: outcome.codewiki, fingerprint: outcome.fingerprint, changed: outcome.changed };
-}
-async function drainCodewikiWrites(cwd) {
-  const workspace = resolve(cwd);
-  for (; ; ) {
-    const tail = workspaceTails.get(codewikiPath(workspace));
-    if (!tail) return;
-    await tail;
-    if (workspaceTails.get(codewikiPath(workspace)) === tail) return;
-  }
-}
-
-export {
-  coordinateCodewikiWrite,
-  coordinateCodewikiExclusive,
-  buildCodewikiCandidate,
-  drainCodewikiWrites
-};
-//# sourceMappingURL=chunk-WWRV5RJI.js.map