dsh-output-styles 0.2.0

package/lib/invariant-LV6hQX5s.js

@@ -0,0 +1,442 @@
+import { join } from "node:path";
+import { readFileSync, readdirSync } from "node:fs";
+import { z } from "zod";
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import { parse } from "yaml";
+//#region src/types.ts
+/** The reserved switch target that removes a session's selection. */
+const OFF = "off";
+/**
+* Provenance marker stored with every selection record. It states who wrote
+* the record, so a session's style choice can be attributed to this plugin
+* when the log is rebuilt or audited.
+*/
+const STYLE_SOURCE = {
+	kind: "plugin",
+	plugin: "dsh-output-styles"
+};
+/** One durable per-session selection record. */
+const styleSelectionSchema = z.object({
+	/** Selected style name; a name present in the style library at write time. */
+	style: z.string().min(1),
+	/** Producer marker; always this plugin's own {@link STYLE_SOURCE}. */
+	source: z.object({
+		kind: z.literal("plugin"),
+		plugin: z.string().min(1)
+	})
+});
+/**
+* The plugin's storage domain: one `selection` record per session, keyed by
+* the session id. Versioned independently from the session log format.
+*/
+const OUTPUT_STYLE_DOMAIN = defineDomain({
+	name: "output_style",
+	version: 1,
+	tables: { selection: domainTable(styleSelectionSchema) }
+});
+/** Validates the `style` projection's wire payload before it leaves the host. */
+const styleSelectionViewSchema = z.object({
+	options: z.array(z.object({
+		value: z.string().min(1),
+		name: z.string().min(1),
+		description: z.string().min(1),
+		whenToUse: z.string().min(1).optional()
+	})),
+	currentValue: z.string().min(1).nullable()
+});
+//#endregion
+//#region src/style-command.ts
+/** Command name registered on `ctx.commands`; also the log's `command/run` name. */
+const STYLE_COMMAND = "style";
+/**
+* Parse the text after `/style` into one switch decision. The empty string
+* is `none` — the handler treats it as the listing form, and the projection
+* fold ignores it. Anything else is a switch: `off` restores the default,
+* and every other input is one style name taken verbatim (style names may
+* contain spaces, so the whole remainder is the candidate). Unknown names
+* are rejected by the handler against the library, and the fold commits only
+* what the handler reports as successful, so both sides agree on what
+* actually switched.
+* @param rawInput - verbatim text after the command name.
+* @returns the decision; non-empty inputs other than `off` name a style.
+*/
+function parseStyleInput(rawInput) {
+	const arg = rawInput.trim();
+	if (arg === "") return { kind: "none" };
+	if (arg === "off") return { kind: "off" };
+	return {
+		kind: "switch",
+		name: arg
+	};
+}
+/** State for the empty log. */
+const EMPTY_STYLE_STATE = {
+	current: null,
+	pending: null
+};
+/**
+* One-event transition of the `style` projection unit. Only a successful
+* `/style` command settles into `current`: `command/run` parks the target as
+* `pending` and its paired `command/done` commits it on `kind: 'success'` or
+* drops it otherwise. Every other event returns the same reference (the
+* registry's change gate).
+* @param state - the folded state before `event`.
+* @param event - one committed session event.
+* @returns the next state; the same reference when the event leaves it unchanged.
+*/
+function applyStyleEvent(state, event) {
+	if (event.type === "command/run") {
+		if (event.data.name !== "style" || event.data.args === void 0) return state;
+		const input = parseStyleInput(event.data.args);
+		if (input.kind === "none") return state;
+		const commandId = String(event.data.commandId);
+		if (state.pending?.commandId === commandId) return state;
+		const target = input.kind === "off" ? { off: true } : { name: input.name };
+		return {
+			...state,
+			pending: {
+				commandId,
+				target
+			}
+		};
+	}
+	if (event.type !== "command/done" || state.pending === null) return state;
+	if (state.pending.commandId !== String(event.data.commandId)) return state;
+	if (event.data.kind !== "success") return {
+		current: state.current,
+		pending: null
+	};
+	return {
+		current: "off" in state.pending.target ? null : state.pending.target.name,
+		pending: null
+	};
+}
+//#endregion
+//#region src/style-library.ts
+/**
+* Style-library loading: one style per `*.md` file (frontmatter + body),
+* with optional Claude Code `outputStyles` JSON compatibility (single entry
+* or an array of entries per file).
+*
+* A style file that does not parse is skipped with a warning; the plugin
+* stays loadable. Structural ambiguity — a duplicate style name, a style
+* named `off`, or two styles declaring `force` — fails the load because it
+* would silently change which body gets injected.
+* @module dsh-output-styles/style-library
+*/
+/** Character set for style names: letters, digits, spaces, and hyphens only. */
+const STYLE_NAME_RE = /^[\p{L}\p{N} -]+$/u;
+/**
+* Whether a name is a legal style name and switch target: at least one
+* letter or digit, only letters/digits/spaces/hyphens, and no leading or
+* trailing space. Spaces are the only whitespace allowed, so a name is
+* always a single switchable line the model can echo back. `off` passes this
+* check but is a reserved target rejected by the library.
+* @param name - candidate style name.
+* @returns whether the name is legal.
+*/
+function isValidStyleName(name) {
+	if (name === "" || name !== name.trim()) return false;
+	if (!STYLE_NAME_RE.test(name)) return false;
+	return /[\p{L}\p{N}]/u.test(name);
+}
+/**
+* Load the style library from one or more directories. Later directories
+* override earlier ones on a same-named style (the Claude Code
+* "closest-to-the-working-directory wins" rule); duplicates within one
+* directory still fail the load. Deterministic order: directories in the
+* given order, files within a directory sorted by code unit.
+* @param stylesDirs - absolute directories, lowest priority first.
+* @param options.compatJson - whether `*.json` entries are loaded.
+* @param warn - warning sink (skipped files, unknown frontmatter keys).
+* @returns the library keyed by style name, in directory/file order.
+* @throws when a directory is unreadable, a style is named `off`, two files
+*   in one directory declare the same name, or two styles declare `force`.
+*/
+function loadStyleLibrary(stylesDirs, options, warn) {
+	const styles = /* @__PURE__ */ new Map();
+	for (const dir of stylesDirs) for (const [name, style] of loadStyleDir(dir, options, warn)) styles.set(name, style);
+	const forced = [...styles.values()].filter((style) => style.force);
+	if (forced.length > 1) throw new Error(`dsh-output-styles: styles ${forced.map((style) => style.file).join(" and ")} both declare force; at most one style may be forced`);
+	return styles;
+}
+/** Load every style in one directory (duplicates within it fail the load). */
+function loadStyleDir(stylesDir, options, warn) {
+	let entries;
+	try {
+		entries = readdirSync(stylesDir, { withFileTypes: true });
+	} catch (cause) {
+		throw new Error(`dsh-output-styles: style directory ${stylesDir} is unreadable`, { cause });
+	}
+	entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+	const styles = /* @__PURE__ */ new Map();
+	const addStyle = (style) => {
+		if (style.name === "off") throw new Error(`dsh-output-styles: style ${style.file} is named "off", which is reserved for switching output styles off`);
+		if (styles.has(style.name)) throw new Error(`dsh-output-styles: duplicate style name "${style.name}" (${styles.get(style.name)?.file} and ${style.file})`);
+		styles.set(style.name, style);
+	};
+	for (const entry of entries) {
+		if (!entry.isFile()) continue;
+		const file = entry.name;
+		if (file.endsWith(".md")) {
+			const parsed = parseMarkdownStyle(file, readStyleFile(stylesDir, file, warn));
+			if (parsed.oddity !== void 0) warn(parsed.oddity);
+			if (parsed.problem !== void 0) {
+				warn(`skipping ${file}: ${parsed.problem}`);
+				continue;
+			}
+			if (parsed.style !== void 0) addStyle(parsed.style);
+		} else if (file.endsWith(".json")) {
+			if (!options.compatJson) {
+				warn(`ignoring ${file}: JSON style loading is disabled (compatJson: false)`);
+				continue;
+			}
+			for (const style of parseJsonFile(file, readStyleFile(stylesDir, file, warn), warn)) addStyle(style);
+		}
+	}
+	return styles;
+}
+/** Read one library file; an unreadable file is a skipped-file warning. */
+function readStyleFile(stylesDir, file, warn) {
+	try {
+		return readFileSync(join(stylesDir, file), "utf8");
+	} catch (cause) {
+		warn(`skipping ${file}: unreadable (${cause instanceof Error ? cause.message : String(cause)})`);
+		return;
+	}
+}
+/** Parse a `---`-fenced frontmatter style file. */
+function parseMarkdownStyle(file, source) {
+	if (source === void 0) return {};
+	const open = /^---[ \t]*\r?\n/.exec(source);
+	if (open === null) return { problem: "missing `---` frontmatter block" };
+	const close = /\r?\n---[ \t]*(?:\r?\n|$)/.exec(source.slice(open[0].length));
+	if (close === null) return { problem: "unterminated `---` frontmatter block" };
+	const frontmatter = source.slice(open[0].length, open[0].length + close.index);
+	const bodyStart = open[0].length + close.index + close[0].length;
+	const body = source.slice(bodyStart).trim();
+	const parsed = parseFrontmatter(file, frontmatter);
+	if (parsed.problem !== void 0) return { problem: parsed.problem };
+	if (body === "") return { problem: "style body must be non-empty" };
+	const fields = parsed.fields;
+	if (fields === void 0) return {};
+	const style = {
+		name: fields.name,
+		description: fields.description,
+		...fields.whenToUse === void 0 ? {} : { whenToUse: fields.whenToUse },
+		body,
+		file,
+		format: "md",
+		keepCodingInstructions: fields.keepCodingInstructions,
+		force: fields.force
+	};
+	return parsed.oddity === void 0 ? { style } : {
+		style,
+		oddity: parsed.oddity
+	};
+}
+/** Attach a present oddity without an explicit-undefined optional key. */
+function withOddity(value, oddity) {
+	return oddity === void 0 ? value : {
+		...value,
+		oddity
+	};
+}
+/** The file name a `name`-less style inherits: the file name without its extension. */
+function defaultStyleName(file) {
+	return file.slice(0, file.length - 3);
+}
+/** Keys both frontmatter formats accept, plus the booleans they share. */
+const FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
+	"name",
+	"description",
+	"whenToUse",
+	"keep-coding-instructions",
+	"force"
+]);
+/** Validate one frontmatter block into {@link StyleFields}. */
+function parseFrontmatter(file, frontmatter) {
+	let raw;
+	try {
+		raw = parse(frontmatter);
+	} catch (cause) {
+		return { problem: `frontmatter is not valid YAML (${cause instanceof Error ? cause.message : String(cause)})` };
+	}
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return { problem: "frontmatter must be a mapping of scalar fields" };
+	const record = raw;
+	const oddityKeys = Object.keys(record).filter((key) => !FRONTMATTER_KEYS.has(key));
+	const oddity = oddityKeys.length > 0 ? `${file}: ignoring unknown frontmatter field${oddityKeys.length > 1 ? "s" : ""} ${oddityKeys.join(", ")}` : void 0;
+	const { name, description, whenToUse } = record;
+	const effectiveName = name === void 0 ? defaultStyleName(file) : name;
+	if (typeof effectiveName !== "string" || !isValidStyleName(effectiveName)) return withOddity({ problem: "frontmatter name must be letters, digits, spaces, or hyphens, with at least one letter or digit and no leading/trailing space" }, oddity);
+	if (typeof description !== "string" || description.trim() === "") return withOddity({ problem: "frontmatter description must be a non-empty string" }, oddity);
+	if (whenToUse !== void 0 && typeof whenToUse !== "string") return withOddity({ problem: "frontmatter whenToUse must be a string when present" }, oddity);
+	const booleans = booleanFields(record, "frontmatter");
+	if (booleans.problem !== void 0) return withOddity({ problem: booleans.problem }, oddity);
+	return withOddity({ fields: {
+		name: effectiveName,
+		description: description.trim(),
+		...whenToUse === void 0 ? {} : { whenToUse: whenToUse.trim() },
+		keepCodingInstructions: booleans.keepCodingInstructions,
+		force: booleans.force
+	} }, oddity);
+}
+/** Read the two shared boolean flags, defaulting each to false. */
+function booleanFields(record, source) {
+	const keep = record["keep-coding-instructions"];
+	if (keep !== void 0 && typeof keep !== "boolean") return {
+		keepCodingInstructions: false,
+		force: false,
+		problem: `${source} keep-coding-instructions must be a boolean when present`
+	};
+	const force = record["force"];
+	if (force !== void 0 && typeof force !== "boolean") return {
+		keepCodingInstructions: false,
+		force: false,
+		problem: `${source} force must be a boolean when present`
+	};
+	return {
+		keepCodingInstructions: keep ?? false,
+		force: force ?? false
+	};
+}
+/**
+* Parse a Claude Code `outputStyles` JSON file: one entry or an array of
+* entries (the legacy `settings.json` collection form). Bad entries are
+* skipped with one warning each; a bad file skips the whole file.
+*/
+function parseJsonFile(file, source, warn) {
+	if (source === void 0) return [];
+	let raw;
+	try {
+		raw = JSON.parse(source);
+	} catch (cause) {
+		warn(`skipping ${file}: invalid JSON (${cause instanceof Error ? cause.message : String(cause)})`);
+		return [];
+	}
+	const records = Array.isArray(raw) ? raw : [raw];
+	const styles = [];
+	for (const [index, record] of records.entries()) {
+		const label = Array.isArray(raw) ? `${file}#${index + 1}` : file;
+		const entry = parseJsonEntry(label, record);
+		if (entry.oddity !== void 0) warn(entry.oddity);
+		if (entry.problem !== void 0) {
+			warn(`skipping ${label}: ${entry.problem}`);
+			continue;
+		}
+		if (entry.style !== void 0) styles.push(entry.style);
+	}
+	return styles;
+}
+/** Parse one Claude Code `outputStyles` JSON entry. */
+function parseJsonEntry(label, record) {
+	if (record === null || typeof record !== "object" || Array.isArray(record)) return { problem: "must be a JSON object" };
+	const raw = record;
+	const { name, description, prompt, whenToUse } = raw;
+	if (typeof name !== "string" || !isValidStyleName(name)) return { problem: "name must be letters, digits, spaces, or hyphens, with at least one letter or digit and no leading/trailing space" };
+	if (typeof description !== "string" || description.trim() === "") return { problem: "description must be a non-empty string" };
+	if (typeof prompt !== "string" || prompt.trim() === "") return { problem: "prompt must be a non-empty string" };
+	const oddityKeys = Object.keys(raw).filter((key) => !FRONTMATTER_KEYS.has(key) && key !== "prompt");
+	const oddity = oddityKeys.length > 0 ? `${label}: ignoring unknown JSON field${oddityKeys.length > 1 ? "s" : ""} ${oddityKeys.join(", ")}` : void 0;
+	if (whenToUse !== void 0 && typeof whenToUse !== "string") return withOddity({ problem: "whenToUse must be a string when present" }, oddity);
+	const booleans = booleanFields(raw, "JSON");
+	if (booleans.problem !== void 0) return withOddity({ problem: booleans.problem }, oddity);
+	return withOddity({ style: {
+		name,
+		description: description.trim(),
+		...whenToUse === void 0 ? {} : { whenToUse: whenToUse.trim() },
+		body: prompt.trim(),
+		file: label,
+		format: "json",
+		keepCodingInstructions: booleans.keepCodingInstructions,
+		force: booleans.force
+	} }, oddity);
+}
+/**
+* Apply the style-body budget: bodies at most `maxChars` code points pass
+* through; longer bodies are cut at the budget and closed with `marker` (the
+* marker itself is not counted against the budget). The cut is code-point
+* safe, so a multi-unit emoji is never split in half.
+* @param body - the raw style body.
+* @param maxChars - budget in code points; at least 1.
+* @param marker - text appended at the truncation point.
+* @returns the body as it will be injected.
+*/
+function truncateStyle(body, maxChars, marker) {
+	const chars = Array.from(body);
+	if (chars.length <= maxChars) return body;
+	return chars.slice(0, maxChars).join("") + marker;
+}
+//#endregion
+//#region src/invariant.ts
+/** Full npm package name owning the reported failures. */
+const PACKAGE_NAME = "dsh-output-styles";
+/** Cordis companion plugin name. */
+const name = "dsh-output-styles-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/** Facts for the standalone companion: envelope checks only, no library/domain handle. */
+const COMPANION_FACTS = { knownStyles: () => void 0 };
+/**
+* Build the installer over a facts source. The standalone companion and the
+* main plugin share this body; only the facts differ.
+* @param facts - library and domain access for the checks.
+* @returns the installer the host registry activates in its child context.
+*/
+function installInvariant(facts) {
+	return (ctx, fail) => {
+		const pending = /* @__PURE__ */ new Map();
+		ctx.on("domain/changed", (change) => {
+			if (change.domain !== "output_style" || change.table !== "selection" || change.operation !== "put") return;
+			const value = change.value;
+			if (typeof value.style !== "string" || !isValidStyleName(value.style)) fail(`selection record names invalid style ${JSON.stringify(value.style)}`);
+			if (JSON.stringify(value.source) !== JSON.stringify(STYLE_SOURCE)) fail(`selection record source is ${JSON.stringify(value.source)}; expected this plugin's own marker`);
+			const known = facts.knownStyles();
+			if (known !== void 0 && typeof value.style === "string" && !known.has(value.style)) fail(`selection record names style "${value.style}" that is not in the style library`);
+		});
+		ctx.on("session/event", (session, event) => {
+			if (event.type === "command/run" && event.data.name === "style" && event.data.args !== void 0) {
+				const input = parseStyleInput(event.data.args);
+				if (input.kind === "off") pending.set(String(event.data.commandId), {
+					session,
+					expected: { off: true }
+				});
+				else if (input.kind === "switch") pending.set(String(event.data.commandId), {
+					session,
+					expected: { name: input.name }
+				});
+				return;
+			}
+			if (event.type !== "command/done") return;
+			const entry = pending.get(String(event.data.commandId));
+			if (entry === void 0) return;
+			pending.delete(String(event.data.commandId));
+			if (event.data.kind !== "success" || facts.selectionFor === void 0) return;
+			const record = facts.selectionFor(entry.session.id);
+			if ("off" in entry.expected) {
+				if (record !== void 0) fail(`/style off settled on session "${entry.session.id}" but its selection record still exists`);
+			} else if (record === void 0 || record.style !== entry.expected.name) fail(`/style ${entry.expected.name} settled on session "${entry.session.id}" without a matching selection record`);
+		}, { global: true });
+	};
+}
+/**
+* Resolve the host registry through Cordis's named service lookup. Keeping
+* this narrow local contract lets the companion build without host source
+* files; a composed DSH profile still supplies the real `invariants` service.
+* @param ctx - Cordis context carrying the host service.
+* @returns the host invariant registry.
+* @throws {Error} when the companion is loaded without its host service.
+*/
+function getInvariantRegistry(ctx) {
+	const registry = ctx.get("invariants");
+	if (registry === void 0) throw new Error(`invariant companion requires the "invariants" service for ${PACKAGE_NAME}`);
+	return registry;
+}
+/**
+* Register the standalone companion with envelope-only facts.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(getInvariantRegistry(ctx).register(PACKAGE_NAME, installInvariant(COMPANION_FACTS)));
+//#endregion
+export { styleSelectionSchema as _, name as a, loadStyleLibrary as c, STYLE_COMMAND as d, applyStyleEvent as f, STYLE_SOURCE as g, OUTPUT_STYLE_DOMAIN as h, installInvariant as i, truncateStyle as l, OFF as m, apply as n, STYLE_NAME_RE as o, parseStyleInput as p, inject as r, isValidStyleName as s, PACKAGE_NAME as t, EMPTY_STYLE_STATE as u, styleSelectionViewSchema as v };

package/lib/invariant.js

@@ -0,0 +1,2 @@
+import { a as name, i as installInvariant, n as apply, r as inject, t as PACKAGE_NAME } from "./invariant-LV6hQX5s.js";
+export { PACKAGE_NAME, apply, inject, installInvariant, name };

package/lib/types/client/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Browser half of `dsh-output-styles`: a popup picker decorating the HOST
+ * `/style` command. The picker reads the `style` session projection
+ * (`{ options, currentValue }`), which the host plugin keeps fresh, and
+ * submits the completed `/style <name>` / `/style off` line back through the
+ * command Remote — so every switch keeps the host's durable command
+ * lifecycle (`command/run`/`command/done`) and the projection stays the
+ * single displayed fact.
+ * @module dsh-output-styles/client
+ */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import { type StyleKey } from './locales.ts';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The style picker's copy. */
+        style: StyleKey;
+    }
+}
+/** Client plugin name; keep stable after publishing. */
+export declare const name = "dsh-output-styles-client";
+/** Required client services: the command surface, the sessions face, the command Remote, and locale. */
+export declare const inject: string[];
+/**
+ * Client plugin body: register the `style` dictionaries and decorate the
+ * host `/style` command's bare invocation with the projection-backed picker.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: ClientContext): void;
+export type { SessionId } from '@deepseek-ai/dsh-client-runtime/client';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,wCAAwC,CAAA;AAMtF,OAAO,EAAU,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEpD,OAAO,QAAQ,kCAAkC,CAAC;IAChD,UAAU,kBAAkB;QAC1B,+BAA+B;QAC/B,KAAK,EAAE,QAAQ,CAAA;KAChB;CACF;AAED,wDAAwD;AACxD,eAAO,MAAM,IAAI,6BAA6B,CAAA;AAE9C,wGAAwG;AACxG,eAAO,MAAM,MAAM,UAAgD,CAAA;AA6BnE;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAqC9C;AAED,YAAY,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAA"}

package/lib/types/client/locales.d.ts

@@ -0,0 +1,13 @@
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export declare const zh: {
+    'option.off': string;
+    'option.offDetail': string;
+};
+/** The style picker namespace key union. */
+export type StyleKey = keyof typeof zh;
+/** English dictionary, checked complete against the zh key set. */
+export declare const en: {
+    'option.off': string;
+    'option.offDetail': string;
+};
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/locales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../../src/client/locales.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,eAAO,MAAM,EAAE;;;CAGmB,CAAA;AAElC,4CAA4C;AAC5C,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,EAAE,CAAA;AAEtC,mEAAmE;AACnE,eAAO,MAAM,EAAE;;;CAGqB,CAAA"}

