@agimon-ai/po-config 0.0.0-alpha.0

package/dist/harnessStore-CltwLB7M.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"harnessStore-CltwLB7M.mjs","names":[],"sources":["../src/models/harnessCache.ts","../src/services/harnessStore/index.ts"],"sourcesContent":["import type { HarnessState } from '../types/config';\n\nexport interface LoadedHarnessState {\n  /** Undefined when this process is running off the environment fallback. */\n  filePath?: string;\n  owned: boolean;\n  state: HarnessState;\n}\n\nexport interface CachedHarnessState extends LoadedHarnessState {\n  /** The file's mtime when it was read, so a rewrite by another copy is noticed. */\n  mtimeMs?: number;\n}\n\nexport const harnessCache: { loaded: CachedHarnessState | undefined } = { loaded: undefined };\n","import fs from 'node:fs';\nimport os from 'node:os';\nimport path from 'node:path';\n\nimport { readDoomSessionEnvironment } from '@agimon-ai/po-core/cordisHost';\n\nimport { harnessCache, type CachedHarnessState, type LoadedHarnessState } from '../../models/harnessCache';\nimport type { HarnessState } from '../../types/config';\nimport { writePrivateAtomicJson } from '../atomicJson';\nimport {\n  HARNESS_STATE_KEYS,\n  projectHarnessEnvironment,\n  readHarnessState,\n  type HarnessStateParseReporter,\n} from '../harnessState';\n\n/**\n * Who owns the harness state, and where it lives.\n *\n * The state used to be the environment: twenty variables that every reader\n * re-parsed and every writer mutated globally. The file is the authority now,\n * and the environment is a projection published for the readers that can only\n * see an environment, which are bash hooks, the shell launchers, packages that\n * do not depend on this one, and any process spawned by any of them.\n *\n * OWNERSHIP IS PER PROCESS, AND THAT IS THE WHOLE DESIGN:\n * Doom Team subagents run detached, in their own process group, from an\n * environment snapshot taken at spawn. A child can outlive its parent. If it\n * shared the parent's file it would corrupt a session it does not own, and if\n * that file sat in the parent's run directory the parent's shutdown sweep would\n * delete it from under a live run. So every process writes a file it owns:\n * `owner.pid` records who, and a process that finds someone else's file copies\n * it before its first write.\n *\n * AVOID:\n * - Treating the file as shared mutable state between processes. Atomic writes\n *   prevent torn reads, not lost updates\n * - Reading the environment directly for anything this exposes\n */\n\n/** Points at the state file. The one variable that is not derived. */\nexport const HARNESS_STATE_POINTER = 'PO_STATE';\n\nconst STATE_FILE_VERSION = 1;\nconst STATE_FILE_NAME = 'harness-state.json';\nconst ADOPTED_DIRECTORY = 'doom-harness';\n/**\n * Written for a process that does not exist yet, so the first one to read it\n * owns it. A spawner cannot know its child's pid, and a child that inherited\n * its parent's file would lose it the moment the parent cleaned up.\n */\nconst UNCLAIMED_OWNER = 0;\n\nexport interface HarnessStateFile {\n  version: number;\n  owner: { pid: number; startedAt: string };\n  state: HarnessState;\n}\n\nexport interface HarnessStateTransactionSnapshot {\n  readonly filePath?: string;\n  readonly owned: boolean;\n  readonly state: HarnessState;\n  readonly environment: Readonly<Record<string, string | undefined>>;\n}\n\n/** Drops the cached state. For tests, and for a process changing identity. */\nexport function resetHarnessStore(): void {\n  harnessCache.loaded = undefined;\n}\n\nfunction fileMtime(filePath: string): number | undefined {\n  try {\n    return fs.statSync(filePath).mtimeMs;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Whether the cache still describes what the process points at.\n *\n * A session can load more than one copy of this package (a layer package\n * installed under .pi/npm brings its own), and each copy caches on its own.\n * The pointer and the file are shared, so a switch persisted through one copy\n * moves the pointer or rewrites the file, and every other copy must notice\n * rather than answer from memory.\n */\nfunction cacheCurrent(cache: CachedHarnessState, environment: NodeJS.ProcessEnv): boolean {\n  const pointer = environment[HARNESS_STATE_POINTER];\n  if (cache.filePath !== pointer) return false;\n  if (!cache.filePath) return true;\n  try {\n    return fs.statSync(cache.filePath).mtimeMs === cache.mtimeMs;\n  } catch {\n    return false;\n  }\n}\n\nfunction parseStateFile(source: string, filePath: string): HarnessStateFile {\n  const parsed = JSON.parse(source) as Partial<HarnessStateFile>;\n  if (parsed.version !== STATE_FILE_VERSION) {\n    throw new Error(\n      `Harness state at ${filePath} has version ${String(parsed.version)}, expected ${STATE_FILE_VERSION}`,\n    );\n  }\n  if (typeof parsed.state !== 'object' || parsed.state === null) {\n    throw new Error(`Harness state at ${filePath} has no state object`);\n  }\n  return {\n    version: STATE_FILE_VERSION,\n    owner: { pid: parsed.owner?.pid ?? -1, startedAt: parsed.owner?.startedAt ?? '' },\n    state: parsed.state as HarnessState,\n  };\n}\n\n/**\n * Reads the state for this process, once.\n *\n * A missing pointer means nobody wrote a file for this process, so the\n * environment is all there is: a nested run, a third-party spawn, or a caller\n * older than the store. A pointer that cannot be read is reported and then\n * treated the same way, because a session that starts degraded beats a session\n * that does not start at all.\n */\nexport function loadHarnessState(\n  environment: NodeJS.ProcessEnv = process.env,\n  report?: HarnessStateParseReporter,\n): LoadedHarnessState {\n  // The cache describes this process. Asking about another environment is a\n  // question about another process, so it reads through rather than answering\n  // from what this one happens to hold.\n  const cacheable = environment === process.env;\n  if (cacheable && harnessCache.loaded && cacheCurrent(harnessCache.loaded, environment)) return harnessCache.loaded;\n\n  const filePath = environment[HARNESS_STATE_POINTER];\n  let result: CachedHarnessState | undefined;\n  if (filePath && fs.existsSync(filePath)) {\n    try {\n      const file = parseStateFile(fs.readFileSync(filePath, 'utf8'), filePath);\n      const owned = file.owner.pid === process.pid || file.owner.pid === UNCLAIMED_OWNER;\n      result = { filePath, owned, state: file.state, mtimeMs: fileMtime(filePath) };\n    } catch (error) {\n      report?.(HARNESS_STATE_POINTER, error);\n    }\n  }\n  result ??= { owned: false, state: readHarnessState(environment, report) };\n  if (cacheable) harnessCache.loaded = result;\n  return result;\n}\n\n/** Captures the owned state pointer and every projected harness variable. */\nexport function snapshotHarnessState(environment: NodeJS.ProcessEnv = process.env): HarnessStateTransactionSnapshot {\n  const loadedState = loadHarnessState(environment);\n  const environmentSnapshot: Record<string, string | undefined> = {\n    [HARNESS_STATE_POINTER]: environment[HARNESS_STATE_POINTER],\n  };\n  for (const key of Object.values(HARNESS_STATE_KEYS)) environmentSnapshot[key] = environment[key];\n  return {\n    filePath: loadedState.filePath,\n    owned: loadedState.owned,\n    state: structuredClone(loadedState.state),\n    environment: environmentSnapshot,\n  };\n}\n\n/** Restores a snapshot only while the current process still owns its state pointer. */\nexport function restoreHarnessStateSnapshot(\n  snapshot: HarnessStateTransactionSnapshot,\n  environment: NodeJS.ProcessEnv = process.env,\n): void {\n  const current = loadHarnessState(environment);\n  if (snapshot.filePath && snapshot.owned) {\n    if (!current.owned || current.filePath !== snapshot.filePath) {\n      throw new Error('Harness state ownership changed; refusing to restore an older snapshot.');\n    }\n    persist(snapshot.filePath, snapshot.state);\n  } else if (!snapshot.filePath) {\n    if (current.filePath && !current.owned) {\n      throw new Error('Harness state is no longer owned by this process; refusing to restore an older snapshot.');\n    }\n    if (current.filePath && current.owned) fs.rmSync(current.filePath, { force: true });\n    resetHarnessStore();\n  } else if (current.filePath !== snapshot.filePath) {\n    throw new Error('Harness state pointer changed; refusing to restore an older snapshot.');\n  }\n  for (const [key, value] of Object.entries(snapshot.environment)) {\n    if (value === undefined) delete environment[key];\n    else environment[key] = value;\n  }\n  if (environment === process.env) {\n    harnessCache.loaded = snapshot.filePath\n      ? {\n          filePath: snapshot.filePath,\n          owned: snapshot.owned,\n          state: snapshot.state,\n          mtimeMs: fileMtime(snapshot.filePath),\n        }\n      : undefined;\n  }\n}\n\nexport function getHarnessState(report?: HarnessStateParseReporter): HarnessState {\n  return loadHarnessState(process.env, report).state;\n}\n\n/**\n * The harness state of one session, by id.\n *\n * A server runs many sessions' extensions in one process, each with its own state file, so\n * a session-scoped reader asks by session id. A terminal session owns its process, and the\n * answer is the same as `getHarnessState`.\n */\nexport function getSessionHarnessState(\n  sessionId: string | undefined,\n  report?: HarnessStateParseReporter,\n): HarnessState {\n  return loadHarnessState(readDoomSessionEnvironment(sessionId), report).state;\n}\n\nfunction stateFilePath(directory: string): string {\n  return path.join(directory, STATE_FILE_NAME);\n}\n\n/** Where a process writes state when it was not given a file of its own. */\nfunction adoptedStateFilePath(): string {\n  return path.join(os.tmpdir(), ADOPTED_DIRECTORY, `${String(process.pid)}.json`);\n}\n\nfunction persist(filePath: string, state: HarnessState, ownerPid = process.pid): void {\n  writePrivateAtomicJson(filePath, {\n    version: STATE_FILE_VERSION,\n    owner: { pid: ownerPid, startedAt: new Date().toISOString() },\n    state,\n  } satisfies HarnessStateFile);\n}\n\n/**\n * Starts a session: writes the file and publishes the derived environment.\n *\n * The environment is a parameter because the caller is usually describing a\n * process other than itself. The launcher builds the environment for the Pi it\n * is about to spawn, and Doom Team builds the snapshot for a detached child, so\n * neither should touch its own `process.env` to do it.\n */\nexport function createHarnessSession(\n  state: HarnessState,\n  options: {\n    directory: string;\n    environment: NodeJS.ProcessEnv;\n    /**\n     * Leave the file for a process that does not exist yet to claim.\n     *\n     * What a spawner wants: the child owns its state from its first read, in a\n     * directory the spawner manages, so the parent cleaning up its own session\n     * cannot pull the file out from under a detached run.\n     */\n    unclaimed?: boolean;\n  },\n): string {\n  const filePath = stateFilePath(options.directory);\n  persist(filePath, state, options.unclaimed ? UNCLAIMED_OWNER : process.pid);\n  options.environment[HARNESS_STATE_POINTER] = filePath;\n  projectHarnessEnvironment(state, options.environment);\n  // Only prime the cache when this process is the one being described.\n  if (!options.unclaimed && options.environment === process.env)\n    harnessCache.loaded = { filePath, owned: true, state, mtimeMs: fileMtime(filePath) };\n  return filePath;\n}\n\n/**\n * Applies a patch to this process's state.\n *\n * Copy on write: a process holding a file it does not own writes its own copy\n * and repoints itself at it, so a child can never rewrite its parent's session.\n */\nexport function updateHarnessState(\n  patch: Partial<HarnessState>,\n  environment: NodeJS.ProcessEnv = process.env,\n): HarnessState {\n  const current = loadHarnessState(environment);\n  const state = { ...current.state, ...patch };\n  const filePath = current.owned && current.filePath ? current.filePath : adoptedStateFilePath();\n  persist(filePath, state);\n  environment[HARNESS_STATE_POINTER] = filePath;\n  if (environment === process.env) harnessCache.loaded = { filePath, owned: true, state, mtimeMs: fileMtime(filePath) };\n  projectHarnessEnvironment(patch, environment);\n  return state;\n}\n\n/** Removes this process's own state file. Safe when there is none. */\nexport function disposeHarnessState(environment: NodeJS.ProcessEnv = process.env): void {\n  const current = harnessCache.loaded;\n  resetHarnessStore();\n  if (!current?.owned || !current.filePath) return;\n  fs.rmSync(current.filePath, { force: true });\n  delete environment[HARNESS_STATE_POINTER];\n}\n\nexport function harnessRoot(state: Pick<HarnessState, 'root'> = getHarnessState()): string {\n  return state.root ?? process.cwd();\n}\n\n/**\n * The repository root, or a hard error.\n *\n * Separate from `requireHarnessPaths` because most callers only need the root,\n * and separate from `harnessRoot` because falling back to `process.cwd()` would\n * quietly operate on whatever directory the session happens to sit in. A caller\n * that asks for the root wants the session's repository or nothing.\n */\nexport function requireHarnessRoot(state: Pick<HarnessState, 'root'> = getHarnessState()): string {\n  if (!state.root) throw new Error(`${HARNESS_STATE_KEYS.root} is not set`);\n  return state.root;\n}\n\n/** The root and the run's scratch directory, for callers that write to disk. */\nexport function requireHarnessPaths(state: Pick<HarnessState, 'root' | 'temporaryDirectory'> = getHarnessState()): {\n  root: string;\n  temporaryDirectory: string;\n} {\n  const root = requireHarnessRoot(state);\n  if (!state.temporaryDirectory) throw new Error(`${HARNESS_STATE_KEYS.temporaryDirectory} is not set`);\n  return { root, temporaryDirectory: state.temporaryDirectory };\n}\n"],"mappings":"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"}

