@agimon-ai/doompi-core 0.0.1-alpha.70

package/dist/runtime-config.cjs

@@ -0,0 +1,232 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let typebox = require("typebox");
+//#region src/schemas/config.ts
+/**
+* Configuration surfaces, contributed by every extension that owns settings.
+*
+* Doom settings live in one YAML file but are owned by many extensions, and for
+* a long time the only way to change any of them was to edit that file by hand.
+* The one exception, an editor-command prompt, asked for a value with no way to
+* see what a valid one looked like.
+*
+* So configuration is published rather than centralised: an extension describes
+* its own fields, one renderer draws them all, and the extension still performs
+* every write. Nothing here knows what a voice model or an editor command is.
+*
+* Deliberately the same shape as the mode and footer contracts next door, since
+* the problem is the same one: several extensions sharing one surface. The UI
+* hub invokes an owner's registered action directly, because unlike a status
+* strip this surface is written to as well as read.
+*/
+/** Canonical Cordis key for the session-owned Doom configuration service. */
+const DOOM_CONFIG_SERVICE = "doom/config";
+/** Matches the leader contract's source rule: package names, addressable and spoof-checkable. */
+const ConfigSourceSchema = typebox.Type.String({
+	minLength: 1,
+	maxLength: 128,
+	pattern: "^[A-Za-z0-9@][A-Za-z0-9@/._:-]*$"
+});
+const ConfigIdSchema = typebox.Type.String({
+	minLength: 1,
+	maxLength: 128,
+	pattern: "^[a-z0-9][a-z0-9._:-]*$"
+});
+/**
+* How ready a value is to be used, as opposed to whether it is merely set.
+* `blocked` covers a choice that needs something else first, such as a model
+* whose engine is not installed.
+*/
+const ConfigStatusSchema = typebox.Type.Union([
+	typebox.Type.Literal("ready"),
+	typebox.Type.Literal("available"),
+	typebox.Type.Literal("blocked")
+]);
+const ConfigFieldKindSchema = typebox.Type.Union([
+	typebox.Type.Literal("text"),
+	typebox.Type.Literal("enum"),
+	typebox.Type.Literal("choice"),
+	typebox.Type.Literal("info")
+]);
+/**
+* A key the renderer offers on the focused field, sent back verbatim as an
+* action. Owners use this for confirmations, so the pending question survives a
+* panel that is closed and reopened.
+*/
+const ConfigActionSchema = typebox.Type.Object({
+	key: typebox.Type.String({
+		minLength: 1,
+		maxLength: 1
+	}),
+	label: typebox.Type.String({
+		minLength: 1,
+		maxLength: 24
+	}),
+	action: ConfigIdSchema
+}, { additionalProperties: false });
+const ConfigChoiceSchema = typebox.Type.Object({
+	id: typebox.Type.String({
+		minLength: 1,
+		maxLength: 256
+	}),
+	label: typebox.Type.String({
+		minLength: 1,
+		maxLength: 96
+	}),
+	/** Right-aligned by the renderer. Sizes, ids, anything narrow. */
+	detail: typebox.Type.Optional(typebox.Type.String({
+		minLength: 1,
+		maxLength: 96
+	})),
+	/** Groups entries under a heading the cursor skips over. */
+	group: typebox.Type.Optional(typebox.Type.String({
+		minLength: 1,
+		maxLength: 48
+	})),
+	status: typebox.Type.Optional(ConfigStatusSchema),
+	statusText: typebox.Type.Optional(typebox.Type.String({
+		minLength: 1,
+		maxLength: 96
+	})),
+	/**
+	* What enter does on this entry. Carrying it per-entry is what lets one list
+	* hold both an installed model that only needs selecting and an absent one
+	* that needs fetching, without the renderer knowing the difference.
+	*/
+	action: typebox.Type.Optional(ConfigIdSchema)
+}, { additionalProperties: false });
+/**
+* One line of a multi-step operation.
+*
+* Published as a list rather than a single "current step" string so the panel can
+* show what already ran alongside what is left. During an install that is the
+* difference between "something is happening" and knowing a package manager
+* already finished and a download is now underway.
+*/
+const ConfigStepSchema = typebox.Type.Object({
+	label: typebox.Type.String({
+		minLength: 1,
+		maxLength: 96
+	}),
+	state: typebox.Type.Union([
+		typebox.Type.Literal("pending"),
+		typebox.Type.Literal("satisfied"),
+		typebox.Type.Literal("running"),
+		typebox.Type.Literal("done"),
+		typebox.Type.Literal("failed")
+	]),
+	detail: typebox.Type.Optional(typebox.Type.String({
+		minLength: 1,
+		maxLength: 160
+	}))
+}, { additionalProperties: false });
+const ConfigProgressSchema = typebox.Type.Object({
+	label: typebox.Type.String({
+		minLength: 1,
+		maxLength: 96
+	}),
+	/** 0 to 1. Omitted when the work has no measurable total. */
+	ratio: typebox.Type.Optional(typebox.Type.Number({
+		minimum: 0,
+		maximum: 1
+	}))
+}, { additionalProperties: false });
+const ConfigFieldSchema = typebox.Type.Object({
+	id: ConfigIdSchema,
+	label: typebox.Type.String({
+		minLength: 1,
+		maxLength: 48
+	}),
+	kind: ConfigFieldKindSchema,
+	/** Absent means unset; the renderer shows `placeholder` instead. */
+	value: typebox.Type.Optional(typebox.Type.String({
+		minLength: 1,
+		maxLength: 4096
+	})),
+	placeholder: typebox.Type.Optional(typebox.Type.String({
+		minLength: 1,
+		maxLength: 96
+	})),
+	/** One line of help for the focused field. */
+	detail: typebox.Type.Optional(typebox.Type.String({
+		minLength: 1,
+		maxLength: 240
+	})),
+	/** The config key this writes, shown under the focused field so the file stays legible. */
+	keyPath: typebox.Type.Optional(typebox.Type.String({
+		minLength: 1,
+		maxLength: 128
+	})),
+	status: typebox.Type.Optional(ConfigStatusSchema),
+	/** Doubles as the error line: a rejected edit comes back as the old value plus this. */
+	statusText: typebox.Type.Optional(typebox.Type.String({
+		minLength: 1,
+		maxLength: 240
+	})),
+	choices: typebox.Type.Optional(typebox.Type.Array(ConfigChoiceSchema, { maxItems: 128 })),
+	actions: typebox.Type.Optional(typebox.Type.Array(ConfigActionSchema, { maxItems: 4 })),
+	/** Work is running; the renderer dims the field and offers abort. */
+	busy: typebox.Type.Optional(typebox.Type.Boolean()),
+	progress: typebox.Type.Optional(ConfigProgressSchema),
+	steps: typebox.Type.Optional(typebox.Type.Array(ConfigStepSchema, { maxItems: 24 })),
+	/**
+	* The tail of a running command's terminal output.
+	*
+	* A tail rather than the whole scrollback: the field is a few rows of a
+	* shared pane, and what matters is the question a package manager just
+	* asked, not what it printed a minute ago.
+	*/
+	output: typebox.Type.Optional(typebox.Type.Array(typebox.Type.String({ maxLength: 512 }), { maxItems: 64 })),
+	/**
+	* The command is waiting on the user. The renderer offers a line to type
+	* into, which comes back as an owner-defined action carrying the text.
+	*/
+	awaitingInput: typebox.Type.Optional(typebox.Type.Boolean())
+}, { additionalProperties: false });
+const ConfigSectionSchema = typebox.Type.Object({
+	id: ConfigIdSchema,
+	title: typebox.Type.String({
+		minLength: 1,
+		maxLength: 32
+	}),
+	detail: typebox.Type.Optional(typebox.Type.String({
+		minLength: 1,
+		maxLength: 96
+	})),
+	order: typebox.Type.Integer({
+		minimum: 0,
+		maximum: 1e3
+	}),
+	/** Section-wide state: readiness, or why a write failed. */
+	notice: typebox.Type.Optional(typebox.Type.String({
+		minLength: 1,
+		maxLength: 240
+	})),
+	noticeLevel: typebox.Type.Optional(typebox.Type.Union([typebox.Type.Literal("info"), typebox.Type.Literal("error")])),
+	fields: typebox.Type.Array(ConfigFieldSchema, { maxItems: 64 })
+}, { additionalProperties: false });
+const ConfigSourceRefSchema = typebox.Type.Object({
+	source: ConfigSourceSchema,
+	generation: typebox.Type.String({ minLength: 1 })
+}, { additionalProperties: false });
+typebox.Type.Object({
+	...ConfigSourceRefSchema.properties,
+	sections: typebox.Type.Array(ConfigSectionSchema, { maxItems: 32 })
+}, { additionalProperties: false });
+const CONFIG_ACTION = {
+	set: "set",
+	clear: "clear"
+};
+//#endregion
+exports.CONFIG_ACTION = CONFIG_ACTION;
+exports.ConfigActionSchema = ConfigActionSchema;
+exports.ConfigChoiceSchema = ConfigChoiceSchema;
+exports.ConfigFieldKindSchema = ConfigFieldKindSchema;
+exports.ConfigFieldSchema = ConfigFieldSchema;
+exports.ConfigProgressSchema = ConfigProgressSchema;
+exports.ConfigSectionSchema = ConfigSectionSchema;
+exports.ConfigSourceSchema = ConfigSourceSchema;
+exports.ConfigStatusSchema = ConfigStatusSchema;
+exports.ConfigStepSchema = ConfigStepSchema;
+exports.DOOM_CONFIG_SERVICE = DOOM_CONFIG_SERVICE;
+
+//# sourceMappingURL=runtime-config.cjs.map