package/lib/types/config.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Serializable configuration, schema, and direct-call defaults.
+ *
+ * Every tunable lives here: a deployment changes behavior through
+ * `cordis.yml`, never by editing source. The schema is validated by the
+ * harness Loader while the plugin loads; invalid configuration fails the
+ * load with an actionable error.
+ * @module dsh-output-styles/config
+ */
+import z from '@deepseek-ai/schemastery';
+/** Plugin configuration supplied by the profile composition. */
+export interface Config {
+    /**
+     * Directories holding the style library (`*.md`, and with {@link Config.compatJson}
+     * also `*.json`). Each entry resolves against the process working directory.
+     * Later directories override earlier ones on a same-named style; the bundled
+     * `styles/` directory participates as the lowest-priority entry unless
+     * {@link Config.includeBuiltins} is false. An empty list means the bundled
+     * library only (or none, with `includeBuiltins: false`). A bare string is
+     * accepted as a single-directory list.
+     */
+    stylesDir?: string | string[];
+    /** Style-body budget in characters; longer bodies are truncated at the budget with a marker. */
+    maxStyleChars?: number;
+    /**
+     * Style injected into sessions that never selected one (and no project
+     * settings default exists). The empty string (default) means new sessions
+     * get no style — the session's own selection, made through `/style`, is
+     * always what wins for a session that has one.
+     */
+    defaultStyle?: string;
+    /** Load Claude Code `outputStyles` JSON entries (`{ name, description, prompt }`) beside Markdown styles. */
+    compatJson?: boolean;
+    /** Order of the injected system-prompt section (90: after the persona, before tool guidance at 100–199). */
+    sectionOrder?: number;
+    /** Marker appended at the truncation point when a style body exceeds {@link Config.maxStyleChars}. */
+    truncationMarker?: string;
+    /** Include the package's bundled `styles/` directory in the library. */
+    includeBuiltins?: boolean;
+    /** Reload the library when a style file changes on disk (default true). */
+    watchStyles?: boolean;
+}
+/** Configuration after defaults have been resolved. */
+export interface ResolvedConfig {
+    /** Absolute style-library directories, lowest priority first (bundled styles first when included). */
+    stylesDirs: string[];
+    /** Style-body budget in characters; at least 1. */
+    maxStyleChars: number;
+    /** Style injected into sessions that never selected one; `''` means none. */
+    defaultStyle: string;
+    /** Whether Claude Code `outputStyles` JSON entries are loaded. */
+    compatJson: boolean;
+    /** Order of the injected system-prompt section; a finite number. */
+    sectionOrder: number;
+    /** Marker appended at the truncation point. */
+    truncationMarker: string;
+    /** Whether the bundled `styles/` directory participates. */
+    includeBuiltins: boolean;
+    /** Whether the library reloads on style-file changes. */
+    watchStyles: boolean;
+}
+/** Loader-visible configuration schema and defaults. */
+export declare const Config: z<Config>;
+/**
+ * Resolve the same defaults for direct callers that bypass the Cordis Loader,
+ * and fail loud on values the schema cannot express (a non-finite section
+ * order).
+ * @param config - Partial serialized configuration.
+ * @param defaultStylesDir - Absolute bundled directory used when built-ins are included.
+ * @returns Configuration with every default applied.
+ */
+export declare function resolveConfig(config: Config, defaultStylesDir: string): ResolvedConfig;
+//# sourceMappingURL=config.d.ts.map

