@ai-matrx/chat 0.4.10 → 0.4.12

package/dist/utils/content-ir/kinds/kind-markdown-utils.d.ts

@@ -1,84 +0,0 @@
-/**
- * Shared plumbing for kind → markdown export facets (`toMarkdown`).
- *
- * The FORWARD leg of the artifact ⇄ markdown two-way layer: every facet
- * turns a kind's ZERO-LOSS value object into clean human-readable markdown
- * (headings / lists / bold — never a JSON dump), following two laws:
- *
- * 1. `__kind` discriminators are transport metadata — never rendered.
- * 2. Nothing silently vanishes: keys a facet doesn't understand (plus the
- *    declared `additionalDetails` bag every top-level kind schema carries)
- *    are appended under a small "Additional details" key: value section via
- *    `collectExtras` + `additionalDetailsSection`.
- *
- * `genericKindMarkdown` is the fallback for kinds WITHOUT a `toMarkdown`
- * facet (and for unregistered kinds): readable markdown built from the value
- * itself — headings, bold-label lists, tables — never a JSON dump.
- */
-export declare function isRecordValue(value: unknown): value is Record<string, unknown>;
-/**
- * One-line rendering of an arbitrary value for key: value lists. Scalars
- * render as text, scalar arrays join with ", ", anything structural falls
- * back to inline JSON in a code span (zero loss, still one line).
- */
-export declare function formatInlineValue(value: unknown): string;
-/**
- * Collect the keys a facet does NOT understand. Skips `__kind`,
- * null/undefined, and the facet's known keys; merges the contents of a
- * declared `additionalDetails` object bag (the schema-blessed extras
- * channel) into the same flat map so both extra channels surface together.
- */
-export declare function collectExtras(value: Record<string, unknown>, knownKeys: Iterable<string>): Record<string, unknown>;
-/**
- * A field's own name, as words — `violations_not_fixed` → "Violations not
- * fixed", `wordCountAfter` → "Word count after".
- *
- * 🚨 WALK 18, DEFECT D. The finished Masterwork deliverable an Expert hands a
- * customer carried `violations_not_fixed: []` — a key out of a schema we
- * declared, printed at a person. A label is the one place a field name is
- * GUARANTEED to reach a reader, so the resolution lives here, beside the
- * extras plumbing, for every RENDERER that puts a structured field on a
- * screen: underscores and camel humps become spaces, the first letter is
- * capitalised, and nothing else changes.
- *
- * Deliberately NOT applied inside {@link extrasList}. That list is the
- * markdown/EXPORT leg (`features/canvas/export/exportArtifactMarkdown.ts`
- * writes a file somebody — or something — reads back), and a key spelled as
- * prose cannot be read back as a key. A screen resolves; a file keeps the key.
- */
-export declare function plainFieldLabel(key: string): string;
-/** Render extras as a key: value bullet list (no heading). Null when empty. */
-export declare function extrasList(extras: Record<string, unknown>): string | null;
-/**
- * The canonical "Additional details" section — appended at the END of a
- * kind's markdown so nothing silently vanishes. Null when there is nothing
- * to say (callers filter with `joinBlocks`).
- */
-export declare function additionalDetailsSection(extras: Record<string, unknown>, headingLevel?: "##" | "###" | "####"): string | null;
-/** Join markdown blocks with blank lines, dropping empty/null ones. */
-export declare function joinBlocks(blocks: Array<string | null | undefined>): string;
-/** "flashcard_set" → "Flashcard Set"; "Artifact" when there is nothing to say. */
-export declare function humanizeKind(kind: string): string;
-/** Renders a nested kind value as markdown (the registry's converter). */
-export type NestedKindMarkdown = (value: Record<string, unknown>) => string;
-/**
- * Fallback markdown for kinds with no `toMarkdown` facet (or unregistered
- * kinds): READABLE markdown built from the value itself (kind-never-raw,
- * Arman 2026-09-30 — a kind is never shown as raw JSON, an export included).
- * Heading = the instance title (`deriveInstanceTitle`), then the kind's
- * name; scalar fields as a bold-label list; arrays of uniform scalar records
- * as a table, other arrays as nested lists; nested plain objects as
- * sections; nested KINDS through `nested` (the registry converter —
- * `kindValueToMarkdown` passes itself; default: this function). Never the
- * `__kind` key, never a JSON fence. Every field still appears (zero loss in
- * content; the discriminator is named in words by the subtitle).
- */
-export declare function genericKindMarkdown(kind: string, value: Record<string, unknown>, nested?: NestedKindMarkdown): string;
-/**
- * Readable markdown for a value that is NOT itself a kind — a kindless JSON
- * wrapper around kinds, or a run of plain values beside kinds in an array —
- * so a destination (export, copy) never prints it as JSON. Same rendering as
- * a kind's body in {@link genericKindMarkdown} (bold-label scalars, tables for
- * uniform records, nested lists, sections), nested kinds through `nested`.
- */
-export declare function plainValueMarkdown(value: unknown, nested?: NestedKindMarkdown): string;