package/dist/runtime-config.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-config.cjs","names":["Type"],"sources":["../src/schemas/config.ts"],"sourcesContent":["/**\n * Configuration surfaces, contributed by every extension that owns settings.\n *\n * Doom settings live in one YAML file but are owned by many extensions, and for\n * a long time the only way to change any of them was to edit that file by hand.\n * The one exception, an editor-command prompt, asked for a value with no way to\n * see what a valid one looked like.\n *\n * So configuration is published rather than centralised: an extension describes\n * its own fields, one renderer draws them all, and the extension still performs\n * every write. Nothing here knows what a voice model or an editor command is.\n *\n * Deliberately the same shape as the mode and footer contracts next door, since\n * the problem is the same one: several extensions sharing one surface. The UI\n * hub invokes an owner's registered action directly, because unlike a status\n * strip this surface is written to as well as read.\n */\n\nimport { type Static, Type } from 'typebox';\n\n/** Canonical Cordis key for the session-owned Doom configuration service. */\nexport const DOOM_CONFIG_SERVICE = 'doom/config';\n\n/** Matches the leader contract's source rule: package names, addressable and spoof-checkable. */\nexport const ConfigSourceSchema = Type.String({\n  minLength: 1,\n  maxLength: 128,\n  pattern: '^[A-Za-z0-9@][A-Za-z0-9@/._:-]*$',\n});\n\nconst ConfigIdSchema = Type.String({ minLength: 1, maxLength: 128, pattern: '^[a-z0-9][a-z0-9._:-]*$' });\n\n/**\n * How ready a value is to be used, as opposed to whether it is merely set.\n * `blocked` covers a choice that needs something else first, such as a model\n * whose engine is not installed.\n */\nexport const ConfigStatusSchema = Type.Union([\n  Type.Literal('ready'),\n  Type.Literal('available'),\n  Type.Literal('blocked'),\n]);\nexport type ConfigStatus = Static<typeof ConfigStatusSchema>;\n\nexport const ConfigFieldKindSchema = Type.Union([\n  /** Free text, edited in place. */\n  Type.Literal('text'),\n  /** A short closed set, cycled in place. */\n  Type.Literal('enum'),\n  /** A long set worth its own screen, with per-entry status and actions. */\n  Type.Literal('choice'),\n  /** Read-only. Resolution results, derived values, preflight checks. */\n  Type.Literal('info'),\n]);\nexport type ConfigFieldKind = Static<typeof ConfigFieldKindSchema>;\n\n/**\n * A key the renderer offers on the focused field, sent back verbatim as an\n * action. Owners use this for confirmations, so the pending question survives a\n * panel that is closed and reopened.\n */\nexport const ConfigActionSchema = Type.Object(\n  {\n    key: Type.String({ minLength: 1, maxLength: 1 }),\n    label: Type.String({ minLength: 1, maxLength: 24 }),\n    action: ConfigIdSchema,\n  },\n  { additionalProperties: false },\n);\nexport type ConfigAction = Static<typeof ConfigActionSchema>;\n\nexport const ConfigChoiceSchema = Type.Object(\n  {\n    id: Type.String({ minLength: 1, maxLength: 256 }),\n    label: Type.String({ minLength: 1, maxLength: 96 }),\n    /** Right-aligned by the renderer. Sizes, ids, anything narrow. */\n    detail: Type.Optional(Type.String({ minLength: 1, maxLength: 96 })),\n    /** Groups entries under a heading the cursor skips over. */\n    group: Type.Optional(Type.String({ minLength: 1, maxLength: 48 })),\n    status: Type.Optional(ConfigStatusSchema),\n    statusText: Type.Optional(Type.String({ minLength: 1, maxLength: 96 })),\n    /**\n     * What enter does on this entry. Carrying it per-entry is what lets one list\n     * hold both an installed model that only needs selecting and an absent one\n     * that needs fetching, without the renderer knowing the difference.\n     */\n    action: Type.Optional(ConfigIdSchema),\n  },\n  { additionalProperties: false },\n);\nexport type ConfigChoice = Static<typeof ConfigChoiceSchema>;\n\n/**\n * One line of a multi-step operation.\n *\n * Published as a list rather than a single \"current step\" string so the panel can\n * show what already ran alongside what is left. During an install that is the\n * difference between \"something is happening\" and knowing a package manager\n * already finished and a download is now underway.\n */\nexport const ConfigStepSchema = Type.Object(\n  {\n    label: Type.String({ minLength: 1, maxLength: 96 }),\n    state: Type.Union([\n      Type.Literal('pending'),\n      /** Already true of this machine, so nothing will run for it. */\n      Type.Literal('satisfied'),\n      Type.Literal('running'),\n      Type.Literal('done'),\n      Type.Literal('failed'),\n    ]),\n    detail: Type.Optional(Type.String({ minLength: 1, maxLength: 160 })),\n  },\n  { additionalProperties: false },\n);\nexport type ConfigStep = Static<typeof ConfigStepSchema>;\n\nexport const ConfigProgressSchema = Type.Object(\n  {\n    label: Type.String({ minLength: 1, maxLength: 96 }),\n    /** 0 to 1. Omitted when the work has no measurable total. */\n    ratio: Type.Optional(Type.Number({ minimum: 0, maximum: 1 })),\n  },\n  { additionalProperties: false },\n);\nexport type ConfigProgress = Static<typeof ConfigProgressSchema>;\n\nexport const ConfigFieldSchema = Type.Object(\n  {\n    id: ConfigIdSchema,\n    label: Type.String({ minLength: 1, maxLength: 48 }),\n    kind: ConfigFieldKindSchema,\n    /** Absent means unset; the renderer shows `placeholder` instead. */\n    value: Type.Optional(Type.String({ minLength: 1, maxLength: 4096 })),\n    placeholder: Type.Optional(Type.String({ minLength: 1, maxLength: 96 })),\n    /** One line of help for the focused field. */\n    detail: Type.Optional(Type.String({ minLength: 1, maxLength: 240 })),\n    /** The config key this writes, shown under the focused field so the file stays legible. */\n    keyPath: Type.Optional(Type.String({ minLength: 1, maxLength: 128 })),\n    status: Type.Optional(ConfigStatusSchema),\n    /** Doubles as the error line: a rejected edit comes back as the old value plus this. */\n    statusText: Type.Optional(Type.String({ minLength: 1, maxLength: 240 })),\n    choices: Type.Optional(Type.Array(ConfigChoiceSchema, { maxItems: 128 })),\n    actions: Type.Optional(Type.Array(ConfigActionSchema, { maxItems: 4 })),\n    /** Work is running; the renderer dims the field and offers abort. */\n    busy: Type.Optional(Type.Boolean()),\n    progress: Type.Optional(ConfigProgressSchema),\n    steps: Type.Optional(Type.Array(ConfigStepSchema, { maxItems: 24 })),\n    /**\n     * The tail of a running command's terminal output.\n     *\n     * A tail rather than the whole scrollback: the field is a few rows of a\n     * shared pane, and what matters is the question a package manager just\n     * asked, not what it printed a minute ago.\n     */\n    output: Type.Optional(Type.Array(Type.String({ maxLength: 512 }), { maxItems: 64 })),\n    /**\n     * The command is waiting on the user. The renderer offers a line to type\n     * into, which comes back as an owner-defined action carrying the text.\n     */\n    awaitingInput: Type.Optional(Type.Boolean()),\n  },\n  { additionalProperties: false },\n);\nexport type ConfigField = Static<typeof ConfigFieldSchema>;\n\nexport const ConfigSectionSchema = Type.Object(\n  {\n    id: ConfigIdSchema,\n    title: Type.String({ minLength: 1, maxLength: 32 }),\n    detail: Type.Optional(Type.String({ minLength: 1, maxLength: 96 })),\n    order: Type.Integer({ minimum: 0, maximum: 1000 }),\n    /** Section-wide state: readiness, or why a write failed. */\n    notice: Type.Optional(Type.String({ minLength: 1, maxLength: 240 })),\n    noticeLevel: Type.Optional(Type.Union([Type.Literal('info'), Type.Literal('error')])),\n    fields: Type.Array(ConfigFieldSchema, { maxItems: 64 }),\n  },\n  { additionalProperties: false },\n);\nexport type ConfigSection = Static<typeof ConfigSectionSchema>;\n\nconst ConfigSourceRefSchema = Type.Object(\n  { source: ConfigSourceSchema, generation: Type.String({ minLength: 1 }) },\n  { additionalProperties: false },\n);\n\nconst ConfigSnapshotSchema = Type.Object(\n  { ...ConfigSourceRefSchema.properties, sections: Type.Array(ConfigSectionSchema, { maxItems: 32 }) },\n  { additionalProperties: false },\n);\nexport type ConfigSnapshot = Static<typeof ConfigSnapshotSchema>;\nexport type ConfigSourceRef = Static<typeof ConfigSourceRefSchema>;\n\nexport const CONFIG_ACTION = {\n  set: 'set',\n  clear: 'clear',\n} as const;\n\nexport interface DoomExtensionContext {\n  sessionManager: { getSessionId(): string };\n}\n\nexport interface DoomConfigSectionView extends ConfigSection {\n  source: string;\n}\n\nexport interface DoomConfigInvocation {\n  source: string;\n  sectionId: string;\n  fieldId: string;\n  action: string;\n  value?: string;\n}\n\nexport interface DoomConfigActionInput<Context extends DoomExtensionContext = DoomExtensionContext> {\n  ctx: Context;\n  sectionId: string;\n  fieldId: string;\n  value?: string;\n}\n\nexport interface DoomConfigContributionOptions<Context extends DoomExtensionContext = DoomExtensionContext> {\n  source: string;\n  listSections: () => readonly ConfigSection[];\n  handlers: Readonly<Record<string, (input: DoomConfigActionInput<Context>) => void | Promise<void>>>;\n  onError: (error: unknown, actionName: string, ctx: Context) => void;\n}\n\nexport interface DoomConfigContributionHandle {\n  update(): void;\n  dispose(): void;\n}\n"],"mappings":"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"}