package/dist/harnessStore.cjs

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_harnessStore = require("./harnessStore-CJSxdSkV.cjs");
+exports.HARNESS_STATE_POINTER = require_harnessStore.HARNESS_STATE_POINTER;
+exports.createHarnessSession = require_harnessStore.createHarnessSession;
+exports.disposeHarnessState = require_harnessStore.disposeHarnessState;
+exports.getHarnessState = require_harnessStore.getHarnessState;
+exports.getSessionHarnessState = require_harnessStore.getSessionHarnessState;
+exports.harnessRoot = require_harnessStore.harnessRoot;
+exports.loadHarnessState = require_harnessStore.loadHarnessState;
+exports.requireHarnessPaths = require_harnessStore.requireHarnessPaths;
+exports.requireHarnessRoot = require_harnessStore.requireHarnessRoot;
+exports.resetHarnessStore = require_harnessStore.resetHarnessStore;
+exports.restoreHarnessStateSnapshot = require_harnessStore.restoreHarnessStateSnapshot;
+exports.snapshotHarnessState = require_harnessStore.snapshotHarnessState;
+exports.updateHarnessState = require_harnessStore.updateHarnessState;

package/dist/harnessStore.d.mts

@@ -0,0 +1,2 @@
+import { a as disposeHarnessState, c as harnessRoot, d as requireHarnessRoot, f as resetHarnessStore, g as LoadedHarnessState, h as updateHarnessState, i as createHarnessSession, l as loadHarnessState, m as snapshotHarnessState, n as HarnessStateFile, o as getHarnessState, p as restoreHarnessStateSnapshot, r as HarnessStateTransactionSnapshot, s as getSessionHarnessState, t as HARNESS_STATE_POINTER, u as requireHarnessPaths } from "./index-DJpG-I9K.mjs";
+export { HARNESS_STATE_POINTER, type HarnessStateFile, type HarnessStateTransactionSnapshot, type LoadedHarnessState, createHarnessSession, disposeHarnessState, getHarnessState, getSessionHarnessState, harnessRoot, loadHarnessState, requireHarnessPaths, requireHarnessRoot, resetHarnessStore, restoreHarnessStateSnapshot, snapshotHarnessState, updateHarnessState };

