@lostgradient/cinder 0.9.0 → 0.12.0

package/dist/components/chat/builders.d.ts

@@ -1,16 +1,25 @@
 /**
  * Conversation builders for the Chat component.
  *
- * Chat renders a {@link ConversationHistory} snapshot. These are thin aliases
- * over the published `conversationalist` builders so examples, demos, tests, and
- * simple apps construct the same transcript shape Chat consumes.
+ * Chat renders a {@link ConversationHistory} snapshot. These helpers construct
+ * the published Conversationalist shape without importing the package runtime
+ * into Cinder's browser graph.
  */
-import { appendAssistantMessage as appendConversationalistAssistantMessage, appendUserMessage as appendConversationalistUserMessage, createConversationHistory } from 'conversationalist';
-import type { ConversationHistory, MessageInput } from './conversation-model.ts';
+import type { ConversationEnvironment, ConversationHistory, ConversationStatus, JSONValue, MessageInput } from './conversation-model.ts';
+type CreateConversationOptions = {
+    id?: string;
+    title?: string;
+    status?: ConversationStatus;
+    metadata?: Record<string, JSONValue>;
+};
+type ConversationEnvironmentInput = Partial<ConversationEnvironment>;
 /** Creates a new empty conversation snapshot. */
-declare const createConversation: typeof createConversationHistory;
+declare function createConversation(options?: CreateConversationOptions, environment?: ConversationEnvironmentInput): ConversationHistory;
 /** Appends one or more messages, preserving the previous no-op identity contract. */
 declare function appendMessages(conversation: ConversationHistory, ...inputs: MessageInput[]): ConversationHistory;
-declare const appendUserMessage: typeof appendConversationalistUserMessage;
-declare const appendAssistantMessage: typeof appendConversationalistAssistantMessage;
+declare function appendMessages(conversation: ConversationHistory, ...inputsAndEnvironment: [...MessageInput[], ConversationEnvironmentInput | undefined]): ConversationHistory;
+declare function appendUserMessage(conversation: ConversationHistory, content: MessageInput['content'], metadata?: Record<string, JSONValue>, environment?: ConversationEnvironmentInput): ConversationHistory;
+declare function appendUserMessage(conversation: ConversationHistory, content: MessageInput['content'], environment?: ConversationEnvironmentInput): ConversationHistory;
+declare function appendAssistantMessage(conversation: ConversationHistory, content: MessageInput['content'], metadata?: Record<string, JSONValue>, environment?: ConversationEnvironmentInput): ConversationHistory;
+declare function appendAssistantMessage(conversation: ConversationHistory, content: MessageInput['content'], environment?: ConversationEnvironmentInput): ConversationHistory;
 export { appendAssistantMessage, appendMessages, appendUserMessage, createConversation };

package/dist/components/chat/conversation-model.d.ts

@@ -8,7 +8,7 @@
  * @module
  */
 import type { ToMarkdownOptions as ConversationalistToMarkdownOptions } from 'conversationalist/markdown';
-export type { AssistantMessage, ContainerUploadContent, ConversationHistory, ConversationStatus, ImageContent, JSONValue, Message, MessageInput, MessageRole, MultiModalContent, RedactedThinkingContent, ServerToolResultContent, ServerToolResultType, ServerToolUseContent, TextContent, ThinkingContent, TokenUsage, ToolAction, ToolCall, ToolError, ToolErrorCategory, ToolResult, WebSearchToolResultContent, } from 'conversationalist';
+export type { AssistantMessage, ContainerUploadContent, ConversationEnvironment, ConversationHistory, ConversationStatus, ImageContent, JSONValue, Message, MessageInput, MessageRole, MultiModalContent, RedactedThinkingContent, ServerToolResultContent, ServerToolResultType, ServerToolUseContent, TextContent, ThinkingContent, TokenUsage, ToolAction, ToolCall, ToolError, ToolErrorCategory, ToolResult, WebSearchToolResultContent, } from 'conversationalist';
 export type { ToolCallPair } from 'conversationalist/utilities';
 /** Base options shared by all transcript export operations. */
 export type ExportOptions = Omit<ConversationalistToMarkdownOptions, 'includeMetadata'>;