package/dist/runtime-config.d.cts

@@ -0,0 +1,313 @@
+import { Static, Type } from "typebox";
+//#region src/schemas/config.d.ts
+/** Canonical Cordis key for the session-owned Doom configuration service. */
+export declare const DOOM_CONFIG_SERVICE = "doom/config";
+/** Matches the leader contract's source rule: package names, addressable and spoof-checkable. */
+export declare const ConfigSourceSchema: Type.TString;
+/**
+ * How ready a value is to be used, as opposed to whether it is merely set.
+ * `blocked` covers a choice that needs something else first, such as a model
+ * whose engine is not installed.
+ */
+export declare const ConfigStatusSchema: Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>;
+export type ConfigStatus = Static<typeof ConfigStatusSchema>;
+export declare const ConfigFieldKindSchema: Type.TUnion<[Type.TLiteral<"text">, Type.TLiteral<"enum">, Type.TLiteral<"choice">, Type.TLiteral<"info">]>;
+export type ConfigFieldKind = Static<typeof ConfigFieldKindSchema>;
+/**
+ * A key the renderer offers on the focused field, sent back verbatim as an
+ * action. Owners use this for confirmations, so the pending question survives a
+ * panel that is closed and reopened.
+ */
+export declare const ConfigActionSchema: Type.TObject<{
+  key: Type.TString;
+  label: Type.TString;
+  action: Type.TString;
+}>;
+export type ConfigAction = Static<typeof ConfigActionSchema>;
+export declare const ConfigChoiceSchema: Type.TObject<{
+  id: Type.TString;
+  label: Type.TString;
+  /** Right-aligned by the renderer. Sizes, ids, anything narrow. */
+  detail: Type.TOptional<Type.TString>;
+  /** Groups entries under a heading the cursor skips over. */
+  group: Type.TOptional<Type.TString>;
+  status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+  statusText: Type.TOptional<Type.TString>;
+  /**
+   * What enter does on this entry. Carrying it per-entry is what lets one list
+   * hold both an installed model that only needs selecting and an absent one
+   * that needs fetching, without the renderer knowing the difference.
+   */
+  action: Type.TOptional<Type.TString>;
+}>;
+export type ConfigChoice = Static<typeof ConfigChoiceSchema>;
+/**
+ * One line of a multi-step operation.
+ *
+ * Published as a list rather than a single "current step" string so the panel can
+ * show what already ran alongside what is left. During an install that is the
+ * difference between "something is happening" and knowing a package manager
+ * already finished and a download is now underway.
+ */
+export declare const ConfigStepSchema: Type.TObject<{
+  label: Type.TString;
+  state: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"satisfied">, Type.TLiteral<"running">, Type.TLiteral<"done">, Type.TLiteral<"failed">]>;
+  detail: Type.TOptional<Type.TString>;
+}>;
+export type ConfigStep = Static<typeof ConfigStepSchema>;
+export declare const ConfigProgressSchema: Type.TObject<{
+  label: Type.TString;
+  /** 0 to 1. Omitted when the work has no measurable total. */
+  ratio: Type.TOptional<Type.TNumber>;
+}>;
+export type ConfigProgress = Static<typeof ConfigProgressSchema>;
+export declare const ConfigFieldSchema: Type.TObject<{
+  id: Type.TString;
+  label: Type.TString;
+  kind: Type.TUnion<[Type.TLiteral<"text">, Type.TLiteral<"enum">, Type.TLiteral<"choice">, Type.TLiteral<"info">]>;
+  /** Absent means unset; the renderer shows `placeholder` instead. */
+  value: Type.TOptional<Type.TString>;
+  placeholder: Type.TOptional<Type.TString>;
+  /** One line of help for the focused field. */
+  detail: Type.TOptional<Type.TString>;
+  /** The config key this writes, shown under the focused field so the file stays legible. */
+  keyPath: Type.TOptional<Type.TString>;
+  status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+  /** Doubles as the error line: a rejected edit comes back as the old value plus this. */
+  statusText: Type.TOptional<Type.TString>;
+  choices: Type.TOptional<Type.TArray<Type.TObject<{
+    id: Type.TString;
+    label: Type.TString;
+    /** Right-aligned by the renderer. Sizes, ids, anything narrow. */
+    detail: Type.TOptional<Type.TString>;
+    /** Groups entries under a heading the cursor skips over. */
+    group: Type.TOptional<Type.TString>;
+    status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+    statusText: Type.TOptional<Type.TString>;
+    /**
+     * What enter does on this entry. Carrying it per-entry is what lets one list
+     * hold both an installed model that only needs selecting and an absent one
+     * that needs fetching, without the renderer knowing the difference.
+     */
+    action: Type.TOptional<Type.TString>;
+  }>>>;
+  actions: Type.TOptional<Type.TArray<Type.TObject<{
+    key: Type.TString;
+    label: Type.TString;
+    action: Type.TString;
+  }>>>;
+  /** Work is running; the renderer dims the field and offers abort. */
+  busy: Type.TOptional<Type.TBoolean>;
+  progress: Type.TOptional<Type.TObject<{
+    label: Type.TString;
+    /** 0 to 1. Omitted when the work has no measurable total. */
+    ratio: Type.TOptional<Type.TNumber>;
+  }>>;
+  steps: Type.TOptional<Type.TArray<Type.TObject<{
+    label: Type.TString;
+    state: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"satisfied">, Type.TLiteral<"running">, Type.TLiteral<"done">, Type.TLiteral<"failed">]>;
+    detail: Type.TOptional<Type.TString>;
+  }>>>;
+  /**
+   * The tail of a running command's terminal output.
+   *
+   * A tail rather than the whole scrollback: the field is a few rows of a
+   * shared pane, and what matters is the question a package manager just
+   * asked, not what it printed a minute ago.
+   */
+  output: Type.TOptional<Type.TArray<Type.TString>>;
+  /**
+   * The command is waiting on the user. The renderer offers a line to type
+   * into, which comes back as an owner-defined action carrying the text.
+   */
+  awaitingInput: Type.TOptional<Type.TBoolean>;
+}>;
+export type ConfigField = Static<typeof ConfigFieldSchema>;
+export declare const ConfigSectionSchema: Type.TObject<{
+  id: Type.TString;
+  title: Type.TString;
+  detail: Type.TOptional<Type.TString>;
+  order: Type.TInteger;
+  /** Section-wide state: readiness, or why a write failed. */
+  notice: Type.TOptional<Type.TString>;
+  noticeLevel: Type.TOptional<Type.TUnion<[Type.TLiteral<"info">, Type.TLiteral<"error">]>>;
+  fields: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    label: Type.TString;
+    kind: Type.TUnion<[Type.TLiteral<"text">, Type.TLiteral<"enum">, Type.TLiteral<"choice">, Type.TLiteral<"info">]>;
+    /** Absent means unset; the renderer shows `placeholder` instead. */
+    value: Type.TOptional<Type.TString>;
+    placeholder: Type.TOptional<Type.TString>;
+    /** One line of help for the focused field. */
+    detail: Type.TOptional<Type.TString>;
+    /** The config key this writes, shown under the focused field so the file stays legible. */
+    keyPath: Type.TOptional<Type.TString>;
+    status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+    /** Doubles as the error line: a rejected edit comes back as the old value plus this. */
+    statusText: Type.TOptional<Type.TString>;
+    choices: Type.TOptional<Type.TArray<Type.TObject<{
+      id: Type.TString;
+      label: Type.TString;
+      /** Right-aligned by the renderer. Sizes, ids, anything narrow. */
+      detail: Type.TOptional<Type.TString>;
+      /** Groups entries under a heading the cursor skips over. */
+      group: Type.TOptional<Type.TString>;
+      status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+      statusText: Type.TOptional<Type.TString>;
+      /**
+       * What enter does on this entry. Carrying it per-entry is what lets one list
+       * hold both an installed model that only needs selecting and an absent one
+       * that needs fetching, without the renderer knowing the difference.
+       */
+      action: Type.TOptional<Type.TString>;
+    }>>>;
+    actions: Type.TOptional<Type.TArray<Type.TObject<{
+      key: Type.TString;
+      label: Type.TString;
+      action: Type.TString;
+    }>>>;
+    /** Work is running; the renderer dims the field and offers abort. */
+    busy: Type.TOptional<Type.TBoolean>;
+    progress: Type.TOptional<Type.TObject<{
+      label: Type.TString;
+      /** 0 to 1. Omitted when the work has no measurable total. */
+      ratio: Type.TOptional<Type.TNumber>;
+    }>>;
+    steps: Type.TOptional<Type.TArray<Type.TObject<{
+      label: Type.TString;
+      state: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"satisfied">, Type.TLiteral<"running">, Type.TLiteral<"done">, Type.TLiteral<"failed">]>;
+      detail: Type.TOptional<Type.TString>;
+    }>>>;
+    /**
+     * The tail of a running command's terminal output.
+     *
+     * A tail rather than the whole scrollback: the field is a few rows of a
+     * shared pane, and what matters is the question a package manager just
+     * asked, not what it printed a minute ago.
+     */
+    output: Type.TOptional<Type.TArray<Type.TString>>;
+    /**
+     * The command is waiting on the user. The renderer offers a line to type
+     * into, which comes back as an owner-defined action carrying the text.
+     */
+    awaitingInput: Type.TOptional<Type.TBoolean>;
+  }>>;
+}>;
+export type ConfigSection = Static<typeof ConfigSectionSchema>;
+declare const ConfigSourceRefSchema: Type.TObject<{
+  source: Type.TString;
+  generation: Type.TString;
+}>;
+declare const ConfigSnapshotSchema: Type.TObject<{
+  source: Type.TString;
+  generation: Type.TString;
+  sections: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    title: Type.TString;
+    detail: Type.TOptional<Type.TString>;
+    order: Type.TInteger;
+    /** Section-wide state: readiness, or why a write failed. */
+    notice: Type.TOptional<Type.TString>;
+    noticeLevel: Type.TOptional<Type.TUnion<[Type.TLiteral<"info">, Type.TLiteral<"error">]>>;
+    fields: Type.TArray<Type.TObject<{
+      id: Type.TString;
+      label: Type.TString;
+      kind: Type.TUnion<[Type.TLiteral<"text">, Type.TLiteral<"enum">, Type.TLiteral<"choice">, Type.TLiteral<"info">]>;
+      /** Absent means unset; the renderer shows `placeholder` instead. */
+      value: Type.TOptional<Type.TString>;
+      placeholder: Type.TOptional<Type.TString>;
+      /** One line of help for the focused field. */
+      detail: Type.TOptional<Type.TString>;
+      /** The config key this writes, shown under the focused field so the file stays legible. */
+      keyPath: Type.TOptional<Type.TString>;
+      status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+      /** Doubles as the error line: a rejected edit comes back as the old value plus this. */
+      statusText: Type.TOptional<Type.TString>;
+      choices: Type.TOptional<Type.TArray<Type.TObject<{
+        id: Type.TString;
+        label: Type.TString;
+        /** Right-aligned by the renderer. Sizes, ids, anything narrow. */
+        detail: Type.TOptional<Type.TString>;
+        /** Groups entries under a heading the cursor skips over. */
+        group: Type.TOptional<Type.TString>;
+        status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+        statusText: Type.TOptional<Type.TString>;
+        /**
+         * What enter does on this entry. Carrying it per-entry is what lets one list
+         * hold both an installed model that only needs selecting and an absent one
+         * that needs fetching, without the renderer knowing the difference.
+         */
+        action: Type.TOptional<Type.TString>;
+      }>>>;
+      actions: Type.TOptional<Type.TArray<Type.TObject<{
+        key: Type.TString;
+        label: Type.TString;
+        action: Type.TString;
+      }>>>;
+      /** Work is running; the renderer dims the field and offers abort. */
+      busy: Type.TOptional<Type.TBoolean>;
+      progress: Type.TOptional<Type.TObject<{
+        label: Type.TString;
+        /** 0 to 1. Omitted when the work has no measurable total. */
+        ratio: Type.TOptional<Type.TNumber>;
+      }>>;
+      steps: Type.TOptional<Type.TArray<Type.TObject<{
+        label: Type.TString;
+        state: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"satisfied">, Type.TLiteral<"running">, Type.TLiteral<"done">, Type.TLiteral<"failed">]>;
+        detail: Type.TOptional<Type.TString>;
+      }>>>;
+      /**
+       * The tail of a running command's terminal output.
+       *
+       * A tail rather than the whole scrollback: the field is a few rows of a
+       * shared pane, and what matters is the question a package manager just
+       * asked, not what it printed a minute ago.
+       */
+      output: Type.TOptional<Type.TArray<Type.TString>>;
+      /**
+       * The command is waiting on the user. The renderer offers a line to type
+       * into, which comes back as an owner-defined action carrying the text.
+       */
+      awaitingInput: Type.TOptional<Type.TBoolean>;
+    }>>;
+  }>>;
+}>;
+export type ConfigSnapshot = Static<typeof ConfigSnapshotSchema>;
+export type ConfigSourceRef = Static<typeof ConfigSourceRefSchema>;
+export declare const CONFIG_ACTION: {
+  readonly set: 'set';
+  readonly clear: 'clear';
+};
+export interface DoomExtensionContext {
+  sessionManager: {
+    getSessionId(): string;
+  };
+}
+export interface DoomConfigSectionView extends ConfigSection {
+  source: string;
+}
+export interface DoomConfigInvocation {
+  source: string;
+  sectionId: string;
+  fieldId: string;
+  action: string;
+  value?: string;
+}
+export interface DoomConfigActionInput<Context extends DoomExtensionContext = DoomExtensionContext> {
+  ctx: Context;
+  sectionId: string;
+  fieldId: string;
+  value?: string;
+}
+export interface DoomConfigContributionOptions<Context extends DoomExtensionContext = DoomExtensionContext> {
+  source: string;
+  listSections: () => readonly ConfigSection[];
+  handlers: Readonly<Record<string, (input: DoomConfigActionInput<Context>) => void | Promise<void>>>;
+  onError: (error: unknown, actionName: string, ctx: Context) => void;
+}
+export interface DoomConfigContributionHandle {
+  update(): void;
+  dispose(): void;
+}
+//#endregion
+//# sourceMappingURL=runtime-config.d.cts.map