package/dist/harnessStore.mjs

@@ -0,0 +1,2 @@
+import { a as getSessionHarnessState, c as requireHarnessPaths, d as restoreHarnessStateSnapshot, f as snapshotHarnessState, i as getHarnessState, l as requireHarnessRoot, n as createHarnessSession, o as harnessRoot, p as updateHarnessState, r as disposeHarnessState, s as loadHarnessState, t as HARNESS_STATE_POINTER, u as resetHarnessStore } from "./harnessStore-CltwLB7M.mjs";
+export { HARNESS_STATE_POINTER, createHarnessSession, disposeHarnessState, getHarnessState, getSessionHarnessState, harnessRoot, loadHarnessState, requireHarnessPaths, requireHarnessRoot, resetHarnessStore, restoreHarnessStateSnapshot, snapshotHarnessState, updateHarnessState };

package/dist/index-BAaTySaM.d.mts

@@ -0,0 +1,35 @@
+import { C as IDoomConfigService, g as DoomConfigTransitionRecord, m as DoomConfigSelection$1, p as DoomConfigPendingSelection, u as DoomConfigContext, x as HarnessState } from "./config-Cm3EV1jp.mjs";
+import { Context } from "@deepseek-ai/cordis";
+import "@agimon-ai/po-core/headless";
+import { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+//#region src/services/sessionConfig/index.d.ts
+declare const DOOM_CONFIG_ENTRY_TYPE = "po:config:v1";
+declare const DOOM_CONFIG_TRANSITION_ENTRY_TYPE = "po:transition:v1";
+type DoomConfigSelection = DoomConfigSelection$1;
+declare function readDoomConfigSelection(ctx: Pick<ExtensionContext, 'sessionManager'>): DoomConfigSelection | undefined;
+declare function createDoomConfigContext(ctx: Pick<ExtensionContext, 'cwd' | 'sessionManager'>): DoomConfigContext;
+declare function createDoomConfigContextAsync(ctx: Pick<ExtensionContext, 'cwd' | 'sessionManager'>): Promise<DoomConfigContext>;
+declare function appendDoomConfigSelection(pi: Pick<ExtensionAPI, 'appendEntry'>, selection: DoomConfigSelection): void;
+/** Journals the live selection, defaulting to whatever the harness store holds. */
+declare function persistHarnessSelection(pi: Pick<ExtensionAPI, 'appendEntry'>, state?: {
+  readonly majorMode: string;
+  readonly domains: readonly string[];
+  readonly profile?: string;
+  readonly compositionFingerprint?: string;
+}): void;
+declare function appendDoomConfigTransition(pi: Pick<ExtensionAPI, 'appendEntry'>, transition: DoomConfigTransitionRecord): void;
+declare function supersedeDoomConfigTransition(pi: Pick<ExtensionAPI, 'appendEntry'>, transition: DoomConfigPendingSelection): void;
+/** Acknowledges the latest pending transition from a fresh session that owns its exact target composition. */
+declare function acknowledgeDoomConfigTransition(pi: Pick<ExtensionAPI, 'appendEntry'>, ctx: Pick<ExtensionContext, 'sessionManager'>, harness: HarnessState): boolean;
+declare function readDoomConfigPendingSelection(ctx: Pick<ExtensionContext, 'sessionManager'>): DoomConfigPendingSelection | undefined;
+declare function provideDoomConfigContext(ctx: Context, context: DoomConfigContext, generation?: string): IDoomConfigService;
+/** Returns the binding identity used to fence in-flight transitions. */
+declare function readDoomConfigContextGeneration(ctx: Context): string | undefined;
+/** Precomputes an immutable context before a transaction reaches publication. */
+declare function freezeDoomConfigContext(context: DoomConfigContext): DoomConfigContext;
+/** Replaces a live binding with a deeply frozen context after publication. */
+declare function replaceDoomConfigContext(ctx: Context, context: DoomConfigContext): DoomConfigContext;
+declare function requireDoomConfigContext(ctx: Context): DoomConfigContext;
+//#endregion
+export { supersedeDoomConfigTransition as _, appendDoomConfigSelection as a, createDoomConfigContextAsync as c, provideDoomConfigContext as d, readDoomConfigContextGeneration as f, requireDoomConfigContext as g, replaceDoomConfigContext as h, acknowledgeDoomConfigTransition as i, freezeDoomConfigContext as l, readDoomConfigSelection as m, DOOM_CONFIG_TRANSITION_ENTRY_TYPE as n, appendDoomConfigTransition as o, readDoomConfigPendingSelection as p, DoomConfigSelection as r, createDoomConfigContext as s, DOOM_CONFIG_ENTRY_TYPE as t, persistHarnessSelection as u };
+//# sourceMappingURL=index-BAaTySaM.d.mts.map

package/dist/index-BAaTySaM.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BAaTySaM.d.mts","names":["ConfigSelection"],"sources":["../src/services/sessionConfig/index.ts"],"mappings":";;;;;cAmBa;cACA;KAED,sBAAsBA;iBAsHlB,wBACd,KAAK,KAAK,sCACT;iBAyCa,wBAAwB,KAAK,KAAK,8CAA8C;iBAK1E,6BACpB,KAAK,KAAK,8CACT,QAAQ;iBA4BK,0BAA0B,IAAI,KAAK,8BAA8B,WAAW;;iBAK5E,wBACd,IAAI,KAAK,8BACT;WACW;WACA;WACA;WACA;;iBAYG,2BACd,IAAI,KAAK,8BACT,YAAY;iBAKE,8BACd,IAAI,KAAK,8BACT,YAAY;;iBAME,gCACd,IAAI,KAAK,8BACT,KAAK,KAAK,qCACV,SAAS;iBAUK,+BACd,KAAK,KAAK,sCACT;iBASa,yBACd,KAAK,SACL,SAAS,mBACT,sBACC;;iBAKa,gCAAgC,KAAK;;iBAKrC,wBAAwB,SAAS,oBAAoB;;iBAKrD,yBAAyB,KAAK,SAAS,SAAS,oBAAoB;iBAepE,yBAAyB,KAAK,UAAU"}

package/dist/index-BT29GZx5.d.mts

@@ -0,0 +1,142 @@
+//#region src/types/domains.d.ts
+interface LocalPluginSource {
+  type: 'local';
+  /** Absolute plugin directory after resolving the declaring config or marketplace root. */
+  path: string;
+}
+interface GitPluginSource {
+  type: 'git';
+  url: string;
+  /** Optional repository-relative plugin directory. */
+  path?: string;
+  ref?: string;
+  sha?: string;
+}
+interface NpmPluginSource {
+  type: 'npm';
+  package: string;
+  version?: string;
+  registry?: string;
+}
+type PluginSource = LocalPluginSource | GitPluginSource | NpmPluginSource;
+type PluginSkillDiscovery = 'recursive' | 'direct-children';
+interface PluginManifestMetadata {
+  path: string;
+  name?: string;
+  version?: string;
+  description?: string;
+  agentPluginSchema?: string;
+}
+interface PluginCatalogEntry {
+  source: PluginSource;
+  description?: string;
+  marketplace?: string;
+  manifest?: PluginManifestMetadata;
+}
+interface PluginCatalog {
+  /** Marketplace, plugin, or plugin-container roots resolved against their declaring config. */
+  roots: string[];
+  /** Supported marketplace manifests discovered in precedence order. */
+  marketplaces: string[];
+  /** Named explicit and marketplace plugin entries. */
+  entries: Record<string, PluginCatalogEntry>;
+  /** Non-fatal errors from automatic marketplace and folder discovery. */
+  diagnostics: string[];
+}
+/** A named plugin, or a subset of one. */
+type DomainPlugin = string | {
+  name: string;
+  skills?: string[];
+  agents?: string[];
+  hooks?: boolean;
+  mcp?: boolean;
+};
+interface DomainMcpAllowlist {
+  /** Server names kept from the repository-level .mcp.json. */
+  servers?: string[];
+  /** Upstream server names kept in the agiflow-proxy config. */
+  proxy?: string[];
+}
+interface DomainDefinition {
+  description?: string;
+  plugins?: DomainPlugin[];
+  mcp?: DomainMcpAllowlist;
+  sharedSkills?: boolean;
+}
+interface ResolvedDomain extends DomainDefinition {
+  baseDirectory: string;
+}
+interface DomainManifest {
+  plugins: PluginCatalog;
+  domains: Record<string, ResolvedDomain>;
+  aliases: Record<string, string[]>;
+  defaultDomains?: string[];
+}
+interface PluginEntry {
+  /** Catalog identifier when the entry came from domains.yaml. */
+  name?: string;
+  directory: string;
+  /** The domain that admitted this plugin; absent for an explicit directory. */
+  domain?: string;
+  /** Omitted for legacy programmatic callers that already supply a directory. */
+  source?: PluginSource;
+  /** Manifest metadata retained so resource adapters can apply schema-gated plugin contracts. */
+  manifest?: PluginManifestMetadata;
+  skillDiscovery?: PluginSkillDiscovery;
+  skills?: string[];
+  agents?: string[];
+  hooks?: boolean;
+  mcp?: boolean;
+}
+//#endregion
+//#region src/services/domains/index.d.ts
+/**
+ * Reads domains and plugin catalogs from global and repository configs.
+ *
+ * Named domains and explicit plugin entries are replaced by later repository
+ * definitions. Configured roots accumulate, with exact marketplace manifests
+ * deduplicated in discovery order. Explicit entries override discovered IDs.
+ */
+declare function loadDomains(repoRoot: string, homeDirectory?: string): DomainManifest;
+declare function listDomainNames(repoRoot: string, homeDirectory?: string): string[];
+/**
+ * Whether to include .claude/skills as shared fallbacks.
+ *
+ * Shared skills are included unless every selected domain opts out, so mixing a
+ * trimmed domain with an untrimmed one cannot strip the untrimmed one's skills.
+ */
+declare function resolveSharedSkills(repoRoot: string, domainNames: string[], homeDirectory?: string): boolean;
+/** Resolves named domain plugins while preserving each subset filter. */
+declare function resolvePluginEntries(repoRoot: string, domainNames: string[], explicitDirectories: string[], homeDirectory?: string): PluginEntry[];
+declare function resolvePluginDirectories(repoRoot: string, domainNames: string[], explicitDirectories: string[], homeDirectory?: string): string[];
+declare const PO_DOMAINS_ENV = "PO_DOMAINS";
+declare const DEFAULT_DOMAIN = "default";
+/**
+ * Domains selected when the caller names none.
+ *
+ * Configuration keeps this axis independent of the major mode. The
+ * major-mode-derived choice is retained only as the compatibility fallback for
+ * domains files that declare no defaultDomains.
+ */
+declare function defaultDomainsForMajorMode(majorMode: string, environment: NodeJS.ProcessEnv, defaultDomains?: readonly string[]): string[];
+//#endregion
+//#region src/services/domains/completion.d.ts
+/** Splits comma-joined selections and expands aliases into concrete domain names. */
+declare function expandDomainNames(manifest: DomainManifest, domainNames: readonly string[]): string[];
+declare function domainCompletionPrefix(textBeforeCursor: string): string | undefined;
+declare function domainCompletionItems(domainNames: string[], query: string): Array<{
+  value: string;
+  label: string;
+}>;
+//#endregion
+//#region src/services/pluginCatalog/index.d.ts
+declare const MARKETPLACE_MANIFEST_RELATIVE_PATHS: readonly ['.agents/plugins/marketplace.json', '.agents/plugins/api_marketplace.json', '.claude-plugin/marketplace.json', '.cursor-plugin/marketplace.json'];
+/** Matches Codex manifest precedence, including schema-gated root plugin.json. */
+declare function findPluginManifestPath(pluginRoot: string): string | undefined;
+declare function pluginDirectoryForSource(source: PluginSource, homeDoomDirectory: string): string;
+declare function isRemotePluginSource(source: PluginSource): source is GitPluginSource | Extract<PluginSource, {
+  type: 'npm';
+}>;
+//#endregion
+export { PluginCatalog as C, PluginSkillDiscovery as D, PluginManifestMetadata as E, PluginSource as O, NpmPluginSource as S, PluginEntry as T, DomainManifest as _, domainCompletionItems as a, GitPluginSource as b, DEFAULT_DOMAIN as c, listDomainNames as d, loadDomains as f, DomainDefinition as g, resolveSharedSkills as h, pluginDirectoryForSource as i, ResolvedDomain as k, PO_DOMAINS_ENV as l, resolvePluginEntries as m, findPluginManifestPath as n, domainCompletionPrefix as o, resolvePluginDirectories as p, isRemotePluginSource as r, expandDomainNames as s, MARKETPLACE_MANIFEST_RELATIVE_PATHS as t, defaultDomainsForMajorMode as u, DomainMcpAllowlist as v, PluginCatalogEntry as w, LocalPluginSource as x, DomainPlugin as y };
+//# sourceMappingURL=index-BT29GZx5.d.mts.map

package/dist/index-BT29GZx5.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BT29GZx5.d.mts","names":[],"sources":["../src/types/domains.ts","../src/services/domains/index.ts","../src/services/domains/completion.ts","../src/services/pluginCatalog/index.ts"],"mappings":";UAAiB;EACf;;EAEA;;UAGe;EACf;EACA;;EAEA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;;KAGU,eAAe,oBAAoB,kBAAkB;KACrD;UAEK;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf,QAAQ;EACR;EACA;EACA,WAAW;;UAGI;;EAEf;;EAEA;;EAEA,SAAS,eAAe;;EAExB;;;KAIU;EAEN;EAAc;EAAmB;EAAmB;EAAiB;;UAE1D;;EAEf;;EAEA;;UAGe;EACf;EACA,UAAU;EACV,MAAM;EACN;;UAGe,uBAAuB;EACtC;;UAGe;EACf,SAAS;EACT,SAAS,eAAe;EACxB,SAAS;EACT;;UAGe;;EAEf;EACA;;EAEA;;EAEA,SAAS;;EAET,WAAW;EACX,iBAAiB;EACjB;EACA;EACA;EACA;;;;;;;;;;;iBC6Bc,YAAY,kBAAkB,yBAAuC;iBA0CrE,gBAAgB,kBAAkB;;;;;;;iBAWlC,oBAAoB,kBAAkB,uBAAuB;;iBAQ7D,qBACd,kBACA,uBACA,+BACA,yBACC;iBAwDa,yBACd,kBACA,uBACA,+BACA;cAOW;cACA;;;;;;;;iBAiBG,2BACd,mBACA,aAAa,OAAO,YACpB;;;;iBCjRc,kBAAkB,UAAU,gBAAgB;iBAW5C,uBAAuB;iBAKvB,sBAAsB,uBAAuB,gBAAgB;EAAQ;EAAe;;;;cCCvF;;iBAgPG,uBAAuB;iBAmJvB,yBAAyB,QAAQ,cAAc;iBA8C/C,qBACd,QAAQ,eACP,UAAU,kBAAkB,QAAQ;EAAgB"}

package/dist/index-B_lp0W3U.d.mts

@@ -0,0 +1,114 @@
+import { i as PersonaVoiceOverride } from "./profiles-CTrUCmIh.mjs";
+import { I as VoiceConfig, N as ResolvedVoiceConfig, O as PlanningModeConfig, T as LenientParseResult, f as DoomConfigLayers, l as DoomConfig, t as AutocompactModeConfig, w as LenientParseOptions } from "./config-Cm3EV1jp.mjs";
+//#region src/services/config/index.d.ts
+declare function globalDoomConfigDirectory(homeDirectory?: string): string;
+declare function globalDoomConfigPath(homeDirectory?: string): string;
+declare function resolvePlanningPlansDirectory(configured: string | undefined, repoRoot: string, homeDirectory?: string): string;
+declare function repositoryDoomConfigPath(repoRoot: string): string;
+declare function loadDoomConfig(repoRoot: string, homeDirectory?: string, environment?: NodeJS.ProcessEnv): DoomConfig;
+/**
+ * Loads the merged config, tolerating unknown keys in either file.
+ *
+ * Only `po sync` uses this. Everything that runs during a session keeps
+ * `loadDoomConfig`, because a key a running extension cannot understand is
+ * better reported than silently ignored; a build that refuses to start over
+ * the same key is not.
+ */
+declare function loadDoomConfigLenient(repoRoot: string, homeDirectory?: string, environment?: NodeJS.ProcessEnv): LenientParseResult;
+declare function loadDoomConfigAsync(repoRoot: string, homeDirectory?: string, environment?: NodeJS.ProcessEnv): Promise<DoomConfig>;
+/**
+ * The two config files kept apart, with the merge alongside them.
+ *
+ * `repoRoot` is optional because the global file is complete on its own: a
+ * settings surface with no repository in view still has settings to show, and
+ * demanding one would leave it with nothing to render rather than with the
+ * global half.
+ *
+ * The origin answer respects the merge's own per-field rules rather than simply
+ * preferring the repository: `editor` is read from the global side whatever the
+ * repository says, and `projectTrust` from the repository side whatever the
+ * global one says. Reporting a file as the source of a value the merge discards
+ * is the exact confusion this exists to remove.
+ */
+declare function loadDoomConfigLayers(repoRoot: string | undefined, homeDirectory?: string, environment?: NodeJS.ProcessEnv): DoomConfigLayers;
+//#endregion
+//#region src/services/configPolicy/index.d.ts
+/**
+ * The accepted values, in the order a picker should offer them.
+ *
+ * Exported because the config UI has to offer exactly what the parser accepts,
+ * and a second hand-written list in the contributing package would drift. The
+ * validating Sets below are built from these for the same reason.
+ */
+declare const DOOM_PLANNING_THINKING_LEVELS: readonly ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+declare const DOOM_VOICE_MODES: readonly ["legacy", 'live'];
+declare const DOOM_VOICE_ENGINES: readonly ["auto", "whisper-cpp", "openai-whisper", "mlx-whisper"];
+declare const DOOM_VOICE_TTS_ENGINES: readonly ["macos-say"];
+declare function parseAutocompactModeConfig(value: unknown, filePath: string, location?: string): AutocompactModeConfig;
+declare function parsePlanningModeConfig(value: unknown, filePath: string, location?: string): PlanningModeConfig;
+/**
+ * Reads one Doom config file.
+ *
+ * The two-argument form is the strict contract every harness-launch consumer
+ * relies on: an unknown key is a hard error. `po sync` opts into the
+ * lenient form so a config written for a different version cannot break a
+ * build; `po doctor` is the strict check that still reports those keys.
+ * Invalid values for known keys throw in both modes.
+ */
+declare function parseDoomConfig(content: string, filePath: string): DoomConfig;
+declare function parseDoomConfig(content: string, filePath: string, options: LenientParseOptions): LenientParseResult;
+declare function mergeDoomConfigs(globalConfig: DoomConfig, repositoryConfig: DoomConfig): DoomConfig;
+/**
+ * Resolves voice settings, optionally shadowed by the active profile's override.
+ *
+ * The override is per field, so a persona that sets only `rate` keeps the voice
+ * from config.yaml. `engine` is deliberately not overridable: it selects the
+ * synthesiser binary, which is a machine-level fact rather than a persona's.
+ *
+ * The result is read once when autonomous voice activates, because
+ * `VoiceNarrationPlayback.config` is assigned in `activate()` and has no setter.
+ * That is sufficient today only because every profile switch reloads the
+ * session, which deactivates and reactivates voice. A future in-place profile
+ * switch would leave the spoken voice stale until the next activation.
+ */
+declare function resolveVoiceConfig(config: VoiceConfig, ttsOverride?: PersonaVoiceOverride): ResolvedVoiceConfig;
+/**
+ * Which files a key may be written to.
+ *
+ * `mergeDoomConfigs` above already decides this per field, but it decides it by
+ * doing it: `editor` reads only from the global side, `projectTrust` only from
+ * the repository side, and repository `voice.mode` or `voice.autoCapture`
+ * declarations throw outright. A caller holding a key path has no way to ask.
+ * surface offers writes that throw, or worse, writes that land in a file the
+ * merge will ignore, so the change appears to do nothing.
+ *
+ * Declared here rather than beside the writer because the rule is a property of
+ * the merge, not of the filesystem, and a test asserts the two agree.
+ */
+type ConfigKeyScope = 'global' | 'repository' | 'both';
+/**
+ * The scopes a key path accepts. An unknown root answers `both` rather than
+ * throwing: the parser is what rejects unsupported keys, and it reports them
+ * far better than a scope lookup could.
+ */
+declare function configScopeOf(keyPath: readonly string[]): ConfigKeyScope;
+/** Every root key the config accepts, so a caller can enumerate without importing the parser's internals. */
+declare function configRootKeys(): readonly string[];
+/**
+ * Every key path a parsed document actually sets, as dotted strings.
+ *
+ * A settings surface needs to tell "this file set this key" from "this file is
+ * silent about it", and the parsed `DoomConfig` cannot answer: an absent file
+ * reads as `{ projectTrust: 'ask' }` and `parseDoomConfig` always returns all
+ * known root keys, some undefined. So the question is asked of the raw document
+ * instead, before any defaulting has happened.
+ *
+ * Leaves only. A list is a leaf because it is replaced whole, and an empty
+ * record sets nothing.
+ */
+declare function configLeafKeys(value: unknown, prefix?: readonly string[]): string[];
+/** The value a key path points at, or undefined when any step is missing. */
+declare function valueAtKeyPath(value: unknown, keyPath: readonly string[]): unknown;
+//#endregion
+export { resolvePlanningPlansDirectory as S, loadDoomConfig as _, DOOM_VOICE_TTS_ENGINES as a, loadDoomConfigLenient as b, configScopeOf as c, parseDoomConfig as d, parsePlanningModeConfig as f, globalDoomConfigPath as g, globalDoomConfigDirectory as h, DOOM_VOICE_MODES as i, mergeDoomConfigs as l, valueAtKeyPath as m, DOOM_PLANNING_THINKING_LEVELS as n, configLeafKeys as o, resolveVoiceConfig as p, DOOM_VOICE_ENGINES as r, configRootKeys as s, ConfigKeyScope as t, parseAutocompactModeConfig as u, loadDoomConfigAsync as v, repositoryDoomConfigPath as x, loadDoomConfigLayers as y };
+//# sourceMappingURL=index-B_lp0W3U.d.mts.map

package/dist/index-B_lp0W3U.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-B_lp0W3U.d.mts","names":[],"sources":["../src/services/config/index.ts","../src/services/configPolicy/index.ts"],"mappings":";;;iBAqCgB,0BAA0B;iBAI1B,qBAAqB;iBAIrB,8BACd,gCACA,kBACA;iBAYc,yBAAyB;iBAuBzB,eACd,kBACA,wBACA,cAAa,OAAO,aACnB;;;;;;;;;iBAmBa,sBACd,kBACA,wBACA,cAAa,OAAO,aACnB;iBAgBmB,oBACpB,kBACA,wBACA,cAAa,OAAO,aACnB,QAAQ;;;;;;;;;;;;;;;iBAgDK,qBACd,8BACA,wBACA,cAAa,OAAO,aACnB;;;;;;;;;;cC1DU;cACA;cACA;cAMA;iBA+VG,2BACd,gBACA,kBACA,oBACC;iBAgBa,wBACd,gBACA,kBACA,oBACC;;;;;;;;;;iBAiJa,gBAAgB,iBAAiB,mBAAmB;iBACpD,gBAAgB,iBAAiB,kBAAkB,SAAS,sBAAsB;iBA2DlF,iBAAiB,cAAc,YAAY,kBAAkB,aAAa;;;;;;;;;;;;;;iBA6G1E,mBAAmB,QAAQ,aAAa,cAAc,uBAAuB;;;;;;;;;;;;;;KA8CjF;;;;;;iBAoBI,cAAc,6BAA6B;;iBAU3C;;;;;;;;;;;;;iBAsBA,eAAe,gBAAgB;;iBAQ/B,eAAe,gBAAgB"}

package/dist/index-C6GaYjq-.d.mts

@@ -0,0 +1,6 @@
+//#region src/services/atomicJson/index.d.ts
+/** Writes JSON readable by its owner only, replacing the target atomically. */
+declare function writePrivateAtomicJson(filePath: string, value: unknown): void;
+//#endregion
+export { writePrivateAtomicJson as t };
+//# sourceMappingURL=index-C6GaYjq-.d.mts.map

package/dist/index-C6GaYjq-.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-C6GaYjq-.d.mts","names":[],"sources":["../src/services/atomicJson/index.ts"],"mappings":";;iBA4BgB,uBAAuB,kBAAkB"}

package/dist/index-CIQrKS1A.d.mts

@@ -0,0 +1,50 @@
+import { x as HarnessState } from "./config-Cm3EV1jp.mjs";
+//#region src/services/harnessState/index.d.ts
+/**
+ * State that lives in the file only.
+ *
+ * These are JSON documents that every spawned process and every hook would
+ * otherwise copy in its environment. The plugin hook list and profile defaults
+ * are read from the store, while Config publishes the MCP projection through
+ * the session-scoped Cordis registry.
+ */
+declare const FILE_ONLY_STATE_FIELDS: ReadonlySet<keyof HarnessState>;
+type HarnessStateParseReporter = (key: string, error: unknown) => void;
+declare const HARNESS_STATE_KEYS: {
+  readonly root: 'PO_ROOT';
+  readonly majorMode: 'PO_MAJOR_MODE';
+  readonly temporaryDirectory: 'PO_TEMP_DIR';
+  readonly domains: 'PO_DOMAINS';
+  readonly layers: 'PO_LAYERS';
+  readonly compositionFingerprint: 'PO_COMPOSITION_FINGERPRINT';
+  readonly profile: 'PO_PROFILE';
+  readonly profileEnvironment: 'PO_PROFILE_ENV';
+  readonly hookGroups: 'PO_HOOK_GROUPS';
+  readonly skillDirectories: 'PO_SKILL_DIRS';
+  readonly agentDirectories: 'PO_AGENT_DIRS';
+  readonly additionalDirectories: 'PO_ADDITIONAL_DIRS';
+  readonly childExtensions: 'PO_CHILD_EXTENSIONS';
+  readonly pluginDirectories: 'PO_PLUGIN_DIRS';
+  readonly pluginHooks: 'PO_PLUGIN_HOOKS';
+  readonly mcpConfigPath: 'PO_MCP_CONFIG';
+  readonly personaFile: 'PO_PERSONA_FILE';
+  readonly hooks: 'PO_HOOKS_ENABLED';
+  readonly agents: 'PO_AGENTS_ENABLED';
+  readonly mcp: 'PO_MCP_ENABLED';
+  readonly allowProtectedWrites: 'PO_ALLOW_PROTECTED_WRITES';
+};
+declare function readHarnessState(environment?: NodeJS.ProcessEnv, report?: HarnessStateParseReporter): HarnessState;
+/**
+ * Publishes a state patch into an environment.
+ *
+ * Takes the environment rather than assuming `process.env`, because the
+ * launcher builds a child environment and Doom Team builds a spawn snapshot;
+ * neither should mutate its own process to describe another one.
+ *
+ * Fields in FILE_ONLY_FIELDS are skipped: the file carries them, and a reader
+ * that needs them reads the store.
+ */
+declare function projectHarnessEnvironment(patch: Partial<HarnessState>, environment?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+//#endregion
+export { readHarnessState as a, projectHarnessEnvironment as i, HARNESS_STATE_KEYS as n, HarnessStateParseReporter as r, FILE_ONLY_STATE_FIELDS as t };
+//# sourceMappingURL=index-CIQrKS1A.d.mts.map

package/dist/index-CIQrKS1A.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CIQrKS1A.d.mts","names":[],"sources":["../src/services/harnessState/index.ts"],"mappings":";;;;;;;;;;cAyBa,wBAAwB,kBAAkB;KAe3C,6BAA6B,aAAa;cAEzC;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;iBA4Ec,iBACd,cAAa,OAAO,YACpB,SAAS,4BACR;;;;;;;;;;;iBAsCa,0BACd,OAAO,QAAQ,eACf,cAAa,OAAO,aACnB,OAAO"}

package/dist/index-CRcoVYXz.d.mts

@@ -0,0 +1,39 @@
+//#region src/services/init/index.d.ts
+/** The global seed files are processed in this fixed order. */
+declare const GLOBAL_DOOM_SEED_FILES: readonly ['config.yaml', 'modes.yaml', 'domains.yaml', 'profiles.yaml'];
+type DoomSeedFile = (typeof GLOBAL_DOOM_SEED_FILES)[number];
+/** Portable defaults for a new global Doom configuration directory. */
+declare const DOOM_CONFIG_TEMPLATES: Readonly<Record<DoomSeedFile, string>>;
+/** Standalone defaults for a repository that is trying Po through DPI. */
+declare const REPOSITORY_DOOM_CONFIG_TEMPLATES: Readonly<Record<DoomSeedFile, string>>;
+/** Result of filling a Doom seed directory. File arrays contain names in seed order. */
+interface GlobalDoomInitResult {
+  directory: string;
+  created: string[];
+  preserved: string[];
+  /** Existing files overwritten from the template. Only ever non-empty under `force`. */
+  replaced: string[];
+}
+interface GlobalDoomInitOptions {
+  /**
+   * Overwrite existing seed files instead of preserving them.
+   *
+   * Off by default: init is safe to re-run, and hand-edited config is the
+   * normal case rather than the exception.
+   */
+  force?: boolean;
+}
+type RepositoryDoomInitOptions = GlobalDoomInitOptions;
+type RepositoryDoomInitResult = GlobalDoomInitResult;
+/**
+ * Fills missing global seed files.
+ *
+ * Existing files are left alone so that re-running init never discards
+ * hand-edited config; pass `force` to overwrite them from the template.
+ */
+declare function initializeGlobalDoomConfig(homeDirectory?: string, options?: GlobalDoomInitOptions): GlobalDoomInitResult;
+/** Seeds repository-local configuration without creating or changing Pi settings. */
+declare function initializeRepositoryDoomConfig(repositoryRoot?: string, options?: RepositoryDoomInitOptions): RepositoryDoomInitResult;
+//#endregion
+export { REPOSITORY_DOOM_CONFIG_TEMPLATES as a, initializeGlobalDoomConfig as c, GlobalDoomInitResult as i, initializeRepositoryDoomConfig as l, GLOBAL_DOOM_SEED_FILES as n, RepositoryDoomInitOptions as o, GlobalDoomInitOptions as r, RepositoryDoomInitResult as s, DOOM_CONFIG_TEMPLATES as t };
+//# sourceMappingURL=index-CRcoVYXz.d.mts.map

package/dist/index-CRcoVYXz.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CRcoVYXz.d.mts","names":[],"sources":["../src/services/init/index.ts"],"mappings":";;cAiBa;KAER,uBAAuB;;cAGf,uBAAuB,SAAS,OAAO;;cA0LvC,kCAAkC,SAAS,OAAO;;UA8D9C;EACf;EACA;EACA;;EAEA;;UAGe;;;;;;;EAOf;;KAGU,4BAA4B;KAC5B,2BAA2B;;;;;;;iBAiKvB,2BACd,wBACA,UAAS,wBACR;;iBAWa,+BACd,yBACA,UAAS,4BACR"}

package/dist/index-CVlciCJF.d.mts

@@ -0,0 +1,40 @@
+import { a as PiConfigPaths, i as PiConfigLoadOptions, r as PiConfig } from "./piConfig-Bx26HMb_.mjs";
+//#region src/services/imageSettings/index.d.ts
+/** Pi's own cap, from its resize core; also the largest value worth writing. */
+declare const DEFAULT_IMAGE_MAX_DIMENSION = 2000;
+/** Below this a screenshot stops being readable, which is what reads are for. */
+declare const MIN_IMAGE_MAX_DIMENSION = 256;
+interface PiImageSettings {
+  /** Pi's own toggle. Unset is on, matching Pi's default. */
+  autoResize: boolean;
+  /** The longest edge an image keeps once resizing is on. */
+  maxDimension: number;
+}
+/** The written form of a change; an absent field leaves that key alone. */
+interface PiImageSettingsUpdate {
+  autoResize?: boolean;
+  maxDimension?: number;
+}
+declare function clampImageMaxDimension(value: number): number;
+/** Resolves the effective limits, defaulting anything absent or unusable. */
+declare function parsePiImageSettings(config: PiConfig): PiImageSettings;
+//#endregion
+//#region src/services/piConfig/index.d.ts
+declare function piConfigPaths(repoRoot: string, homeDirectory?: string, agentDirectory?: string): PiConfigPaths;
+declare function loadPiConfig(options: PiConfigLoadOptions): PiConfig;
+declare function loadPiConfigAsync(options: PiConfigLoadOptions): Promise<PiConfig>;
+/** The file a change lands in; Pi's own settings toggle writes the same one. */
+declare function piImageSettingsPath(homeDirectory?: string): string;
+declare function loadPiImageSettings(homeDirectory?: string): PiImageSettings;
+/**
+ * Writes the changed keys back and reports the limits that now apply.
+ *
+ * Read-modify-write on Pi's own file, so a save races a concurrent Pi settings
+ * save rather than merging with it. Pi writes only the fields its UI touched,
+ * as this does, which keeps the window to the one setting being changed on
+ * both sides at once.
+ */
+declare function savePiImageSettings(update: PiImageSettingsUpdate, homeDirectory?: string): PiImageSettings;
+//#endregion
+export { piImageSettingsPath as a, MIN_IMAGE_MAX_DIMENSION as c, clampImageMaxDimension as d, parsePiImageSettings as f, piConfigPaths as i, PiImageSettings as l, loadPiConfigAsync as n, savePiImageSettings as o, loadPiImageSettings as r, DEFAULT_IMAGE_MAX_DIMENSION as s, loadPiConfig as t, PiImageSettingsUpdate as u };
+//# sourceMappingURL=index-CVlciCJF.d.mts.map

package/dist/index-CVlciCJF.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CVlciCJF.d.mts","names":[],"sources":["../src/services/imageSettings/index.ts","../src/services/piConfig/index.ts"],"mappings":";;;cA0Ba;;cAEA;UAEI;;EAEf;;EAEA;;;UAIe;EACf;EACA;;iBAGc,uBAAuB;;iBAYvB,qBAAqB,QAAQ,WAAW;;;iBCkBxC,cACd,kBACA,wBACA,0BACC;iBASa,aAAa,SAAS,sBAAsB;iBAkBtC,kBAAkB,SAAS,sBAAsB,QAAQ;;iBAoC/D,oBAAoB;iBAIpB,oBAAoB,yBAA+B;;;;;;;;;iBAanD,oBAAoB,QAAQ,uBAAuB,yBAA+B"}