package/dist/components/chat/index.d.ts

@@ -12,7 +12,7 @@ export type { ChatAnnounceLevel, ChatCapabilities, ChatProps, ReadReceipt, Typin
 export { Chat };
 export type { ChatAdapter, ChatAdapterErrorEvent, ChatCommand, ChatPushHandlers, ChatReadReceiptEvent, } from './adapter';
 export { appendAssistantMessage, appendMessages, appendUserMessage, createConversation, } from './builders.ts';
-export type { AssistantMessage, ContainerUploadContent, ConversationHistory, ConversationStatus, ExportOptions, ImageContent, JSONValue, Message, MessageInput, MessageRole, MultiModalContent, RedactedThinkingContent, ServerToolResultContent, ServerToolResultType, ServerToolUseContent, TextContent, ThinkingContent, ToMarkdownOptions, TokenUsage, ToolAction, ToolCall, ToolCallPair, ToolError, ToolErrorCategory, ToolResult, WebSearchToolResultContent, } from './conversation-model.ts';
+export type { AssistantMessage, ContainerUploadContent, ConversationEnvironment, ConversationHistory, ConversationStatus, ExportOptions, ImageContent, JSONValue, Message, MessageInput, MessageRole, MultiModalContent, RedactedThinkingContent, ServerToolResultContent, ServerToolResultType, ServerToolUseContent, TextContent, ThinkingContent, ToMarkdownOptions, TokenUsage, ToolAction, ToolCall, ToolCallPair, ToolError, ToolErrorCategory, ToolResult, WebSearchToolResultContent, } from './conversation-model.ts';
 export { formatMessageAsMarkdown, getMessageRoleLabel, getMessageText, messagesToMarkdown, type ChatExportOptions, type DeliveryStatus, } from './utilities';
 export { ChatAttachmentPreview, ChatInput, deriveAttachmentKind, serializeChatAttachment, serializeChatAttachments, } from './input';
 export type { AttachmentKind, ChatAttachment, SerializedChatAttachment } from './input';

package/dist/components/chat/index.js

@@ -2489,13 +2489,26 @@ import * as $65 from "svelte/internal/client";
 import { tick as tick2, untrack as untrack3 } from "svelte";
 
 // src/components/chat/utilities/conversation.ts
-import { getMessages } from "conversationalist";
-import { pairToolCallsWithResults as pairConversationalistToolCallsWithResults } from "conversationalist/utilities";
-function hasPairableToolField(message) {
-  return message.role === "tool-call" && message.toolCall !== undefined || message.role === "tool-result" && message.toolResult !== undefined;
+function getMessages(conversation, options = {}) {
+  return conversation.ids.map((id) => conversation.messages[id]).filter((message) => message !== undefined).filter((message) => options.includeHidden === true || !message.hidden);
 }
 function pairToolCallsWithResults(messages) {
-  return pairConversationalistToolCallsWithResults(messages.filter(hasPairableToolField));
+  const resultsByCallId = new Map;
+  for (const message of messages) {
+    if (message.role === "tool-result" && message.toolResult !== undefined) {
+      resultsByCallId.set(message.toolResult.callId, message.toolResult);
+    }
+  }
+  const pairs = [];
+  for (const message of messages) {
+    if (message.role === "tool-call" && message.toolCall !== undefined) {
+      pairs.push({
+        call: message.toolCall,
+        result: resultsByCallId.get(message.toolCall.id)
+      });
+    }
+  }
+  return pairs;
 }
 // src/components/chat/utilities/utilities.ts
 var CINDER_REASONING_METADATA_KEY = "cinder:reasoning";
@@ -9521,20 +9534,290 @@ function Chat2($$anchor, $$props) {
 }
 
 // src/components/chat/builders.ts
-import {
-  appendAssistantMessage as appendConversationalistAssistantMessage,
-  appendMessages as appendConversationalistMessages,
-  appendUserMessage as appendConversationalistUserMessage,
-  createConversationHistory
-} from "conversationalist";
-var createConversation = createConversationHistory;
-function appendMessages(conversation, ...inputs) {
+var MESSAGE_ROLES = new Set([
+  "user",
+  "assistant",
+  "system",
+  "developer",
+  "tool-call",
+  "tool-result",
+  "snapshot"
+]);
+var CONVERSATION_STATUSES = new Set(["active", "archived", "deleted"]);
+function createId() {
+  return globalThis.crypto?.randomUUID?.() ?? `message-${Date.now()}-${Math.random()}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isJsonObject(value) {
+  if (!isRecord(value) || Array.isArray(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isJsonValue(value) {
+  if (value === null)
+    return true;
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return true;
+    case "number":
+      return Number.isFinite(value);
+    case "object":
+      if (Array.isArray(value))
+        return value.every(isJsonValue);
+      return isJsonObject(value) && Object.values(value).every(isJsonValue);
+    default:
+      return false;
+  }
+}
+function assertJsonObject(value, label) {
+  if (!isJsonObject(value) || !Object.values(value).every(isJsonValue)) {
+    throw new Error(`${label} must be a JSON-compatible object`);
+  }
+}
+function isConversationEnvironmentParameter(value) {
+  if (!isRecord(value) || "role" in value)
+    return false;
+  return typeof value["now"] === "function" || typeof value["randomId"] === "function" || typeof value["estimateTokens"] === "function" || Array.isArray(value["plugins"]) && value["plugins"].every((plugin) => typeof plugin === "function");
+}
+function isRoleHelperEnvironmentParameter(value) {
+  if (!isRecord(value) || "role" in value)
+    return false;
+  return typeof value["now"] === "function" || typeof value["randomId"] === "function" || typeof value["estimateTokens"] === "function" || Array.isArray(value["plugins"]) && value["plugins"].length > 0 && value["plugins"].every((plugin) => typeof plugin === "function");
+}
+function isMultiModalContentPart(value) {
+  if (!isJsonObject(value) || typeof value["type"] !== "string")
+    return false;
+  if (!Object.values(value).every(isJsonValue))
+    return false;
+  switch (value["type"]) {
+    case "text":
+      return typeof value["text"] === "string";
+    case "image":
+      return typeof value["url"] === "string";
+    case "thinking":
+      return typeof value["thinking"] === "string";
+    case "redacted_thinking":
+      return typeof value["data"] === "string";
+    case "server_tool_use":
+      return typeof value["id"] === "string" && typeof value["name"] === "string";
+    case "web_search_tool_result":
+      return typeof value["tool_use_id"] === "string" && "content" in value;
+    case "container_upload":
+      return typeof value["file_id"] === "string";
+    default:
+      return false;
+  }
+}
+function isMessageContentInput(value) {
+  return typeof value === "string" || Array.isArray(value) && value.every(isMultiModalContentPart) || isMultiModalContentPart(value);
+}
+function isLooseMessageInput(value) {
+  return isRecord(value) && typeof value["role"] === "string" && MESSAGE_ROLES.has(value["role"]) && isMessageContentInput(value["content"]) && (value["hidden"] === undefined || typeof value["hidden"] === "boolean") && (value["goalCompleted"] === undefined || typeof value["goalCompleted"] === "boolean");
+}
+function isMetadataRecord(value) {
+  return isJsonObject(value);
+}
+function resolveEnvironment(environment) {
+  const plugins = environment?.plugins ?? [];
+  if (!Array.isArray(plugins) || plugins.some((plugin) => typeof plugin !== "function")) {
+    throw new Error("conversation environment plugins must be functions");
+  }
+  return {
+    now: environment?.now ?? (() => new Date().toISOString()),
+    randomId: environment?.randomId ?? createId,
+    plugins: [...plugins]
+  };
+}
+function cloneStructuredValue(value) {
+  return structuredClone(value);
+}
+function cloneMetadata(metadata) {
+  if (metadata === undefined)
+    return {};
+  assertJsonObject(metadata, "metadata");
+  return cloneStructuredValue(metadata);
+}
+function normalizeContent(content) {
+  if (typeof content === "string")
+    return content;
+  return Array.isArray(content) ? cloneStructuredValue(content) : [cloneStructuredValue(content)];
+}
+function cloneTokenUsage(tokenUsage) {
+  assertJsonObject(tokenUsage, "tokenUsage");
+  const values = Object.values(tokenUsage);
+  if (values.some((value) => typeof value !== "number")) {
+    throw new Error("tokenUsage values must be numbers");
+  }
+  if (values.some((value) => typeof value === "number" && (!Number.isInteger(value) || value < 0))) {
+    throw new Error("tokenUsage values must be non-negative integers");
+  }
+  return cloneStructuredValue(tokenUsage);
+}
+function cloneToolCall(toolCall) {
+  assertJsonObject(toolCall, "toolCall");
+  if (typeof toolCall.id !== "string" || typeof toolCall.name !== "string" || !("arguments" in toolCall) || !isJsonValue(toolCall.arguments)) {
+    throw new Error("toolCall must include string id, string name, and JSON arguments");
+  }
+  return cloneStructuredValue(toolCall);
+}
+function cloneToolResult(toolResult) {
+  assertJsonObject(toolResult, "toolResult");
+  if (typeof toolResult.callId !== "string" || !["success", "error", "action_required"].includes(String(toolResult.outcome)) || !("content" in toolResult) || !isJsonValue(toolResult.content)) {
+    throw new Error("toolResult must include string callId, valid outcome, and JSON content");
+  }
+  return cloneStructuredValue(toolResult);
+}
+function getOrderedMessages(conversation) {
+  return conversation.ids.map((id) => conversation.messages[id]).filter((message) => message !== undefined);
+}
+function buildToolCallIds(messages) {
+  const toolCallIds = new Set;
+  for (const message of messages) {
+    if (message.role === "tool-call" && message.toolCall !== undefined) {
+      if (toolCallIds.has(message.toolCall.id)) {
+        throw new Error(`duplicate toolCall.id in conversation: ${message.toolCall.id}`);
+      }
+      toolCallIds.add(message.toolCall.id);
+    }
+  }
+  return toolCallIds;
+}
+function assertValidToolMessage(input, toolCallIds) {
+  if (input.role === "tool-result" && input.toolResult !== undefined) {
+    if (!toolCallIds.has(input.toolResult.callId)) {
+      throw new Error(`tool result references non-existent tool-call: ${input.toolResult.callId}`);
+    }
+  }
+  if (input.role === "tool-call" && input.toolCall !== undefined) {
+    if (toolCallIds.has(input.toolCall.id)) {
+      throw new Error(`duplicate toolCall.id in conversation: ${input.toolCall.id}`);
+    }
+    toolCallIds.add(input.toolCall.id);
+  }
+}
+function createConversation(options = {}, environment) {
+  const resolvedEnvironment = resolveEnvironment(environment);
+  const createdAt = resolvedEnvironment.now();
+  const conversationId = options.id ?? resolvedEnvironment.randomId();
+  if (typeof conversationId !== "string") {
+    throw new Error("conversation id must be a string");
+  }
+  if (typeof createdAt !== "string") {
+    throw new Error("conversation timestamp must be a string");
+  }
+  if (options.title !== undefined && typeof options.title !== "string") {
+    throw new Error("conversation title must be a string");
+  }
+  if (options.status !== undefined && !CONVERSATION_STATUSES.has(options.status)) {
+    throw new Error("conversation status must be active, archived, or deleted");
+  }
+  return {
+    schemaVersion: 4,
+    id: conversationId,
+    ...options.title !== undefined ? { title: options.title } : {},
+    status: options.status ?? "active",
+    metadata: cloneMetadata(options.metadata),
+    ids: [],
+    messages: {},
+    createdAt,
+    updatedAt: createdAt
+  };
+}
+function materializeMessage(input, position, createdAt, id) {
+  return {
+    id,
+    role: input.role,
+    content: normalizeContent(input.content),
+    position,
+    createdAt,
+    metadata: cloneMetadata(input.metadata),
+    hidden: input.hidden ?? false,
+    ...input.toolCall !== undefined ? { toolCall: cloneToolCall(input.toolCall) } : {},
+    ...input.toolResult !== undefined ? { toolResult: cloneToolResult(input.toolResult) } : {},
+    ...input.tokenUsage !== undefined ? { tokenUsage: cloneTokenUsage(input.tokenUsage) } : {},
+    ...input.role === "assistant" && input.goalCompleted !== undefined ? { goalCompleted: input.goalCompleted } : {}
+  };
+}
+function partitionAppendArguments(args) {
+  const filteredArguments = args.at(-1) === undefined ? args.slice(0, -1) : args;
+  if (filteredArguments.some((argument) => argument === undefined)) {
+    throw new Error("appendMessages expected MessageInput arguments before the optional environment");
+  }
+  const lastArgument = filteredArguments.at(-1);
+  const inputArguments = isConversationEnvironmentParameter(lastArgument) ? filteredArguments.slice(0, -1) : filteredArguments;
+  const inputs = [];
+  for (const argument of inputArguments) {
+    if (!isLooseMessageInput(argument)) {
+      throw new Error("appendMessages expected MessageInput arguments before the optional environment");
+    }
+    inputs.push(argument);
+  }
+  if (isConversationEnvironmentParameter(lastArgument)) {
+    return { inputs, environment: lastArgument };
+  }
+  return { inputs };
+}
+function appendMessages(conversation, ...args) {
+  const { inputs, environment } = partitionAppendArguments(args);
   if (inputs.length === 0)
     return conversation;
-  return appendConversationalistMessages(conversation, ...inputs);
+  const resolvedEnvironment = resolveEnvironment(environment);
+  const updatedAt = resolvedEnvironment.now();
+  if (typeof updatedAt !== "string") {
+    throw new Error("conversation timestamp must be a string");
+  }
+  const nextIds = [...conversation.ids];
+  const nextMessages = { ...conversation.messages };
+  const toolCallIds = buildToolCallIds(getOrderedMessages(conversation));
+  inputs.forEach((input, index3) => {
+    const normalizedInput = { ...input, content: normalizeContent(input.content) };
+    const processedInput = resolvedEnvironment.plugins.reduce((current, plugin) => plugin(current), normalizedInput);
+    if (!isLooseMessageInput(processedInput)) {
+      throw new Error("conversation plugin returned an invalid MessageInput");
+    }
+    assertValidToolMessage(processedInput, toolCallIds);
+    const messageId = resolvedEnvironment.randomId();
+    if (typeof messageId !== "string") {
+      throw new Error("generated message id must be a string");
+    }
+    if (nextMessages[messageId] !== undefined || nextIds.includes(messageId)) {
+      throw new Error(`duplicate message id in conversation: ${messageId}`);
+    }
+    const message = materializeMessage(processedInput, conversation.ids.length + index3, updatedAt, messageId);
+    nextIds.push(message.id);
+    nextMessages[message.id] = message;
+  });
+  return {
+    ...conversation,
+    ids: nextIds,
+    messages: nextMessages,
+    updatedAt
+  };
+}
+function appendUserMessage(conversation, content, metadataOrEnvironment, environment) {
+  const metadata = resolveRoleHelperMetadata(metadataOrEnvironment, environment);
+  const resolvedEnvironment = environment ?? (isRoleHelperEnvironmentParameter(metadataOrEnvironment) ? metadataOrEnvironment : undefined);
+  return appendMessages(conversation, { role: "user", content, metadata }, resolvedEnvironment);
+}
+function appendAssistantMessage(conversation, content, metadataOrEnvironment, environment) {
+  const metadata = resolveRoleHelperMetadata(metadataOrEnvironment, environment);
+  const resolvedEnvironment = environment ?? (isRoleHelperEnvironmentParameter(metadataOrEnvironment) ? metadataOrEnvironment : undefined);
+  return appendMessages(conversation, { role: "assistant", content, metadata }, resolvedEnvironment);
+}
+function resolveRoleHelperMetadata(metadataOrEnvironment, environment) {
+  if (metadataOrEnvironment === undefined)
+    return;
+  if (environment === undefined && isRoleHelperEnvironmentParameter(metadataOrEnvironment)) {
+    return;
+  }
+  if (isMetadataRecord(metadataOrEnvironment))
+    return metadataOrEnvironment;
+  throw new Error("metadata must be a JSON-compatible object");
 }
-var appendUserMessage = appendConversationalistUserMessage;
-var appendAssistantMessage = appendConversationalistAssistantMessage;
 // src/components/chat/export/conversation-export-actions.svelte
 import"svelte/internal/disclose-version";
 import * as $73 from "svelte/internal/client";
@@ -11019,4 +11302,4 @@ export {
   Artifact_panel as ArtifactPanel
 };
 
-//# debugId=39AB4E5BB8E0D1BE64756E2164756E21
+//# debugId=58C35D46F786E29A64756E2164756E21

package/dist/components/chat/utilities/conversation.d.ts

@@ -1,12 +1,12 @@
 /**
  * Conversation-reading helpers for Chat.
  *
- * These delegate to `conversationalist` so message ordering stays aligned with
- * the published conversation package. Tool pairing keeps Chat's role gate so an
- * incidental tool-shaped field on a non-tool message never renders as a pair.
+ * These helpers operate on the Conversationalist transcript shape while keeping
+ * Cinder's browser runtime free of the full conversation package.
  */
-import { getMessages } from 'conversationalist';
-import type { Message, ToolCallPair } from '../conversation-model.ts';
+import type { ConversationHistory, Message, ToolCallPair } from '../conversation-model.ts';
+export declare function getMessages(conversation: ConversationHistory, options?: {
+    includeHidden?: boolean;
+}): Message[];
 /** Pairs tool calls with role-valid tool results from an already-ordered message array. */
 export declare function pairToolCallsWithResults(messages: ReadonlyArray<Message>): ToolCallPair[];
-export { getMessages };

package/dist/components/chat-conversation-header/index.js

@@ -3666,13 +3666,26 @@ function File_text($$anchor, $$props) {
   }));
 }
 // src/components/chat/utilities/conversation.ts
-import { getMessages } from "conversationalist";
-import { pairToolCallsWithResults as pairConversationalistToolCallsWithResults } from "conversationalist/utilities";
-function hasPairableToolField(message) {
-  return message.role === "tool-call" && message.toolCall !== undefined || message.role === "tool-result" && message.toolResult !== undefined;
+function getMessages(conversation, options = {}) {
+  return conversation.ids.map((id) => conversation.messages[id]).filter((message) => message !== undefined).filter((message) => options.includeHidden === true || !message.hidden);
 }
 function pairToolCallsWithResults(messages) {
-  return pairConversationalistToolCallsWithResults(messages.filter(hasPairableToolField));
+  const resultsByCallId = new Map;
+  for (const message of messages) {
+    if (message.role === "tool-result" && message.toolResult !== undefined) {
+      resultsByCallId.set(message.toolResult.callId, message.toolResult);
+    }
+  }
+  const pairs = [];
+  for (const message of messages) {
+    if (message.role === "tool-call" && message.toolCall !== undefined) {
+      pairs.push({
+        call: message.toolCall,
+        result: resultsByCallId.get(message.toolCall.id)
+      });
+    }
+  }
+  return pairs;
 }
 // src/components/chat/utilities/utilities.ts
 var CINDER_REASONING_METADATA_KEY = "cinder:reasoning";
@@ -4262,4 +4275,4 @@ export {
   Chat_conversation_header as ChatConversationHeader
 };
 
-//# debugId=3FF39ABB234DF4E864756E2164756E21
+//# debugId=B66F016402C32A4164756E2164756E21

package/dist/components/chat-conversation-list/index.js

@@ -64,13 +64,26 @@ function classNames(...parts) {
 }
 
 // src/components/chat/utilities/conversation.ts
-import { getMessages } from "conversationalist";
-import { pairToolCallsWithResults as pairConversationalistToolCallsWithResults } from "conversationalist/utilities";
-function hasPairableToolField(message) {
-  return message.role === "tool-call" && message.toolCall !== undefined || message.role === "tool-result" && message.toolResult !== undefined;
+function getMessages(conversation, options = {}) {
+  return conversation.ids.map((id) => conversation.messages[id]).filter((message) => message !== undefined).filter((message) => options.includeHidden === true || !message.hidden);
 }
 function pairToolCallsWithResults(messages) {
-  return pairConversationalistToolCallsWithResults(messages.filter(hasPairableToolField));
+  const resultsByCallId = new Map;
+  for (const message of messages) {
+    if (message.role === "tool-result" && message.toolResult !== undefined) {
+      resultsByCallId.set(message.toolResult.callId, message.toolResult);
+    }
+  }
+  const pairs = [];
+  for (const message of messages) {
+    if (message.role === "tool-call" && message.toolCall !== undefined) {
+      pairs.push({
+        call: message.toolCall,
+        result: resultsByCallId.get(message.toolCall.id)
+      });
+    }
+  }
+  return pairs;
 }
 // src/components/chat/utilities/utilities.ts
 var CINDER_REASONING_METADATA_KEY = "cinder:reasoning";
@@ -520,4 +533,4 @@ export {
   Chat_conversation_list as ChatConversationList
 };
 
-//# debugId=FA6DE2C72C326CFB64756E2164756E21
+//# debugId=ADE11286DEEAF0C664756E2164756E21

package/dist/components/code-block/code-block.css

@@ -9,12 +9,17 @@
  * ======================================== */
 
   .cinder-code-block {
+    --cinder-code-block-background: var(--_cinder-code-block-code-surface);
+    --cinder-code-block-font-size: var(--cinder-text-sm);
+    --cinder-code-block-height: auto;
+    --cinder-code-block-line-height: var(--cinder-leading-relaxed);
+    --cinder-code-block-padding: var(--cinder-space-4);
     --_cinder-code-block-code-surface: light-dark(
       var(--cinder-surface-raised),
       var(--cinder-surface-inset)
     );
 
-    background: var(--cinder-surface-inset);
+    background: var(--cinder-code-block-background);
     border: 1px solid var(--cinder-border);
     border-radius: var(--cinder-radius-md);
     overflow: hidden;
@@ -44,33 +49,34 @@
    * inner pre elements can stay metrically identical. */
   .cinder-code-block__viewport {
     display: block;
-    overflow-x: auto;
-    background: var(--_cinder-code-block-code-surface);
+    block-size: var(--cinder-code-block-height);
+    overflow: auto;
+    background: var(--cinder-code-block-background);
   }
 
   .cinder-code-block__pre,
   .cinder-code-block :where(pre.shiki) {
     margin: 0;
-    padding: var(--cinder-space-4);
+    padding: var(--cinder-code-block-padding);
     width: max-content;
     min-width: 100%;
     overflow-x: clip;
     font-family: var(--cinder-font-mono);
-    font-size: var(--cinder-text-sm);
-    line-height: var(--cinder-leading-relaxed);
+    font-size: var(--cinder-code-block-font-size);
+    line-height: var(--cinder-code-block-line-height);
     color: var(--cinder-text);
     /* Use near-white in light mode so github-light token colors (e.g. #d73a49
      * keyword red) clear 4.5:1 WCAG AA. In dark mode keep the deep inset so
      * github-dark tokens maintain contrast on a very dark surface. */
-    background: var(--_cinder-code-block-code-surface);
+    background: var(--cinder-code-block-background);
   }
 
   /* Shiki writes inline background styles on its generated <pre>; keep the
    * highlighted state visually and metrically identical to the plain fallback. */
   .cinder-code-block :where(pre.shiki) {
     margin: 0 !important;
-    padding: var(--cinder-space-4) !important;
-    background: var(--_cinder-code-block-code-surface) !important;
+    padding: var(--cinder-code-block-padding) !important;
+    background: var(--cinder-code-block-background) !important;
   }
 
   .cinder-code-block__code,

package/dist/components/code-block/code-block.variables.js

@@ -52,10 +52,16 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/components/code-block/code-block.variables.ts
-var variables = [];
+var variables = [
+  "--cinder-code-block-background",
+  "--cinder-code-block-font-size",
+  "--cinder-code-block-height",
+  "--cinder-code-block-line-height",
+  "--cinder-code-block-padding"
+];
 var code_block_variables_default = variables;
 export {
   code_block_variables_default as default
 };
 
-//# debugId=28C5BF47C17214D064756E2164756E21
+//# debugId=78150DCF4A1748A164756E2164756E21

package/dist/components/confirm-dialog/confirm-dialog.css

@@ -1,4 +1,6 @@
 @layer cinder.tokens, cinder.foundation, cinder.components, cinder.utilities;
+@import '../input/input.css';
+
 @layer cinder.components {
   .cinder-confirm-dialog__description {
     margin: 0;

package/dist/components/confirm-dialog/confirm-dialog.schema.js

@@ -87,6 +87,15 @@ Never use "OK" or "Confirm" in production — they don't describe the action.`
       description: `When true, the confirm button uses variant="danger". The cancel button still
 receives default focus regardless — color is never the sole destructive signal.`
     },
+    typeToConfirm: {
+      type: "string",
+      description: `When set, renders a labelled text input and disables the confirm button until the
+trimmed input matches this value case-insensitively.`
+    },
+    typeToConfirmLabel: {
+      type: "string",
+      description: 'Visible label for the typed-confirmation input. Defaults to `Type "<value>" to confirm`.'
+    },
     class: {
       type: "string",
       description: "Optional extra class on the underlying <Modal>. Destructured as `class: className` per repo convention."
@@ -123,4 +132,4 @@ export {
   confirm_dialog_schema_default as default
 };
 
-//# debugId=A7F3FC6EA5DCEDE864756E2164756E21
+//# debugId=9E452C902BC5550F64756E2164756E21

package/dist/components/confirm-dialog/confirm-dialog.types.d.ts

@@ -36,6 +36,13 @@ export type ConfirmDialogProps = {
      * receives default focus regardless — color is never the sole destructive signal.
      */
     destructive?: boolean;
+    /**
+     * When set, renders a labelled text input and disables the confirm button until the
+     * trimmed input matches this value case-insensitively.
+     */
+    typeToConfirm?: string;
+    /** Visible label for the typed-confirmation input. Defaults to `Type "<value>" to confirm`. */
+    typeToConfirmLabel?: string;
     /** Fired when the user activates the confirm button. Required. Component closes itself after. */
     onconfirm: () => void;
     /**