@skaile/forge-editor-compose 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.1.0 - 2026-10-28
+
+### Added
+
+- First release.
+- Entry `.`: `composeBlockTypes({ slotOptions?, labels? })` (the Block types `slot`, `source`, `fact`, `example`; `section` stays forge-editor's), `withAiBrief(blockType, { purpose, instructions? })` and `withProperties(blockType, definitions)` to adapt them per app (pure, they return new Block types), and `KIND` re-exported from `@skaile/forge-compose/documents`.
+- Entry `./vue`: `composeFeatures({ documentId, invoke })` with the features `compose-material` („Block füllen (KI)“ material from facts and ranked examples), `compose-split` („In Beispiele zerlegen (KI)“, „Vorschläge annehmen“, a title-row chip with confidence and origin on proposals), `compose-facts` („Stichpunkte erzeugen (KI)“) and `compose-example` („Als Beispiel übernehmen“); `httpInvoke({ base?, fetch })`, the `ComposeInvoke` type and `createInstance(invoke, input)`.
+- Entry `./server`, free of the AI SDK, h3 and forge-app-actions: the operation contract (`ComposeOperationId`, the zod `composeInputs`, `ComposeInput<K>`, `ComposeOutput<K>`), `ComposeError` (`status`, `statusCode`), `composeOperations(options)` with `material`, `split`, `facts`, `example`, `instance` and `classify` over the host's `ports`, `generate` (forge-compose `Generate`) and `contextOf`, `catalogOf(template, examples, vocabulary?)` (label catalogues from the template and the accepted examples) and `composeTools(ops)` (read-only chat tools `compose_slots`, `compose_material`, `compose_examples`, `compose_classify`, reading the open document from `ToolContext.documentId`).
+- Entry `./server/actions`: `composeActions(define, ops, { authorize, userOf, audience? })`, the five operations as forge-app-actions server actions (`compose.*`); optional peer `@skaile/forge-app-actions`.
+- Entry `./server/ai-sdk`: `aiSdkGenerate({ models, ref, user, onRun? })`, a `Generate` over the editor's `ModelProvider` and the AI SDK; optional peer `ai`.
+- Needs `@skaile/forge-editor` `^6.2.0` and `@skaile/forge-compose` `^0.1.0`.

package/README.md

@@ -1,3 +1,136 @@
-# Temporary Holding Version
+# @skaile/forge-editor-compose
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Corpus → example blocks → tagged templates → generated text, as an add-on of [`@skaile/forge-editor`](../editor). The pure calculus (tag selectors, case profile, ranking, segmentation pipeline, document conventions) lives in [`@skaile/forge-compose`](https://github.com/skaile-ai/forge-compose); this package is its editor side: Block types, editor features and the operation contract the features and the host's routes share.
+
+The documents are ordinary editor documents:
+
+| Block type | Is | Fields (`meta`) |
+|---|---|---|
+| `section` | chapter of a template (forge-editor's own container type) | – |
+| `slot` | one text block of a template, and of an instance made from it | `identifier`, `optional`, `heading`, `anweisung`, `skelett`, `selector` |
+| `source` | a text facts and examples come from | `sourceType`, `date` |
+| `fact` | one statement of a source, assigned to a slot | `slot`, `derivation` |
+| `example` | one reusable text for a slot; tags carry the case (`alter/kind`, `icd/f32`) | `slot`, `status` (`vorschlag` \| `geprüft`), `confidence`, `origin`, `derivation` |
+
+## Entries
+
+| Entry | Exports |
+|---|---|
+| `@skaile/forge-editor-compose` | `composeBlockTypes`, `withAiBrief`, `withProperties`, `KIND` |
+| `@skaile/forge-editor-compose/vue` | `composeFeatures`, `httpInvoke`, `createInstance`, `ComposeInvoke` |
+| `@skaile/forge-editor-compose/server` | `composeOperations`, `composeTools`, `catalogOf`, `ComposeError`, `composeInputs`, `ComposeInput`, `ComposeOutput`, `ComposeOperationId`, `isComposeOperationId`, `FACTS_SYSTEM` |
+| `@skaile/forge-editor-compose/server/actions` | `composeActions` – the five operations as forge-app-actions server actions (`compose.material` …) |
+| `@skaile/forge-editor-compose/server/ai-sdk` | `aiSdkGenerate` – a `Generate` over the editor's `ModelProvider` and the AI SDK |
+
+`./server` never imports the AI SDK, h3 or forge-app-actions; the optional peers `ai` and `@skaile/forge-app-actions` are imported only by `./server/ai-sdk` and `./server/actions`.
+
+## Host wiring
+
+```ts
+import { composeBlockTypes, withAiBrief, withProperties, KIND } from '@skaile/forge-editor-compose'
+import { composeFeatures, httpInvoke } from '@skaile/forge-editor-compose/vue'
+
+// Block types: the four compose types, adapted to the app.
+const [slot, source, fact, example] = composeBlockTypes({ slotOptions: slotsOfTheTemplate /* { value, label }[] */ })
+const blockTypes = [
+  withAiBrief(slot, { purpose: 'Ein Abschnitt eines Entlassbriefs …', instructions: 'Schreibe sachlich, dritte Person, Präteritum.' }),
+  withProperties(source, [{ key: 'format', label: 'Format', type: 'select', options: [{ value: 'verlauf', label: 'Verlauf' }] }]),
+  fact,
+  example,
+]
+
+// Features: the editor calls the host through one function; the host picks the transport.
+const features = composeFeatures({
+  documentId: () => props.documentId,
+  invoke: httpInvoke({ base: '/api/compose', fetch: $fetch }), // POST /api/compose/{material|split|facts|example|instance}
+})
+```
+
+`blockTypes` and `features` go into the host's editor preset (`composeEditor(ui, { blockTypes, add: features })` or the host's wrapper). The preset's `blockTypes` **replaces** the built-in Block types, so the host lists `section` itself (`[...defaultBlockTypes(t), ...composeTypes]`, `defaultBlockTypes` from `@skaile/forge-editor/composites`). The host mounts the routes (or exposes the operations another way): `composeInputs[op]` validates each body, `ComposeOutput<op>` is the answer.
+
+## Server
+
+The operations are plain functions; routes, forge-app-actions definitions and chat tools are projections of them. The host brings the case (`contextOf`), the model (`generate`) and its ports; **authorization is the host's** (its action `authorize` or route check runs before the operation, which trusts `user` for port reads only).
+
+```ts
+import { composeOperations, composeTools, isComposeOperationId, composeInputs, ComposeError } from '@skaile/forge-editor-compose/server'
+import { icdHierarchy } from '@skaile/forge-compose'
+import { entrySplitter } from '@skaile/forge-compose/segment'
+
+const ops = composeOperations({
+  ports,                                   // `documents` (with `putDocument`) required; `embeddings` and `index` optional
+  generate,                                // forge-compose `Generate`: every model call goes through it (see below)
+  exampleLibraryId: 'beispiele',           // where „Als Beispiel übernehmen“ writes; created when missing
+  hierarchy: icdHierarchy,
+  async contextOf(documentId, user) {      // null = unknown document → ComposeError(404)
+    const c = await caseOf(documentId, user)
+    return c && { case: { tags: c.tags, data: c.data }, templateId: c.templateId, sourceIds: c.sourceIds, exampleIds: ['beispiele'] }
+  },
+  segmentation: {
+    rules: [{ pattern: /^Therapie/i, id: 'therapie' }],                // heading → slot (confidence 1, origin `rule`)
+    tagRules: [],                                                      // text → tag, e.g. `icdAnchorRule`
+    splitterFor: source => (source.meta.sourceType === 'verlauf' ? entrySplitter(VERLAUF_HEADER) : null),
+    // llm: false                                                      // no `llmLabeler`; slotLabelers/tagLabelers replace the default lists
+  },
+})
+
+// Chat: the read-only tools compose_slots, compose_material, compose_examples, compose_classify.
+provideEditorServer({ ports, tools: composeTools(ops) })               // `ops` must be what composeOperations returned
+
+// Route (Nuxt/h3): the transport `httpInvoke` calls, POST /api/compose/:op
+export default defineEventHandler(async event => {
+  const op = getRouterParam(event, 'op')
+  if (!isComposeOperationId(op)) throw createError({ statusCode: 404 })
+  const user = await userOf(event)                                    // the host authorizes here
+  try {
+    return await ops[op](composeInputs[op].parse(await readBody(event)), user)
+  }
+  catch (error) {
+    if (error instanceof ComposeError) throw createError({ statusCode: error.status, statusMessage: error.message })
+    throw error
+  }
+})
+```
+
+**Operations** – `material` (facts of the case's sources plus the best examples, scored by `scorers`, default `[tagFitScorer, embeddingScorer, lengthScorer]`; the embedding scorer scores 0 without `ports.embeddings`), `split` (source block → `example` proposals with `status: 'vorschlag'`, `confidence`, `origin`, derivation `ai:split` with the SHA-256 of the body), `facts` (one `generate` call with `stage: 'facts'`; a fact for a slot the template does not have keeps an empty `slot`), `example` (adopt an instance slot into the library; 409 without text), `instance` (409 „Instanz existiert“ unless `force`), `classify` (slot and tags of one text by the configured labelers; chat only). Each answers `ComposeOutput<op>`; failures the caller can act on are `ComposeError` (`status` 400, 404, 409, 422 or 503, `statusCode` the same, so forge-app-actions and h3 map it).
+
+**Learning** – `catalogOf(template, examples, vocabulary?)` builds the slot and tag catalogues the labelers read; the `example` blocks with a status other than `vorschlag` are their examples (newest first), so each acceptance improves the next assignment without a training step. `FACTS_SYSTEM` is the default system message of `facts`; `factsSystem` replaces it for a domain.
+
+**Model seam** – `generate` is the host's: a host with its own pipeline (local-only checks, run log, JSON repair) implements it itself; a host whose `ports.models` comes from `createEditorModelProvider` uses the adapter:
+
+```ts
+import { aiSdkGenerate } from '@skaile/forge-editor-compose/server/ai-sdk'
+const generate = aiSdkGenerate({ models: ports.models, ref, user, onRun: run => log(run) })   // rejects ComposeError(503) without a model
+```
+
+**Actions** – a host with a forge-app-actions catalogue registers the five operations as `compose.material` … `compose.instance`:
+
+```ts
+import { composeActions } from '@skaile/forge-editor-compose/server/actions'
+const actions = composeActions(defineServerAction, ops, { authorize, userOf: ctx => ctx.principal, audience: ['user', 'llm'] })
+serverActionRegistry.registerAll(actions)
+```
+
+## Features
+
+- **`compose-material`** – „Block füllen (KI)“ on a `slot` with an identifier asks `material` and hands the facts and the best-ranked examples to the model (`aiBlockData`, at most 10 entries).
+- **`compose-split`** – „In Beispiele zerlegen (KI)“ on a `source` asks `split` and inserts the returned `example` proposals right after the source in one transaction (one undo step). A proposal shows a chip `Vorschlag 0.82 · embed` (confidence · origin) in its title row until „Vorschläge annehmen“ on the source sets `status: 'geprüft'` on the proposals that follow it and came from it, and removes `confidence` and `origin`.
+- **`compose-facts`** – „Stichpunkte erzeugen (KI)“ on a `source` asks `facts` and inserts the `fact` blocks after the source (and after the facts that already follow it).
+- **`compose-example`** – „Als Beispiel übernehmen“ on a `slot` of an instance (one with `derivation.method === 'copy'`) asks `example`; the host appends it to its example library.
+- **`createInstance(invoke, { templateId, instanceId, force? })`** – not a feature: a page calls it to make the instance document of a case; it answers `{ chosen, dropped, unresolved }`.
+
+Failures of `invoke` (a rejected promise) show the error's message (`data.message`, `data.statusMessage` or `message`) in a notice; nothing is inserted.
+
+## Things to know
+
+- The operations read the **stored** document (`documentId` plus a block id). An edit the debounced save has not reached yet is not seen by `split`, `facts` and `example`.
+- `confidence` and `origin` of an example are declared `hidden` properties: the properties form has no read-only field, so the title-row chip shows them while `status` is `vorschlag`.
+- The slot's AI brief has no `contentTemplate`: the editor leaves an unfilled `{skelett}` literally in the prompt. The `skelett` of a slot is sent by `compose-material` as the first „Block füllen (KI)“ data entry instead, only when it is set.
+- `source` lists the `container` capability without `accepts`: facts and examples are siblings of the source, not nested in it.
+- `split` and `facts` read a source's body as Markdown: `heading` nodes and bold one-line paragraphs (how imports mark section headings) become `#` lines, so the structural splitter sees the sections; lists become list lines.
+- A unit `split` cannot assign still becomes an `example` proposal (empty `slot`): nothing of the corpus is lost, the person assigns it in the inspector. A unit a rule or classifier decided is never sent to the language model (`stage: 'label'` batches hold only undecided units).
+- `contextOf` must answer for every document an operation names: the document with the source (`split`, `facts`), the instance (`material`, `example`, `instance`) and the document open in the chat. `null` is a 404.
+
+## Peers
+
+`@skaile/forge-editor` `^6.2.0` (6.2 adds `ToolContext.documentId`, which the chat tools read), `@tiptap/core`, `@tiptap/pm`, `vue` `^3.5`; dependencies `@skaile/forge-compose` and `zod`. Optional: `ai` `^7.0.124` (only `./server/ai-sdk` imports it), `@skaile/forge-app-actions` `^0.4.1` (only `./server/actions` imports it).

package/dist/block-types.d.ts

@@ -0,0 +1,25 @@
+import { KIND } from "@skaile/forge-compose/documents";
+import { BlockType } from "@skaile/forge-editor/composites";
+import { PropertyDefinition } from "@skaile/forge-editor/core";
+//#region src/block-types.d.ts
+export type ComposeKind = typeof KIND.slot | typeof KIND.source | typeof KIND.fact | typeof KIND.example;
+export interface ComposeBlockTypeOptions {
+  /** The slot identifiers a fact or example can target: `value` = identifier, `label` = what the person sees. Without options `slot` is a text field. */
+  slotOptions?: {
+    value: string;
+    label: string;
+  }[];
+  /** Display names of the four types; defaults are German. */
+  labels?: Partial<Record<'slot' | 'source' | 'fact' | 'example', string>>;
+}
+/** The four compose Block types. */
+export declare function composeBlockTypes(o?: ComposeBlockTypeOptions): BlockType[];
+/** `blockType` with the `ai-brief` capability's purpose (and, when given, instructions) replaced; the other brief settings stay. Pure. */
+export declare function withAiBrief(blockType: BlockType, brief: {
+  purpose: string;
+  instructions?: string;
+}): BlockType;
+/** `blockType` with `definitions` added to its `properties` capability; a definition whose key exists replaces it in place. Pure. */
+export declare function withProperties(blockType: BlockType, definitions: readonly PropertyDefinition[]): BlockType;
+//#endregion
+//# sourceMappingURL=block-types.d.ts.map

package/dist/block-types.js

@@ -0,0 +1,231 @@
+import { KIND } from "@skaile/forge-compose/documents";
+//#region src/block-types.ts
+/** `ja`/`nein` as a select: the library has no boolean field; unset means the per-field default (`optional` nein, `heading` ja). */
+const JA_NEIN = [{
+	value: "ja",
+	label: "Ja"
+}, {
+	value: "nein",
+	label: "Nein"
+}];
+const BASKET = { id: "basket" };
+const TITLE_HIDDEN = { id: "titleHidden" };
+const DERIVATION = {
+	key: "derivation",
+	label: "Herkunft",
+	type: "derivation"
+};
+/**
+* The slot type's AI brief. It has no `contentTemplate`: the editor leaves a `{key}` placeholder of the template literally in
+* the prompt when the property is empty, so a template of `{skelett}` would reach the model as the text „{skelett}“ for every
+* slot without a skeleton. The skeleton travels as an `aiBlockData` entry instead (`compose-material`), only when it is set.
+*/
+const SLOT_AI = {
+	purpose: "Ein Abschnitt eines Dokuments: sachlicher Fließtext, der nur aus den genannten Fakten entsteht; Beispiele sind Stilvorlage.",
+	instructions: "Schreibe sachlichen Fließtext nur aus den genannten Fakten. Beispiele sind Stilvorlage für Aufbau und Ton; erfinde nichts hinzu.",
+	instructionsField: "anweisung"
+};
+/** The four compose Block types. */
+function composeBlockTypes(o = {}) {
+	const label = {
+		slot: "Abschnitt",
+		source: "Quelle",
+		fact: "Fakt",
+		example: "Beispiel",
+		...o.labels
+	};
+	const options = (o.slotOptions ?? []).filter((option) => option.value !== "");
+	const slotTarget = options.length > 0 ? {
+		key: "slot",
+		label: "Slot (Bezeichner im Template)",
+		type: "select",
+		options
+	} : {
+		key: "slot",
+		label: "Slot (Bezeichner im Template)",
+		type: "text"
+	};
+	return [
+		{
+			id: KIND.slot,
+			label: label.slot,
+			icon: "i-lucide-file-text",
+			titlePlaceholder: label.slot,
+			descriptionPlaceholder: "Beschreibung: Zuordnung, Stichpunkte, Zweck der Prosa",
+			capabilities: [
+				BASKET,
+				TITLE_HIDDEN,
+				{
+					id: "properties",
+					config: { definitions: [
+						{
+							key: "identifier",
+							label: "Bezeichner (z. B. therapie/pflege)",
+							type: "text"
+						},
+						{
+							key: "optional",
+							label: "Optional (Slot darf in der Instanz entfallen)",
+							type: "select",
+							options: JA_NEIN
+						},
+						{
+							key: "heading",
+							label: "Überschrift im Dokument",
+							type: "select",
+							options: JA_NEIN
+						},
+						{
+							key: "anweisung",
+							label: "KI-Anweisung (ersetzt die Vorgabe)",
+							type: "textarea"
+						},
+						{
+							key: "skelett",
+							label: "Skelett (Zieltext als Markdown, {{…}} = freie Stellen)",
+							type: "textarea"
+						},
+						{
+							key: "selector",
+							label: "Auswahl (#muss ~bevorzugt -nicht)",
+							type: "text"
+						}
+					] }
+				},
+				{
+					id: "ai-brief",
+					config: { ...SLOT_AI }
+				}
+			]
+		},
+		{
+			id: KIND.source,
+			label: label.source,
+			icon: "i-lucide-file-search",
+			titlePlaceholder: "Titel der Quelle",
+			descriptionPlaceholder: "",
+			capabilities: [
+				{
+					id: "container",
+					config: {}
+				},
+				BASKET,
+				TITLE_HIDDEN,
+				{
+					id: "properties",
+					config: { definitions: [{
+						key: "sourceType",
+						label: "Quelltyp",
+						type: "text"
+					}, {
+						key: "date",
+						label: "Datum",
+						type: "text"
+					}] }
+				}
+			],
+			chrome: { tags: false }
+		},
+		{
+			id: KIND.fact,
+			label: label.fact,
+			icon: "i-lucide-lightbulb",
+			titlePlaceholder: "",
+			descriptionPlaceholder: "",
+			capabilities: [
+				BASKET,
+				TITLE_HIDDEN,
+				{
+					id: "properties",
+					config: { definitions: [slotTarget, DERIVATION] }
+				}
+			],
+			chrome: { tags: false }
+		},
+		{
+			id: KIND.example,
+			label: label.example,
+			icon: "i-lucide-quote",
+			titlePlaceholder: label.example,
+			descriptionPlaceholder: "",
+			capabilities: [
+				BASKET,
+				TITLE_HIDDEN,
+				{
+					id: "properties",
+					config: { definitions: [
+						slotTarget,
+						{
+							key: "status",
+							label: "Status",
+							type: "select",
+							options: [{
+								value: "vorschlag",
+								label: "Vorschlag"
+							}, {
+								value: "geprüft",
+								label: "Geprüft"
+							}]
+						},
+						{
+							key: "confidence",
+							label: "Sicherheit",
+							type: "text",
+							hidden: true
+						},
+						{
+							key: "origin",
+							label: "Herkunft der Zuordnung",
+							type: "text",
+							hidden: true
+						},
+						DERIVATION
+					] }
+				}
+			]
+		}
+	];
+}
+/** `blockType` with the `ai-brief` capability's purpose (and, when given, instructions) replaced; the other brief settings stay. Pure. */
+function withAiBrief(blockType, brief) {
+	const config = (existing) => ({
+		...existing && typeof existing === "object" ? existing : {},
+		purpose: brief.purpose,
+		...brief.instructions !== void 0 && { instructions: brief.instructions }
+	});
+	const listed = blockType.capabilities.some((capability) => capability.id === "ai-brief");
+	return {
+		...blockType,
+		capabilities: listed ? blockType.capabilities.map((capability) => capability.id === "ai-brief" ? {
+			...capability,
+			config: config(capability.config)
+		} : capability) : [...blockType.capabilities, {
+			id: "ai-brief",
+			config: config(void 0)
+		}]
+	};
+}
+/** `blockType` with `definitions` added to its `properties` capability; a definition whose key exists replaces it in place. Pure. */
+function withProperties(blockType, definitions) {
+	const merge = (existing) => {
+		const current = existing?.definitions ?? [];
+		const replaced = current.map((definition) => definitions.find((added) => added.key === definition.key) ?? definition);
+		const added = definitions.filter((definition) => !current.some((known) => known.key === definition.key));
+		return { definitions: [...replaced, ...added] };
+	};
+	const listed = blockType.capabilities.some((capability) => capability.id === "properties");
+	return {
+		...blockType,
+		capabilities: listed ? blockType.capabilities.map((capability) => capability.id === "properties" ? {
+			...capability,
+			config: merge(capability.config)
+		} : capability) : [...blockType.capabilities, {
+			id: "properties",
+			config: merge(void 0)
+		}]
+	};
+}
+//#endregion
+export { composeBlockTypes, withAiBrief, withProperties };
+
+//# sourceMappingURL=block-types.js.map

package/dist/block-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-types.js","names":[],"sources":["../src/block-types.ts"],"sourcesContent":["// Block types of the compose documents. Pure data (type-only imports besides `KIND`), so seeds, tests and server code use the\n// same ids and properties as the editor. `section` is forge-editor's built-in container type and is not defined here.\n//\n//   slot     one text block of a template (and of an instance made from it); `identifier` is what facts and examples target\n//   source   a text the facts and examples come from (a letter, a chapter, a case file)\n//   fact     one short statement of a source, assigned to a slot\n//   example  one reusable text for a slot, tagged by case (`alter/*`, `icd/*`, …); a proposal until a person accepts it\nimport type { BlockType } from '@skaile/forge-editor/composites'\nimport type { PropertyDefinition } from '@skaile/forge-editor/core'\nimport { KIND } from '@skaile/forge-compose/documents'\n\nexport type ComposeKind = typeof KIND.slot | typeof KIND.source | typeof KIND.fact | typeof KIND.example\n\nexport interface ComposeBlockTypeOptions {\n  /** The slot identifiers a fact or example can target: `value` = identifier, `label` = what the person sees. Without options `slot` is a text field. */\n  slotOptions?: { value: string; label: string }[]\n  /** Display names of the four types; defaults are German. */\n  labels?: Partial<Record<'slot' | 'source' | 'fact' | 'example', string>>\n}\n\n/** `ja`/`nein` as a select: the library has no boolean field; unset means the per-field default (`optional` nein, `heading` ja). */\nconst JA_NEIN = [\n  { value: 'ja', label: 'Ja' },\n  { value: 'nein', label: 'Nein' },\n]\n\nconst BASKET = { id: 'basket' }\nconst TITLE_HIDDEN = { id: 'titleHidden' }\n\nconst DERIVATION: PropertyDefinition = { key: 'derivation', label: 'Herkunft', type: 'derivation' }\n\n/**\n * The slot type's AI brief. It has no `contentTemplate`: the editor leaves a `{key}` placeholder of the template literally in\n * the prompt when the property is empty, so a template of `{skelett}` would reach the model as the text „{skelett}“ for every\n * slot without a skeleton. The skeleton travels as an `aiBlockData` entry instead (`compose-material`), only when it is set.\n */\nconst SLOT_AI = {\n  purpose: 'Ein Abschnitt eines Dokuments: sachlicher Fließtext, der nur aus den genannten Fakten entsteht; Beispiele sind Stilvorlage.',\n  instructions: 'Schreibe sachlichen Fließtext nur aus den genannten Fakten. Beispiele sind Stilvorlage für Aufbau und Ton; erfinde nichts hinzu.',\n  instructionsField: 'anweisung',\n}\n\n/** The four compose Block types. */\nexport function composeBlockTypes(o: ComposeBlockTypeOptions = {}): BlockType[] {\n  const label = { slot: 'Abschnitt', source: 'Quelle', fact: 'Fakt', example: 'Beispiel', ...o.labels }\n  const options = (o.slotOptions ?? []).filter(option => option.value !== '')\n\n  // A select cannot hold an empty option (the Select component refuses an empty value): the placeholder shows while `slot` is unset.\n  // A `slot` that is no longer in the template stays in the document but is not selectable.\n  const slotTarget: PropertyDefinition = options.length > 0\n    ? { key: 'slot', label: 'Slot (Bezeichner im Template)', type: 'select', options }\n    : { key: 'slot', label: 'Slot (Bezeichner im Template)', type: 'text' }\n\n  return [\n    {\n      id: KIND.slot,\n      label: label.slot,\n      icon: 'i-lucide-file-text',\n      titlePlaceholder: label.slot,\n      descriptionPlaceholder: 'Beschreibung: Zuordnung, Stichpunkte, Zweck der Prosa',\n      capabilities: [\n        BASKET,\n        TITLE_HIDDEN,\n        {\n          id: 'properties',\n          config: {\n            definitions: [\n              { key: 'identifier', label: 'Bezeichner (z. B. therapie/pflege)', type: 'text' },\n              { key: 'optional', label: 'Optional (Slot darf in der Instanz entfallen)', type: 'select', options: JA_NEIN },\n              { key: 'heading', label: 'Überschrift im Dokument', type: 'select', options: JA_NEIN },\n              { key: 'anweisung', label: 'KI-Anweisung (ersetzt die Vorgabe)', type: 'textarea' },\n              { key: 'skelett', label: 'Skelett (Zieltext als Markdown, {{…}} = freie Stellen)', type: 'textarea' },\n              { key: 'selector', label: 'Auswahl (#muss ~bevorzugt -nicht)', type: 'text' },\n            ],\n          },\n        },\n        { id: 'ai-brief', config: { ...SLOT_AI } },\n      ],\n    },\n    {\n      id: KIND.source,\n      label: label.source,\n      icon: 'i-lucide-file-search',\n      titlePlaceholder: 'Titel der Quelle',\n      descriptionPlaceholder: '',\n      capabilities: [\n        { id: 'container', config: {} },\n        BASKET,\n        TITLE_HIDDEN,\n        {\n          id: 'properties',\n          config: {\n            definitions: [\n              { key: 'sourceType', label: 'Quelltyp', type: 'text' },\n              { key: 'date', label: 'Datum', type: 'text' },\n            ],\n          },\n        },\n      ],\n      chrome: { tags: false },\n    },\n    {\n      id: KIND.fact,\n      label: label.fact,\n      icon: 'i-lucide-lightbulb',\n      titlePlaceholder: '',\n      descriptionPlaceholder: '',\n      capabilities: [BASKET, TITLE_HIDDEN, { id: 'properties', config: { definitions: [slotTarget, DERIVATION] } }],\n      chrome: { tags: false },\n    },\n    {\n      id: KIND.example,\n      label: label.example,\n      icon: 'i-lucide-quote',\n      titlePlaceholder: label.example,\n      descriptionPlaceholder: '',\n      capabilities: [\n        BASKET,\n        TITLE_HIDDEN,\n        {\n          id: 'properties',\n          config: {\n            definitions: [\n              slotTarget,\n              { key: 'status', label: 'Status', type: 'select', options: [\n                { value: 'vorschlag', label: 'Vorschlag' },\n                { value: 'geprüft', label: 'Geprüft' },\n              ] },\n              // Written by the split, shown as the proposal chip of the title row (`composeFeatures`) while `status` is `vorschlag`;\n              // the properties form has no read-only field, so both are hidden from it and removed when the proposal is accepted.\n              { key: 'confidence', label: 'Sicherheit', type: 'text', hidden: true },\n              { key: 'origin', label: 'Herkunft der Zuordnung', type: 'text', hidden: true },\n              DERIVATION,\n            ],\n          },\n        },\n      ],\n    },\n  ]\n}\n\n/** `blockType` with the `ai-brief` capability's purpose (and, when given, instructions) replaced; the other brief settings stay. Pure. */\nexport function withAiBrief(blockType: BlockType, brief: { purpose: string; instructions?: string }): BlockType {\n  const config = (existing: unknown) => ({\n    ...(existing && typeof existing === 'object' ? existing : {}),\n    purpose: brief.purpose,\n    ...(brief.instructions !== undefined && { instructions: brief.instructions }),\n  })\n  const listed = blockType.capabilities.some(capability => capability.id === 'ai-brief')\n  return {\n    ...blockType,\n    capabilities: listed\n      ? blockType.capabilities.map(capability => (capability.id === 'ai-brief' ? { ...capability, config: config(capability.config) } : capability))\n      : [...blockType.capabilities, { id: 'ai-brief', config: config(undefined) }],\n  }\n}\n\n/** `blockType` with `definitions` added to its `properties` capability; a definition whose key exists replaces it in place. Pure. */\nexport function withProperties(blockType: BlockType, definitions: readonly PropertyDefinition[]): BlockType {\n  const merge = (existing: unknown): { definitions: PropertyDefinition[] } => {\n    const current = (existing as { definitions?: readonly PropertyDefinition[] } | undefined)?.definitions ?? []\n    const replaced = current.map(definition => definitions.find(added => added.key === definition.key) ?? definition)\n    const added = definitions.filter(definition => !current.some(known => known.key === definition.key))\n    return { definitions: [...replaced, ...added] }\n  }\n  const listed = blockType.capabilities.some(capability => capability.id === 'properties')\n  return {\n    ...blockType,\n    capabilities: listed\n      ? blockType.capabilities.map(capability => (capability.id === 'properties' ? { ...capability, config: merge(capability.config) } : capability))\n      : [...blockType.capabilities, { id: 'properties', config: merge(undefined) }],\n  }\n}\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { ComposeBlockTypeOptions, ComposeKind, composeBlockTypes, withAiBrief, withProperties } from "./block-types.js";
+import { KIND } from "@skaile/forge-compose/documents";
+export { type ComposeBlockTypeOptions, type ComposeKind, KIND, composeBlockTypes, withAiBrief, withProperties };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { composeBlockTypes, withAiBrief, withProperties } from "./block-types.js";
+import { KIND } from "@skaile/forge-compose/documents";
+export { KIND, composeBlockTypes, withAiBrief, withProperties };

package/dist/server/actions.d.ts

@@ -0,0 +1,45 @@
+import { ComposeOperations } from "./operations.js";
+import { z } from "zod";
+import { DefineServerActionArgs, ServerActionAudience, ServerActionContext, createServerActionDefiner } from "@skaile/forge-app-actions/server";
+//#region src/server/actions.d.ts
+/** The app's action definer, `createServerActionDefiner<P, D>()`. */
+export type ComposeActionDefiner<P, D> = ReturnType<typeof createServerActionDefiner<P, D>>;
+export interface ComposeActionOptions<P, D> {
+  /** The host's authorization, run by each action after its input parsed and before the operation. Throw to deny; an error with a numeric `statusCode` keeps its status. */
+  authorize: NonNullable<DefineServerActionArgs<string, z.ZodType, P, D, unknown>['authorize']>;
+  /** The `user` the operations read ports with, derived from the action's context (usually its `principal`). */
+  userOf(ctx: ServerActionContext<P, D>): object;
+  /** Who is offered the actions. Default `['user']`. */
+  audience?: readonly ServerActionAudience[];
+}
+/**
+ * The five compose operations as server actions `compose.material`, `compose.split`, `compose.facts`, `compose.example` and
+ * `compose.instance`. `define` is the app's `createServerActionDefiner<P, D>()`. A `ComposeError` thrown by an operation carries
+ * `statusCode`, so `invokeAction` answers its status and message.
+ */
+export declare function composeActions<P, D>(define: ComposeActionDefiner<P, D>, ops: ComposeOperations, o: ComposeActionOptions<P, D>): readonly [import("@skaile/forge-app-actions/server").ServerAction<"compose.material", {
+  document: string;
+  slot: string;
+}, import("@skaile/forge-compose/documents").Material>, import("@skaile/forge-app-actions/server").ServerAction<"compose.split", {
+  document: string;
+  block: string;
+}, {
+  nodes: import("@skaile/forge-compose/documents").DocNode[];
+}>, import("@skaile/forge-app-actions/server").ServerAction<"compose.facts", {
+  document: string;
+  block: string;
+}, {
+  nodes: import("@skaile/forge-compose/documents").DocNode[];
+}>, import("@skaile/forge-app-actions/server").ServerAction<"compose.example", {
+  document: string;
+  block: string;
+}, {
+  libraryId: string;
+  blockId: string;
+}>, import("@skaile/forge-app-actions/server").ServerAction<"compose.instance", {
+  templateId: string;
+  instanceId: string;
+  force?: boolean | undefined;
+}, import("@skaile/forge-compose/documents").InstanceReport>];
+//#endregion
+//# sourceMappingURL=actions.d.ts.map

package/dist/server/actions.js

@@ -0,0 +1,62 @@
+import { composeInputs } from "./inputs.js";
+//#region src/server/actions.ts
+/**
+* The five compose operations as server actions `compose.material`, `compose.split`, `compose.facts`, `compose.example` and
+* `compose.instance`. `define` is the app's `createServerActionDefiner<P, D>()`. A `ComposeError` thrown by an operation carries
+* `statusCode`, so `invokeAction` answers its status and message.
+*/
+function composeActions(define, ops, o) {
+	const audience = o.audience ?? ["user"];
+	const { authorize, userOf } = o;
+	return [
+		define({
+			id: "compose.material",
+			description: "Material eines Slots: Fakten und passende Beispiele",
+			input: composeInputs.material,
+			kind: "query",
+			audience,
+			authorize,
+			run: (input, ctx) => ops.material(input, userOf(ctx))
+		}),
+		define({
+			id: "compose.split",
+			description: "Quelle in Beispielvorschläge zerlegen",
+			input: composeInputs.split,
+			kind: "effect",
+			audience,
+			authorize,
+			run: (input, ctx) => ops.split(input, userOf(ctx))
+		}),
+		define({
+			id: "compose.facts",
+			description: "Stichpunkte aus einer Quelle erzeugen",
+			input: composeInputs.facts,
+			kind: "effect",
+			audience,
+			authorize,
+			run: (input, ctx) => ops.facts(input, userOf(ctx))
+		}),
+		define({
+			id: "compose.example",
+			description: "Slot als Beispiel in die Bibliothek übernehmen",
+			input: composeInputs.example,
+			kind: "effect",
+			audience,
+			authorize,
+			run: (input, ctx) => ops.example(input, userOf(ctx))
+		}),
+		define({
+			id: "compose.instance",
+			description: "Instanz aus einer Vorlage anlegen",
+			input: composeInputs.instance,
+			kind: "effect",
+			audience,
+			authorize,
+			run: (input, ctx) => ops.instance(input, userOf(ctx))
+		})
+	];
+}
+//#endregion
+export { composeActions };
+
+//# sourceMappingURL=actions.js.map

package/dist/server/actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.js","names":[],"sources":["../../src/server/actions.ts"],"sourcesContent":["// The forge-app-actions projection of the compose operations, for hosts with an action catalogue. Registers nothing and mounts no\n// route: the host puts the returned actions into its catalogue (`serverActionRegistry.registerAll`) or behind its own route.\nimport type {\n  DefineServerActionArgs,\n  ServerActionAudience,\n  ServerActionContext,\n  createServerActionDefiner,\n} from '@skaile/forge-app-actions/server'\nimport type { z } from 'zod'\nimport { composeInputs } from './inputs'\nimport type { ComposeOperations } from './operations'\n\n/** The app's action definer, `createServerActionDefiner<P, D>()`. */\nexport type ComposeActionDefiner<P, D> = ReturnType<typeof createServerActionDefiner<P, D>>\n\nexport interface ComposeActionOptions<P, D> {\n  /** The host's authorization, run by each action after its input parsed and before the operation. Throw to deny; an error with a numeric `statusCode` keeps its status. */\n  authorize: NonNullable<DefineServerActionArgs<string, z.ZodType, P, D, unknown>['authorize']>\n  /** The `user` the operations read ports with, derived from the action's context (usually its `principal`). */\n  userOf(ctx: ServerActionContext<P, D>): object\n  /** Who is offered the actions. Default `['user']`. */\n  audience?: readonly ServerActionAudience[]\n}\n\n/**\n * The five compose operations as server actions `compose.material`, `compose.split`, `compose.facts`, `compose.example` and\n * `compose.instance`. `define` is the app's `createServerActionDefiner<P, D>()`. A `ComposeError` thrown by an operation carries\n * `statusCode`, so `invokeAction` answers its status and message.\n */\nexport function composeActions<P, D>(\n  define: ComposeActionDefiner<P, D>,\n  ops: ComposeOperations,\n  o: ComposeActionOptions<P, D>,\n) {\n  const audience = o.audience ?? ['user']\n  const { authorize, userOf } = o\n  return [\n    define({\n      id: 'compose.material',\n      description: 'Material eines Slots: Fakten und passende Beispiele',\n      input: composeInputs.material,\n      kind: 'query',\n      audience,\n      authorize,\n      run: (input, ctx) => ops.material(input, userOf(ctx)),\n    }),\n    define({\n      id: 'compose.split',\n      description: 'Quelle in Beispielvorschläge zerlegen',\n      input: composeInputs.split,\n      kind: 'effect',\n      audience,\n      authorize,\n      run: (input, ctx) => ops.split(input, userOf(ctx)),\n    }),\n    define({\n      id: 'compose.facts',\n      description: 'Stichpunkte aus einer Quelle erzeugen',\n      input: composeInputs.facts,\n      kind: 'effect',\n      audience,\n      authorize,\n      run: (input, ctx) => ops.facts(input, userOf(ctx)),\n    }),\n    define({\n      id: 'compose.example',\n      description: 'Slot als Beispiel in die Bibliothek übernehmen',\n      input: composeInputs.example,\n      kind: 'effect',\n      audience,\n      authorize,\n      run: (input, ctx) => ops.example(input, userOf(ctx)),\n    }),\n    define({\n      id: 'compose.instance',\n      description: 'Instanz aus einer Vorlage anlegen',\n      input: composeInputs.instance,\n      kind: 'effect',\n      audience,\n      authorize,\n      run: (input, ctx) => ops.instance(input, userOf(ctx)),\n    }),\n  ] as const\n}\n"],"mappings":";;;;;;;AA6BA,SAAgB,eACd,QACA,KACA,GACA;CACA,MAAM,WAAW,EAAE,YAAY,CAAC,MAAM;CACtC,MAAM,EAAE,WAAW,WAAW;CAC9B,OAAO;EACL,OAAO;GACL,IAAI;GACJ,aAAa;GACb,OAAO,cAAc;GACrB,MAAM;GACN;GACA;GACA,MAAM,OAAO,QAAQ,IAAI,SAAS,OAAO,OAAO,GAAG,CAAC;EACtD,CAAC;EACD,OAAO;GACL,IAAI;GACJ,aAAa;GACb,OAAO,cAAc;GACrB,MAAM;GACN;GACA;GACA,MAAM,OAAO,QAAQ,IAAI,MAAM,OAAO,OAAO,GAAG,CAAC;EACnD,CAAC;EACD,OAAO;GACL,IAAI;GACJ,aAAa;GACb,OAAO,cAAc;GACrB,MAAM;GACN;GACA;GACA,MAAM,OAAO,QAAQ,IAAI,MAAM,OAAO,OAAO,GAAG,CAAC;EACnD,CAAC;EACD,OAAO;GACL,IAAI;GACJ,aAAa;GACb,OAAO,cAAc;GACrB,MAAM;GACN;GACA;GACA,MAAM,OAAO,QAAQ,IAAI,QAAQ,OAAO,OAAO,GAAG,CAAC;EACrD,CAAC;EACD,OAAO;GACL,IAAI;GACJ,aAAa;GACb,OAAO,cAAc;GACrB,MAAM;GACN;GACA;GACA,MAAM,OAAO,QAAQ,IAAI,SAAS,OAAO,OAAO,GAAG,CAAC;EACtD,CAAC;CACH;AACF"}

package/dist/server/ai-sdk.d.ts

@@ -0,0 +1,26 @@
+import { Generate } from "@skaile/forge-compose";
+import { ModelProvider } from "@skaile/forge-editor/server";
+import { ModelRef } from "@skaile/forge-editor/ai/protocol";
+//#region src/server/ai-sdk.d.ts
+/** One model call as `onRun` reports it, for the host's run log. */
+export interface ComposeRun {
+  stage: string;
+  /** The model id, as the language model names itself. */
+  model: string;
+  /** First 16 hex characters of the SHA-256 of `system + prompt`; identifies the prompt without storing it. */
+  promptHash: string;
+  ok: boolean;
+  ms: number;
+  error?: string;
+}
+export interface AiSdkGenerateOptions {
+  models: ModelProvider;
+  ref: ModelRef;
+  /** What the host's `authenticate` returned; `null` for a call without a user. */
+  user: object | null;
+  /** Called once per model call, after it succeeded or failed (a failure is rethrown afterwards). */
+  onRun?(run: ComposeRun): void;
+}
+export declare function aiSdkGenerate(o: AiSdkGenerateOptions): Generate;
+//#endregion
+//# sourceMappingURL=ai-sdk.d.ts.map

package/dist/server/ai-sdk.js

@@ -0,0 +1,46 @@
+import { ComposeError } from "./errors.js";
+import { Output, generateText } from "ai";
+//#region src/server/ai-sdk.ts
+async function promptHashOf(text) {
+	const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, 16);
+}
+function aiSdkGenerate(o) {
+	return async ({ stage, system, prompt, schema, signal }) => {
+		const model = await o.models.languageModel?.(o.ref, o.user) ?? null;
+		if (!model) throw new ComposeError(503, "Kein Modell");
+		const started = Date.now();
+		const run = async (ok, error) => {
+			if (!o.onRun) return;
+			o.onRun({
+				stage,
+				model: typeof model === "string" ? model : model.modelId,
+				promptHash: await promptHashOf((system ?? "") + prompt),
+				ok,
+				ms: Date.now() - started,
+				...error !== void 0 && { error: error instanceof Error ? error.message : String(error) }
+			});
+		};
+		try {
+			const answer = (await generateText({
+				model,
+				abortSignal: signal,
+				...system !== void 0 && { system },
+				output: Output.object({ schema }),
+				messages: [{
+					role: "user",
+					content: prompt
+				}]
+			})).output;
+			await run(true);
+			return answer;
+		} catch (error) {
+			await run(false, error);
+			throw error;
+		}
+	};
+}
+//#endregion
+export { aiSdkGenerate };
+
+//# sourceMappingURL=ai-sdk.js.map