package/dist/runtime-config.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-config.d.cts","names":[],"sources":["../src/schemas/config.ts"],"mappings":";;;qBAqBa;;qBAGA,oBAAkB,KAAA;;;;;;qBAalB,oBAAkB,KAAA,QAAA,KAAA,mBAAA,KAAA,uBAAA,KAAA;YAKnB,eAAe,cAAc;qBAE5B,uBAAqB,KAAA,QAAA,KAAA,kBAAA,KAAA,kBAAA,KAAA,oBAAA,KAAA;YAUtB,kBAAkB,cAAc;;;;;;qBAO/B,oBAAkB,KAAA;;;;;YAQnB,eAAe,cAAc;qBAE5B,oBAAkB,KAAA;;;;;;;;;;;;;;;;YAmBnB,eAAe,cAAc;;;;;;;;;qBAU5B,kBAAgB,KAAA;;;;;YAejB,aAAa,cAAc;qBAE1B,sBAAoB,KAAA;;;;;YAQrB,iBAAiB,cAAc;qBAE9B,mBAAiB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqClB,cAAc,cAAc;qBAE3B,qBAAmB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAapB,gBAAgB,cAAc;cAEpC,uBAAqB,KAAA;;;;cAKrB,sBAAoB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAId,iBAAiB,cAAc;YAC/B,kBAAkB,cAAc;qBAE/B;WACX;WACA;;iBAGe;EACf;IAAkB;;;iBAGH,8BAA8B;EAC7C;;iBAGe;EACf;EACA;EACA;EACA;EACA;;iBAGe,sBAAsB,gBAAgB,uBAAuB;EAC5E,KAAK;EACL;EACA;EACA;;iBAGe,8BAA8B,gBAAgB,uBAAuB;EACpF;EACA,6BAA6B;EAC7B,UAAU,SAAS,gBAAgB,OAAO,sBAAsB,oBAAoB;EACpF,UAAU,gBAAgB,oBAAoB,KAAK;;iBAGpC;EACf;EACA"}