package/dist/utils/content-ir/kinds/kind-markdown-utils.js

@@ -1,233 +0,0 @@
-import { KIND_KEY } from "@ai-matrx/content-ir";
-import {
-  deriveInstanceTitle,
-  INSTANCE_TITLE_KEYS
-} from "../instance-title.js";
-import { humanizeIdentifier } from "@ai-matrx/kit/text-case";
-function isRecordValue(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isScalar(value) {
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-}
-function formatInlineValue(value) {
-  if (value === null || value === void 0) return "\u2014";
-  if (isScalar(value)) return String(value);
-  if (Array.isArray(value) && value.every(isScalar)) {
-    return value.map(String).join(", ");
-  }
-  try {
-    return `\`${JSON.stringify(stripKindForDisplay(value))}\``;
-  } catch {
-    return String(value);
-  }
-}
-function stripKindForDisplay(value) {
-  if (Array.isArray(value)) return value.map(stripKindForDisplay);
-  if (isRecordValue(value)) {
-    const out = {};
-    for (const [key, child] of Object.entries(value)) {
-      if (key === KIND_KEY) continue;
-      out[key] = stripKindForDisplay(child);
-    }
-    return out;
-  }
-  return value;
-}
-function collectExtras(value, knownKeys) {
-  const known = new Set(knownKeys);
-  known.add(KIND_KEY);
-  known.add("additionalDetails");
-  const extras = {};
-  const details = value.additionalDetails;
-  if (isRecordValue(details)) {
-    for (const [key, child] of Object.entries(details)) {
-      if (key === KIND_KEY || child === null || child === void 0) continue;
-      extras[key] = child;
-    }
-  } else if (details !== null && details !== void 0) {
-    extras.additionalDetails = details;
-  }
-  for (const [key, child] of Object.entries(value)) {
-    if (known.has(key) || child === null || child === void 0) continue;
-    extras[key] = child;
-  }
-  return extras;
-}
-function plainFieldLabel(key) {
-  const words = key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim().toLowerCase();
-  if (!words) return key;
-  return words.charAt(0).toUpperCase() + words.slice(1);
-}
-function extrasList(extras) {
-  const entries = Object.entries(extras);
-  if (entries.length === 0) return null;
-  return entries.map(([key, value]) => `- **${key}:** ${formatInlineValue(value)}`).join("\n");
-}
-function additionalDetailsSection(extras, headingLevel = "##") {
-  const list = extrasList(extras);
-  if (!list) return null;
-  return `${headingLevel} Additional details
-
-${list}`;
-}
-function joinBlocks(blocks) {
-  return blocks.map((block) => typeof block === "string" ? block.trim() : "").filter((block) => block.length > 0).join("\n\n");
-}
-function humanizeKind(kind) {
-  return humanizeIdentifier(kind) || "Artifact";
-}
-function isKindValue(value) {
-  return isRecordValue(value) && typeof value[KIND_KEY] === "string" && value[KIND_KEY].trim().length > 0;
-}
-function scalarText(value) {
-  if (typeof value === "boolean") return value ? "Yes" : "No";
-  return String(value);
-}
-function cellText(value) {
-  return scalarText(value).replace(/\r?\n/g, " ").replace(/\|/g, "\\|");
-}
-function visibleEntries(value) {
-  return Object.entries(value).filter(
-    ([key, child]) => key !== KIND_KEY && child !== null && child !== void 0 && !(typeof child === "string" && child.trim() === "") && !(Array.isArray(child) && child.length === 0)
-  );
-}
-function uniformTable(items) {
-  if (items.length === 0) return null;
-  let columns = null;
-  for (const item of items) {
-    if (!isRecordValue(item) || isKindValue(item)) return null;
-    const keys = Object.keys(item).filter((key) => key !== KIND_KEY);
-    if (keys.length === 0) return null;
-    if (!keys.every((key) => item[key] === null || isScalar(item[key]))) return null;
-    if (columns === null) columns = keys;
-    else if (keys.length !== columns.length || !keys.every((k, i) => k === columns[i]))
-      return null;
-  }
-  const cols = columns;
-  const head = `| ${cols.map(plainFieldLabel).join(" | ")} |`;
-  const rule = `| ${cols.map(() => "---").join(" | ")} |`;
-  const rows = items.map(
-    (item) => `| ${cols.map((key) => {
-      const cell = item[key];
-      return cell === null || cell === void 0 ? "\u2014" : cellText(cell);
-    }).join(" | ")} |`
-  );
-  return [head, rule, ...rows].join("\n");
-}
-function indentBlock(text, indent) {
-  return text.split("\n").map((line) => line.trim() ? indent + line : line).join("\n");
-}
-function listLines(value, indent, nested) {
-  if (Array.isArray(value)) {
-    const lines = [];
-    for (const item of value) {
-      if (item === null || item === void 0) continue;
-      if (isScalar(item)) lines.push(`${indent}- ${scalarText(item)}`);
-      else if (isKindValue(item)) {
-        lines.push(`${indent}-`);
-        lines.push(indentBlock(nested(item), indent + "  "));
-      } else if (Array.isArray(item)) {
-        lines.push(`${indent}-`);
-        lines.push(...listLines(item, indent + "  ", nested));
-      } else if (isRecordValue(item)) {
-        const fields = listLines(item, indent + "  ", nested);
-        if (fields.length > 0) {
-          lines.push(`${indent}- ${fields[0].trimStart().replace(/^- /, "")}`);
-          lines.push(...fields.slice(1));
-        }
-      }
-    }
-    return lines;
-  }
-  if (isRecordValue(value)) {
-    if (isKindValue(value)) return [indentBlock(nested(value), indent)];
-    const lines = [];
-    for (const [key, child] of visibleEntries(value)) {
-      const label = `**${plainFieldLabel(key)}:**`;
-      if (isScalar(child)) lines.push(`${indent}- ${label} ${scalarText(child)}`);
-      else if (Array.isArray(child) && child.every(isScalar))
-        lines.push(`${indent}- ${label} ${child.map(scalarText).join(", ")}`);
-      else {
-        lines.push(`${indent}- ${label}`);
-        lines.push(...listLines(child, indent + "  ", nested));
-      }
-    }
-    return lines;
-  }
-  return isScalar(value) ? [`${indent}- ${scalarText(value)}`] : [];
-}
-function headingFor(depth) {
-  return "#".repeat(Math.min(Math.max(depth, 1), 6));
-}
-function recordBody(value, depth, nested, skipKey) {
-  const scalars = [];
-  const sections = [];
-  for (const [key, child] of visibleEntries(value)) {
-    if (key === skipKey) continue;
-    const label = plainFieldLabel(key);
-    if (isScalar(child)) {
-      scalars.push(`- **${label}:** ${scalarText(child)}`);
-    } else if (Array.isArray(child) && child.every(isScalar)) {
-      scalars.push(`- **${label}:** ${child.map(scalarText).join(", ")}`);
-    } else if (isKindValue(child)) {
-      sections.push(joinBlocks([`${headingFor(depth + 1)} ${label}`, nested(child)]));
-    } else if (Array.isArray(child)) {
-      sections.push(
-        joinBlocks([
-          `${headingFor(depth + 1)} ${label}`,
-          uniformTable(child) ?? listLines(child, "", nested).join("\n")
-        ])
-      );
-    } else if (isRecordValue(child)) {
-      sections.push(
-        joinBlocks([
-          `${headingFor(depth + 1)} ${label}`,
-          ...recordBody(child, depth + 1, nested, null)
-        ])
-      );
-    }
-  }
-  return [scalars.length ? scalars.join("\n") : null, ...sections].filter(
-    (block) => block !== null
-  );
-}
-function titleSourceKey(value, title) {
-  if (!title) return null;
-  for (const key of INSTANCE_TITLE_KEYS) {
-    const v = value[key];
-    if (typeof v === "string" && v.trim() === title) return key;
-  }
-  return null;
-}
-function genericKindMarkdown(kind, value, nested) {
-  const renderNested = nested ?? ((child) => genericKindMarkdown(String(child[KIND_KEY] ?? "artifact"), child));
-  const title = deriveInstanceTitle(value);
-  return joinBlocks([
-    `# ${title ?? humanizeKind(kind)}`,
-    `*${humanizeKind(kind)}*`,
-    ...recordBody(value, 1, renderNested, titleSourceKey(value, title))
-  ]);
-}
-function plainValueMarkdown(value, nested) {
-  const renderNested = nested ?? ((child) => genericKindMarkdown(String(child[KIND_KEY] ?? "artifact"), child));
-  if (value === null || value === void 0) return "";
-  if (isKindValue(value)) return renderNested(value);
-  if (Array.isArray(value)) {
-    return uniformTable(value) ?? listLines(value, "", renderNested).join("\n");
-  }
-  if (isRecordValue(value)) return joinBlocks(recordBody(value, 1, renderNested, null));
-  return isScalar(value) ? scalarText(value) : String(value);
-}
-export {
-  additionalDetailsSection,
-  collectExtras,
-  extrasList,
-  formatInlineValue,
-  genericKindMarkdown,
-  humanizeKind,
-  isRecordValue,
-  joinBlocks,
-  plainFieldLabel,
-  plainValueMarkdown
-};

package/dist/utils/content-ir/kinds/kind-value-markdown.d.ts

@@ -1,5 +0,0 @@
-type KindValueToMarkdown = (value: Record<string, unknown>, fallbackKind?: string) => string;
-/** The host's registry-backed converter (matrx-frontend: `features/canvas/export/exportArtifactMarkdown`). */
-export declare function registerKindValueMarkdown(impl: KindValueToMarkdown | null): void;
-export declare function kindValueToMarkdown(value: Record<string, unknown>, fallbackKind?: string): string;
-export {};

package/dist/utils/content-ir/kinds/kind-value-markdown.js

@@ -1,17 +0,0 @@
-import { readObjectKind } from "@ai-matrx/content-ir";
-import { reportUnregisteredHostSlot } from "../../../host/diagnostics.js";
-import { genericKindMarkdown } from "./kind-markdown-utils.js";
-let registered = null;
-function registerKindValueMarkdown(impl) {
-  registered = impl;
-}
-function kindValueToMarkdown(value, fallbackKind = "artifact") {
-  if (registered) return registered(value, fallbackKind);
-  reportUnregisteredHostSlot("kindValueMarkdown", "kind values render through the generic readable form, not the host's kind registry");
-  const nested = (child) => kindValueToMarkdown(child);
-  return genericKindMarkdown(readObjectKind(value) ?? fallbackKind, value, nested);
-}
-export {
-  kindValueToMarkdown,
-  registerKindValueMarkdown
-};

package/dist/utils/content-ir/legacy-quiz-envelope.d.ts

@@ -1,3 +0,0 @@
-import type { CanonicalBlockIR } from "@ai-matrx/content-ir";
-/** Mirror the server's legacy quiz adapter while keeping source aliases in IR residue. */
-export declare function canonicalizeCompletedLegacyQuizEnvelope(envelope: CanonicalBlockIR, sourceText: string): CanonicalBlockIR;

package/dist/utils/content-ir/legacy-quiz-envelope.js

@@ -1,45 +0,0 @@
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function canonicalizeCompletedLegacyQuizEnvelope(envelope, sourceText) {
-  if (envelope.root.kind !== "quiz_set" || envelope.root.status !== "complete") {
-    return envelope;
-  }
-  let source;
-  try {
-    source = JSON.parse(sourceText);
-  } catch {
-    return envelope;
-  }
-  if (!isRecord(source)) return envelope;
-  const hasLegacyAliases = typeof source.quiz_title === "string" || typeof source.quizTitle === "string" || Array.isArray(source.multiple_choice) || Array.isArray(source.multipleChoice);
-  if (source.__kind !== void 0 || !hasLegacyAliases) return envelope;
-  const title = typeof source.quiz_title === "string" ? source.quiz_title : typeof source.quizTitle === "string" ? source.quizTitle : null;
-  const sourceQuestions = source.questions ?? source.multiple_choice ?? source.multipleChoice;
-  if (title === null || !Array.isArray(sourceQuestions)) return envelope;
-  const questions = sourceQuestions.flatMap((candidate) => {
-    if (!isRecord(candidate)) return [];
-    const { __kind: _legacyKind, ...legacyQuestion } = candidate;
-    const options = Array.isArray(candidate.options) ? candidate.options : [];
-    const answer = candidate.correct_answer ?? candidate.correctAnswer ?? "";
-    const correctAnswer = typeof answer === "number" && Number.isInteger(answer) && answer >= 0 && answer < options.length ? options[answer] : answer;
-    return [{
-      ...legacyQuestion,
-      type: typeof candidate.type === "string" ? candidate.type : "multiple_choice",
-      question: typeof candidate.question === "string" ? candidate.question : "",
-      options,
-      correct_answer: typeof correctAnswer === "string" ? correctAnswer : String(correctAnswer),
-      explanation: typeof candidate.explanation === "string" ? candidate.explanation : null
-    }];
-  });
-  return {
-    ...envelope,
-    root: {
-      ...envelope.root,
-      value: { ...envelope.root.value, title, questions }
-    }
-  };
-}
-export {
-  canonicalizeCompletedLegacyQuizEnvelope
-};

package/dist/utils/content-ir/surfaces/embedded-kind-json.d.ts

@@ -1,140 +0,0 @@
-/**
- * Recover complete self-described kind objects from ANY containing text.
- *
- * Markdown, code fences, and XML are arrival containers, not type authority.
- * Once a complete JSON object directly declares a non-empty `__kind`, that
- * object is its own Content IR region even when an outer parser already
- * classified the surrounding bytes as code, XML, or prose.
- *
- * Generic XML opts into literal-context exclusion so tag attributes, code,
- * comments, and CDATA remain examples owned by their container. Otherwise the
- * scanner is syntax-agnostic about the outer container. It only promotes candidates that independently pass JSON.parse and carry a
- * direct string discriminator. Failed/malformed candidates remain untouched.
- */
-export interface EmbeddedKindJsonRegion {
-    start: number;
-    end: number;
-    content: string;
-    kind: string;
-}
-export type EmbeddedKindJsonPiece = {
-    type: "container";
-    content: string;
-} | {
-    type: "kind";
-    content: string;
-    kind: string;
-}
-/**
- * JSON punctuation that only held kinds together — the `[`, `,` and `]` of
- * an array of kinds. Kept so the partition stays lossless; never rendered
- * (a lone `[` drawn as a JSON card is noise, not content — A6).
- */
- | {
-    type: "chrome";
-    content: string;
-}
-/**
- * The non-kind DATA of a JSON wrapper around kinds (`{"result":{…kind…},
- * "note":"x"}`, A7): `content` is the source span it replaces (lossless),
- * `json` is the wrapper's value with every kind removed — valid JSON, drawn
- * as genuine JSON. A wrapper that holds only kinds has no residual piece.
- */
- | {
-    type: "residual";
-    content: string;
-    json: string;
-};
-/**
- * For every `{` / `[` in `text`: the end (exclusive) of the string-aware
- * balanced JSON value opening there, or -1 (never balances). Each opener's
- * reading starts outside a string, exactly as if read alone; one right-to-left
- * pass reuses each nested opener's own answer (its reading from inside an
- * enclosing value is the same reading), so the whole table is linear — a
- * reading per opener was quadratic on thousands of unclosed `{` (round 11, P5).
- */
-export declare function balancedEnds(text: string): Int32Array;
-/** Outermost complete self-described objects, in source order. */
-export { frontMatterEnd } from "./json-kind-signal.js";
-export interface EmbeddedKindSearchOptions {
-    /** Generic XML: code, comments, CDATA and tags are literal (the XML card shows them). */
-    excludeLiteralContexts?: boolean;
-    /**
-     * With `excludeLiteralContexts` (an XML TAG — structure, ruling (b) round 3):
-     * a ```json / ```jsonc / ```json5 / unlabelled fence is NOT literal. A kind
-     * that is its whole body leaves with the fence's own lines as chrome, so
-     * the XML pieces around it hold no orphan fence marker.
-     */
-    liftJsonFences?: boolean;
-    /**
-     * Markdown: inline code spans and non-JSON fences are the model quoting
-     * source (`quotedSourceRanges`, the owner's ruling 2026-09-30) — never lifted.
-     */
-    excludeQuotedSource?: boolean;
-}
-export declare function findEmbeddedKindJsonRegions(source: string, options?: EmbeddedKindSearchOptions): EmbeddedKindJsonRegion[];
-/** Losslessly partition a container around every recovered kind region. */
-export declare function splitAroundEmbeddedKindJson(source: string, options?: EmbeddedKindSearchOptions): EmbeddedKindJsonPiece[];
-/**
- * A recovered PROSE piece, shaped exactly as the live stream shapes the same
- * bytes (A5, 2026-09-30): the stream splits `Here: {"__kind":…} after` into
- * three lines as it arrives, so its prose blocks are trimmed at the end (every
- * text block is) and, after a kind, start where the next character does — the
- * spaces after the object and the one line break that ended its line are the
- * boundary, not content. Both hosts call this on every text piece, so a live
- * message and its reload draw the same blocks.
- */
-export declare function normalizeRecoveredProsePiece(content: string, followsKind: boolean): string;
-/**
- * Every recovered container piece, by its container's block type: prose by
- * the rule above, code byte-verbatim, and a SECTION (`thinking`, `info`, …)
- * trimmed — the live stream splits a kind out of a section as it arrives
- * (A8) and each part is a section body, which is trimmed like a whole one.
- */
-export declare function normalizeRecoveredContainerPiece(content: string, containerType: string, followsKind: boolean): string;
-/**
- * A complete JSON value (object or array) that holds at least one kind, as
- * one region: a recovered kind region widened to the OUTERMOST complete,
- * parseable JSON value that contains it — a kindless wrapper
- * (`{"result":{…kind…},"note":…}`, A7) or an array of kinds and plain values.
- * For DESTINATION transforms (export, copy, speech) that convert the value
- * whole; the renderer partitions the same bytes with
- * {@link splitAroundEmbeddedKindJson}. Built on THE region finder above.
- */
-export interface KindCarryingJsonRegion {
-    start: number;
-    end: number;
-    content: string;
-    value: unknown;
-}
-export declare function findKindCarryingJsonValues(source: string, options?: {
-    excludeLiteralContexts?: boolean;
-}): KindCarryingJsonRegion[];
-/**
- * A kind that can never complete as written: [start, end) and the text of
- * its region. Two shapes, by the same ownership rule as the finder above:
- *  - a CLOSED object whose root declares `__kind` but does not parse (the
- *    finder's malformed owner) — bounded;
- *  - an UNCLOSED JSON object or array at the tail (a stream cut off, a
- *    truncated store) holding a `"__kind"` key anywhere — runs to the end,
- *    from its outermost opener (a kindless wrapper is cut with its kind).
- * For destinations that must say "<Kind> did not finish" instead of printing
- * the fragment. Complete values (kind or not) are skipped whole.
- */
-export interface BrokenKindJsonRegion {
-    start: number;
-    end: number;
-    content: string;
-}
-/**
- * Round 10 (C1): a broken region is bounded by its OWN JSON grammar. An opener
- * owns a kind key only when its grammar reaches the key; it runs to the end of
- * the text only while it is still validly open, else it ends at its cut. A
- * stray `[[`, `{"`, `{{`, `["`, an unrelated earlier object or a pasted
- * schema never extends a region over the prose after it. A balanced span that
- * does not parse is a region only when it reads once trailing commas go.
- * Linear: key positions once, each opener's grammar stops at its break.
- */
-export declare function findBrokenKindJsonRegions(source: string, options?: {
-    excludeLiteralContexts?: boolean;
-}): BrokenKindJsonRegion[];