package/lib/types/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,CAAC,MAAM,0BAA0B,CAAA;AAGxC,gEAAgE;AAChE,MAAM,WAAW,MAAM;IACrB;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAC7B,gGAAgG;IAChG,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,6GAA6G;IAC7G,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,4GAA4G;IAC5G,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,sGAAsG;IACtG,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,wEAAwE;IACxE,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAC7B,sGAAsG;IACtG,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAA;IACrB,6EAA6E;IAC7E,YAAY,EAAE,MAAM,CAAA;IACpB,kEAAkE;IAClE,UAAU,EAAE,OAAO,CAAA;IACnB,oEAAoE;IACpE,YAAY,EAAE,MAAM,CAAA;IACpB,+CAA+C;IAC/C,gBAAgB,EAAE,MAAM,CAAA;IACxB,4DAA4D;IAC5D,eAAe,EAAE,OAAO,CAAA;IACxB,yDAAyD;IACzD,WAAW,EAAE,OAAO,CAAA;CACrB;AAED,wDAAwD;AACxD,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,MAAM,CAS3B,CAAA;AAEF;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,cAAc,CAuBtF"}

package/lib/types/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `dsh-output-styles`: Claude Code `outputStyles`-equivalent runtime output
+ * styles for DeepSeek Harness. The plugin registers a model-visible system
+ * prompt section that injects the current session's style body, a `/style`
+ * slash command that switches it, per-session persistence over the
+ * `output_style` storage domain, and the `style` session projection.
+ * @module dsh-output-styles
+ */
+/** Cordis plugin name; keep this stable after publishing. */
+export declare const name = "dsh-output-styles";
+/**
+ * Services that must exist before the plugin applies: the prompt-assembly
+ * registry for the injected section, and the storage domain facility for
+ * per-session persistence. A composition without a routed kv backend keeps
+ * the plugin pending until the storage rows appear (Cordis dependency
+ * semantics), instead of racing a parallel mount.
+ */
+export declare const inject: string[];
+export { Config, resolveConfig } from './config.ts';
+export type { ResolvedConfig } from './config.ts';
+export { apply, DEFAULT_STYLES_DIR, OutputStyleRuntime, STYLE_SECTION_NAME } from './runtime.ts';
+export { applyStyleEvent, EMPTY_STYLE_STATE, parseStyleInput, STYLE_COMMAND, } from './style-command.ts';
+export type { StyleFoldState, StyleInput } from './style-command.ts';
+export { isValidStyleName, loadStyleLibrary, STYLE_NAME_RE, truncateStyle, } from './style-library.ts';
+export type { OutputStyle } from './style-library.ts';
+export { OFF, OUTPUT_STYLE_DOMAIN, STYLE_SOURCE, styleSelectionSchema, styleSelectionViewSchema, } from './types.ts';
+export type { StyleOption, StyleSelection, StyleSelectionView } from './types.ts';
+export { installInvariant, PACKAGE_NAME } from './invariant.ts';
+export type { InvariantFacts, InvariantInstaller, InvariantRegistry } from './invariant.ts';
+export type * from './types.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,6DAA6D;AAC7D,eAAO,MAAM,IAAI,sBAAsB,CAAA;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,UAAoC,CAAA;AAEvD,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AACnD,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,EAAE,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAChG,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,aAAa,GACd,MAAM,oBAAoB,CAAA;AAC3B,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACpE,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,aAAa,GACd,MAAM,oBAAoB,CAAA;AAC3B,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EACL,GAAG,EACH,mBAAmB,EACnB,YAAY,EACZ,oBAAoB,EACpB,wBAAwB,GACzB,MAAM,YAAY,CAAA;AACnB,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AACjF,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC/D,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAG3F,mBAAmB,YAAY,CAAA"}