@artkit-ai/react 0.1.0 → 0.2.0

package/src/hooks.ts

@@ -2,12 +2,10 @@ import {
   type AnyArtifactExporter,
   type Artifact,
   ArtifactError,
-  type ChangeSummary,
   type CommitResult,
   isArtifactError,
   silentLogger,
   slugify,
-  type VersionEntry,
 } from '@artkit-ai/core';
 import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
 import type { CacheEntry } from './cache.js';
@@ -26,16 +24,7 @@ function toArtifactError(error: unknown): ArtifactError {
   });
 }
 
-function newKey(): string {
-  const cryptoApi = (globalThis as { crypto?: { randomUUID?: () => string } }).crypto;
-  return (
-    cryptoApi?.randomUUID?.() ?? `ak-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`
-  );
-}
-
 export interface UseArtifactOptions {
-  /** A specific (immutable) version; omit for the latest. */
-  version?: number;
   /** Already-known artifact (e.g. from a chat message), shown immediately and cached. */
   initial?: Artifact;
   /** Revalidate the latest version on mount (default true). */
@@ -53,12 +42,12 @@ export interface UseArtifactResult {
 /** Loads an artifact through the client with a shared cache (spec §13.2). Pass undefined to skip. */
 export function useArtifact(id: string | undefined, options: UseArtifactOptions = {}): UseArtifactResult {
   const { cache } = useArtkit();
-  const { version, initial, revalidate = true } = options;
+  const { initial, revalidate = true } = options;
   const subscribe = useCallback(
     (listener: () => void) => (id ? cache.subscribe(id, listener) : noop),
     [cache, id],
   );
-  const read = () => (id ? cache.entry(id, version) : NO_ENTRY);
+  const read = () => (id ? cache.entry(id) : NO_ENTRY);
   const entry = useSyncExternalStore(id ? subscribe : noSubscription, read, read);
 
   useEffect(() => {
@@ -67,21 +56,18 @@ export function useArtifact(id: string | undefined, options: UseArtifactOptions
 
   useEffect(() => {
     if (!id) return;
-    cache.load(id, version, version === undefined && revalidate).catch(noop);
-  }, [cache, id, version, revalidate]);
+    cache.load(id, revalidate).catch(noop);
+  }, [cache, id, revalidate]);
 
-  const usableInitial =
-    initial && initial.id === id && (version === undefined || initial.version === version)
-      ? initial
-      : undefined;
+  const usableInitial = initial && initial.id === id ? initial : undefined;
   const artifact =
     entry.artifact && (!usableInitial || entry.artifact.version >= usableInitial.version)
       ? entry.artifact
       : (usableInitial ?? entry.artifact);
   const refresh = useCallback(async () => {
     if (!id) return undefined;
-    return cache.load(id, version, true);
-  }, [cache, id, version]);
+    return cache.load(id, true);
+  }, [cache, id]);
 
   return {
     artifact,
@@ -102,104 +88,15 @@ export function useLatestVersion(id: string | undefined): number | undefined {
   return useSyncExternalStore(subscribe, read, read);
 }
 
-export interface UseArtifactHistoryResult {
-  entries: VersionEntry[];
-  loading: boolean;
-  error: unknown;
-  hasMore: boolean;
-  loadMore(): Promise<void>;
-  refresh(): Promise<void>;
-  /** Creates a new version with the content of `version` (spec §8.5). */
-  restore(version: number, message?: string): Promise<CommitResult>;
-  restoring: number | undefined;
-}
-
-/** Version list with pagination and restore (spec §13.2). Refetches when a newer version is known. */
-export function useArtifactHistory(
-  id: string | undefined,
-  options: { pageSize?: number } = {},
-): UseArtifactHistoryResult {
-  const { client, cache } = useArtkit();
-  const pageSize = options.pageSize ?? 20;
-  const latest = useLatestVersion(id);
-  const [entries, setEntries] = useState<VersionEntry[]>([]);
-  const [cursor, setCursor] = useState<string | undefined>(undefined);
-  const [loading, setLoading] = useState(Boolean(id));
-  const [error, setError] = useState<unknown>(undefined);
-  const [restoring, setRestoring] = useState<number | undefined>(undefined);
-  const request = useRef(0);
-
-  const refresh = useCallback(async () => {
-    if (!id) return;
-    const ticket = ++request.current;
-    setLoading(true);
-    try {
-      const page = await client.history(id, { limit: pageSize });
-      if (ticket !== request.current) return;
-      setEntries(page.items);
-      setCursor(page.nextCursor);
-      setError(undefined);
-    } catch (caught) {
-      if (ticket === request.current) setError(caught);
-    } finally {
-      if (ticket === request.current) setLoading(false);
-    }
-  }, [client, id, pageSize]);
-
-  // biome-ignore lint/correctness/useExhaustiveDependencies: `latest` is the revalidation trigger.
-  useEffect(() => {
-    void refresh();
-  }, [refresh, latest]);
-
-  const loadMore = useCallback(async () => {
-    if (!id || !cursor) return;
-    const ticket = ++request.current;
-    setLoading(true);
-    try {
-      const page = await client.history(id, { limit: pageSize, cursor });
-      if (ticket !== request.current) return;
-      setEntries((previous) => {
-        const seen = new Set(previous.map((entry) => entry.version));
-        return [...previous, ...page.items.filter((entry) => !seen.has(entry.version))];
-      });
-      setCursor(page.nextCursor);
-    } catch (caught) {
-      if (ticket === request.current) setError(caught);
-    } finally {
-      if (ticket === request.current) setLoading(false);
-    }
-  }, [client, id, cursor, pageSize]);
-
-  const restore = useCallback(
-    async (version: number, message?: string) => {
-      if (!id) throw new ArtifactError('NOT_FOUND', 'No artifact id.');
-      setRestoring(version);
-      try {
-        const result = await client.restore(id, version, message);
-        cache.put(result.artifact);
-        return result;
-      } finally {
-        setRestoring(undefined);
-      }
-    },
-    [client, cache, id],
-  );
-
-  return { entries, loading, error, hasMore: cursor !== undefined, loadMore, refresh, restore, restoring };
-}
-
 export interface ApplyConflict {
   operations: unknown[];
   baseVersion: number;
   currentVersion?: number;
-  changes: ChangeSummary[];
 }
 
 export interface ApplyOptions {
   /** Defaults to the latest cached version (loaded when unknown). */
   baseVersion?: number;
-  idempotencyKey?: string;
-  message?: string;
 }
 
 export interface UseApplyOperationsResult {
@@ -227,12 +124,7 @@ export function useApplyOperations(id: string): UseApplyOperationsResult {
       let baseVersion = options.baseVersion;
       try {
         baseVersion ??= cache.latest(id)?.version ?? (await cache.load(id)).version;
-        const result = await client.apply(id, {
-          baseVersion,
-          operations,
-          idempotencyKey: options.idempotencyKey ?? newKey(),
-          ...(options.message ? { message: options.message } : {}),
-        });
+        const result = await client.apply(id, { baseVersion, operations });
         cache.put(result.artifact);
         conflictRef.current = undefined;
         setState({ pending: false });
@@ -241,15 +133,13 @@ export function useApplyOperations(id: string): UseApplyOperationsResult {
         const error = toArtifactError(caught);
         let conflict: ApplyConflict | undefined;
         if (error.code === 'VERSION_CONFLICT') {
-          const changes = error.details.changesSinceBase;
           const current = error.details.currentVersion;
           conflict = {
             operations,
             baseVersion: baseVersion ?? 0,
             ...(typeof current === 'number' ? { currentVersion: current } : {}),
-            changes: Array.isArray(changes) ? (changes as ChangeSummary[]) : [],
           };
-          cache.load(id, undefined, true).catch(noop);
+          cache.load(id, true).catch(noop);
         }
         conflictRef.current = conflict;
         setState({ pending: false, error, ...(conflict ? { conflict } : {}) });
@@ -262,7 +152,7 @@ export function useApplyOperations(id: string): UseApplyOperationsResult {
   const retry = useCallback(async () => {
     const conflict = conflictRef.current;
     if (!conflict) throw new ArtifactError('NOT_FOUND', 'There is no conflicting batch to retry.');
-    const latest = await cache.load(id, undefined, true);
+    const latest = await cache.load(id, true);
     return apply(conflict.operations, { baseVersion: latest.version });
   }, [apply, cache, id]);
 
@@ -275,7 +165,6 @@ export function useApplyOperations(id: string): UseApplyOperationsResult {
 }
 
 export interface ExportOptions {
-  version?: number;
   /** Triggers a browser download (default true). */
   download?: boolean;
   options?: Record<string, unknown>;
@@ -299,21 +188,21 @@ export interface UseArtifactExportResult {
  * Exports in the browser when a loaded exporter with runtime `any`/`browser` handles the format, else
  * through the client (spec §13.2), and triggers a download.
  */
-export function useArtifactExport(id: string, kind?: string): UseArtifactExportResult {
+export function useArtifactExport(id: string, format?: string): UseArtifactExportResult {
   const ctx = useArtkit();
   const { client, cache, registry } = ctx;
   const [pending, setPending] = useState<string | undefined>(undefined);
   const [error, setError] = useState<ArtifactError | undefined>(undefined);
   const [warnings, setWarnings] = useState<string[]>([]);
   const [loaded, setLoaded] = useState<AnyArtifactExporter[]>([]);
-  const knownKind = kind ?? cache.latest(id)?.kind;
+  const knownFormat = format ?? cache.latest(id)?.format;
 
   const browserExporters = useCallback(
     async (artifactKind: string): Promise<AnyArtifactExporter[]> => {
       const fromRegistry = registry.exporters(artifactKind).filter((exporter) => exporter.runtime !== 'node');
       if (!ctx.hasExporters(artifactKind)) return fromRegistry;
       const lazy = (await ctx.loadExporters(artifactKind)).filter(
-        (exporter) => exporter.kind === artifactKind && exporter.runtime !== 'node',
+        (exporter) => exporter.format === artifactKind && exporter.runtime !== 'node',
       );
       return [...lazy, ...fromRegistry];
     },
@@ -321,22 +210,22 @@ export function useArtifactExport(id: string, kind?: string): UseArtifactExportR
   );
 
   const loadFormats = useCallback(async () => {
-    if (!knownKind) return;
+    if (!knownFormat) return;
     try {
-      setLoaded(await browserExporters(knownKind));
+      setLoaded(await browserExporters(knownFormat));
     } catch {
       // Without browser exporters the server formats still work.
     }
-  }, [browserExporters, knownKind]);
+  }, [browserExporters, knownFormat]);
 
   const formats = useMemo(() => {
-    if (!knownKind) return [];
-    const set = new Set<string>(ctx.exportFormats[knownKind] ?? []);
-    for (const exporter of registry.exporters(knownKind))
-      if (exporter.runtime !== 'node') set.add(exporter.format);
-    for (const exporter of loaded) set.add(exporter.format);
+    if (!knownFormat) return [];
+    const set = new Set<string>(ctx.exportFormats[knownFormat] ?? []);
+    for (const exporter of registry.exporters(knownFormat))
+      if (exporter.runtime !== 'node') set.add(exporter.target);
+    for (const exporter of loaded) set.add(exporter.target);
     return [...set];
-  }, [ctx.exportFormats, knownKind, loaded, registry]);
+  }, [ctx.exportFormats, knownFormat, loaded, registry]);
 
   const exportArtifact = useCallback(
     async (format: string, options: ExportOptions = {}) => {
@@ -344,14 +233,11 @@ export function useArtifactExport(id: string, kind?: string): UseArtifactExportR
       setError(undefined);
       setWarnings([]);
       try {
-        const artifact =
-          options.version === undefined
-            ? (cache.latest(id) ?? (await cache.load(id)))
-            : await cache.load(id, options.version);
+        const artifact = cache.latest(id) ?? (await cache.load(id));
         let result: ClientExportResult | undefined;
         if (options.prefer !== 'server') {
-          const exporter = (await browserExporters(artifact.kind).catch(() => [])).find(
-            (candidate) => candidate.format === format,
+          const exporter = (await browserExporters(artifact.format).catch(() => [])).find(
+            (candidate) => candidate.target === format,
           );
           if (exporter) {
             const collected: string[] = [];
@@ -389,7 +275,6 @@ export function useArtifactExport(id: string, kind?: string): UseArtifactExportR
         }
         result ??= await client.export(id, {
           format,
-          ...(options.version === undefined ? {} : { version: options.version }),
           ...(options.options ? { options: options.options } : {}),
           ...(options.signal ? { signal: options.signal } : {}),
         });

package/src/i18n.ts

@@ -4,7 +4,7 @@ export const uiMessages = {
     loading: 'Loading…',
     generating: 'Generating…',
     provisional: 'Preview — not saved yet',
-    noRenderer: 'No renderer is registered for kind "{kind}". Showing the raw content.',
+    noRenderer: 'No renderer is registered for kind "{format}". Showing the raw content.',
     loadFailed: 'Could not load this artifact.',
     retry: 'Retry',
     close: 'Close',
@@ -15,7 +15,8 @@ export const uiMessages = {
     latest: 'latest',
     tabView: 'View',
     tabCode: 'Code',
-    tabHistory: 'History',
+    tabEdit: 'Edit',
+    save: 'Save',
     tabsLabel: 'Artifact sections',
     copy: 'Copy',
     copied: 'Copied',
@@ -25,34 +26,10 @@ export const uiMessages = {
     exported: 'Exported {filename}',
     exportWarnings: 'Export finished with warnings:',
     noExportFormats: 'No export formats available',
-    status: 'Status',
-    status_draft: 'Draft',
-    status_pending_approval: 'Pending approval',
-    status_published: 'Published',
-    status_archived: 'Archived',
-    action_submit: 'Submit for approval',
-    action_approve: 'Approve',
-    action_reject: 'Reject',
-    action_publish: 'Publish',
-    action_archive: 'Archive',
-    statusChanged: 'Status changed to {status}',
     rejectReason: 'Reason for rejection',
-    rejectReasonRequired: 'Explain why the version is being rejected.',
     confirmReject: 'Confirm rejection',
     cancel: 'Cancel',
-    approvalTitle: 'Review version {version}',
-    approvalComparedTo: 'Compared with version {version}',
-    approvalFirstVersion: 'First version: nothing to compare with.',
-    notPending: 'This artifact is not waiting for approval.',
-    approved: 'Version {version} approved',
-    rejected: 'Version {version} rejected',
-    historyEmpty: 'No versions yet.',
     loadMore: 'Load more',
-    restore: 'Restore',
-    restoreVersion: 'Restore version {version}',
-    restored: 'Version {version} restored as version {newVersion}',
-    viewVersion: 'View version {version}',
-    restoredFrom: 'restored from v{version}',
     by: 'by {actor}',
     actor_agent: 'agent',
     actor_user: 'user',
@@ -66,8 +43,6 @@ export const uiMessages = {
     diffUnified: 'Highlighted',
     diffSplit: 'Side by side',
     diffViewLabel: 'Diff layout',
-    diffBefore: 'Version {version}',
-    diffAfter: 'Version {version}',
     lineAdded: 'added',
     lineRemoved: 'removed',
     undo: 'Undo',
@@ -76,18 +51,12 @@ export const uiMessages = {
     redone: 'Change redone',
     saving: 'Saving…',
     saved: 'Saved',
-    savedVersion: 'Saved version {version}',
     unsaved: 'Unsaved changes',
     rolledBack: 'Change rejected: {message}',
     dismiss: 'Dismiss',
     readOnly: 'Read only',
     lockedBy: 'Locked by the {actor} — editing is disabled.',
     lockedUntil: 'Locked until {time} — editing is disabled.',
-    agentUpdated: 'The artifact was updated to version {version}',
-    conflictTitle: 'Your edit conflicts with a newer version',
-    conflictBody: 'Version {version} changed the same items you edited.',
-    conflictUndoBody: 'The artifact changed after your edit, so undoing it would also discard those changes.',
-    keepTheirs: 'Keep agent version',
     reapplyMine: 'Reapply my edit',
     editorLabel: 'Editor for {title}',
     lintWarnings: '{count} lint warnings',
@@ -96,7 +65,7 @@ export const uiMessages = {
     loading: 'Carregando…',
     generating: 'Gerando…',
     provisional: 'Prévia — ainda não salva',
-    noRenderer: 'Não há renderer registrado para o tipo "{kind}". Exibindo o conteúdo bruto.',
+    noRenderer: 'Não há renderer registrado para o tipo "{format}". Exibindo o conteúdo bruto.',
     loadFailed: 'Não foi possível carregar este artefato.',
     retry: 'Tentar novamente',
     close: 'Fechar',
@@ -107,7 +76,8 @@ export const uiMessages = {
     latest: 'atual',
     tabView: 'Visualização',
     tabCode: 'Código',
-    tabHistory: 'Histórico',
+    tabEdit: 'Editar',
+    save: 'Salvar',
     tabsLabel: 'Seções do artefato',
     copy: 'Copiar',
     copied: 'Copiado',
@@ -117,34 +87,10 @@ export const uiMessages = {
     exported: '{filename} exportado',
     exportWarnings: 'Exportação concluída com avisos:',
     noExportFormats: 'Nenhum formato de exportação disponível',
-    status: 'Status',
-    status_draft: 'Rascunho',
-    status_pending_approval: 'Aguardando aprovação',
-    status_published: 'Publicado',
-    status_archived: 'Arquivado',
-    action_submit: 'Enviar para aprovação',
-    action_approve: 'Aprovar',
-    action_reject: 'Rejeitar',
-    action_publish: 'Publicar',
-    action_archive: 'Arquivar',
-    statusChanged: 'Status alterado para {status}',
     rejectReason: 'Motivo da rejeição',
-    rejectReasonRequired: 'Explique por que a versão está sendo rejeitada.',
     confirmReject: 'Confirmar rejeição',
     cancel: 'Cancelar',
-    approvalTitle: 'Revisar versão {version}',
-    approvalComparedTo: 'Comparada com a versão {version}',
-    approvalFirstVersion: 'Primeira versão: não há com o que comparar.',
-    notPending: 'Este artefato não está aguardando aprovação.',
-    approved: 'Versão {version} aprovada',
-    rejected: 'Versão {version} rejeitada',
-    historyEmpty: 'Ainda não há versões.',
     loadMore: 'Carregar mais',
-    restore: 'Restaurar',
-    restoreVersion: 'Restaurar versão {version}',
-    restored: 'Versão {version} restaurada como versão {newVersion}',
-    viewVersion: 'Ver versão {version}',
-    restoredFrom: 'restaurada da v{version}',
     by: 'por {actor}',
     actor_agent: 'agente',
     actor_user: 'usuário',
@@ -158,8 +104,6 @@ export const uiMessages = {
     diffUnified: 'Destacado',
     diffSplit: 'Lado a lado',
     diffViewLabel: 'Layout do diff',
-    diffBefore: 'Versão {version}',
-    diffAfter: 'Versão {version}',
     lineAdded: 'inserida',
     lineRemoved: 'removida',
     undo: 'Desfazer',
@@ -168,18 +112,12 @@ export const uiMessages = {
     redone: 'Alteração refeita',
     saving: 'Salvando…',
     saved: 'Salvo',
-    savedVersion: 'Versão {version} salva',
     unsaved: 'Alterações não salvas',
     rolledBack: 'Alteração rejeitada: {message}',
     dismiss: 'Dispensar',
     readOnly: 'Somente leitura',
     lockedBy: 'Bloqueado pelo {actor} — edição desativada.',
     lockedUntil: 'Bloqueado até {time} — edição desativada.',
-    agentUpdated: 'O artefato foi atualizado para a versão {version}',
-    conflictTitle: 'Sua edição conflita com uma versão mais nova',
-    conflictBody: 'A versão {version} alterou os mesmos itens que você editou.',
-    conflictUndoBody: 'O artefato mudou depois da sua edição; desfazê-la também descartaria essas mudanças.',
-    keepTheirs: 'Manter versão do agente',
     reapplyMine: 'Reaplicar minha edição',
     editorLabel: 'Editor de {title}',
     lintWarnings: '{count} avisos de lint',

package/src/index.ts

@@ -11,20 +11,13 @@ export {
   type HttpClientOptions,
   type ReadOptions,
   type RequestOptions,
-  STATUS_ACTIONS,
-  type StatusAction,
 } from './client.js';
-export {
-  ArtifactApproval,
-  type ArtifactApprovalPart,
-  type ArtifactApprovalProps,
-} from './components/approval.js';
 export { ArtifactCard, type ArtifactCardPart, type ArtifactCardProps } from './components/card.js';
 export {
   ArtifactEditor,
   type ArtifactEditorPart,
   type ArtifactEditorProps,
-  type EditorPermission,
+  type SaveEvent,
 } from './components/editor.js';
 export {
   ArtifactPanel,
@@ -32,20 +25,12 @@ export {
   type ArtifactPanelProps,
   type PanelTab,
 } from './components/panel.js';
-export { type Slots, StatusBadge } from './components/shared.js';
-export {
-  ArtifactVersionDiff,
-  type ArtifactVersionDiffPart,
-  type ArtifactVersionDiffProps,
-  compareVersions,
-  type DiffLayout,
-  type VersionComparison,
-} from './components/version-diff.js';
+export type { Slots } from './components/shared.js';
 export {
   ArtifactView,
   type ArtifactViewPart,
   type ArtifactViewProps,
-  KindRenderer,
+  FormatRenderer,
   previewContent,
 } from './components/view.js';
 export {
@@ -92,17 +77,10 @@ export {
 } from './controls.js';
 export { triggerDownload } from './download.js';
 export {
-  type ConflictChoice,
-  EditorSession,
-  type EditorSessionOptions,
-  type EditorSessionState,
-  type EnvelopeState,
-  envelopeOf,
-  operationsBetween,
-  type SendRequest,
-  type SessionConflict,
-  type SessionEvent,
-  type SessionStatus,
+  DraftSession,
+  type DraftSessionOptions,
+  type DraftSnapshot,
+  type EmitOptions,
 } from './editor-session.js';
 export {
   type ApplyConflict,
@@ -110,13 +88,11 @@ export {
   type ExportOptions,
   type UseApplyOperationsResult,
   type UseArtifactExportResult,
-  type UseArtifactHistoryResult,
   type UseArtifactOptions,
   type UseArtifactResult,
   useApplyOperations,
   useArtifact,
   useArtifactExport,
-  useArtifactHistory,
   useLatestVersion,
 } from './hooks.js';
 export {
@@ -128,14 +104,6 @@ export {
   uiMessages,
 } from './i18n.js';
 export { kitCss } from './kit-css.js';
-export {
-  diffLines,
-  type LineDiffEntry,
-  type LineDiffOptions,
-  type LineDiffType,
-  type SplitRow,
-  toSplitRows,
-} from './line-diff.js';
 export { parsePartialJson } from './partial-json.js';
 export { ArtifactProvider, type ArtifactProviderProps } from './provider.js';
 export { artkitCss, darkTheme, mixColors, themeStyles } from './styles.js';

package/src/provider.tsx

@@ -18,7 +18,7 @@ export interface ArtifactProviderProps {
   /** Core registry with the kinds the app shows (parsePartial, apply, project, diff, lint). */
   registry: ArtifactRegistry;
   client: ArtifactClient;
-  /** Lazy renderers, editors and exporters per kind. Read once per kind: later changes are ignored. */
+  /** Lazy renderers, editors and exporters per format. Read once per format: later changes are ignored. */
   loaders?: ArtifactLoaders;
   /** UI locale (pt-BR or en built in). Artifacts keep their own locale for content formatting. */
   locale?: string;
@@ -92,8 +92,8 @@ export function ArtifactProvider(props: ArtifactProviderProps) {
 
   const value = useMemo<ArtkitContextValue>(() => {
     const byId = new Map(themeList.map((theme) => [theme.id, theme]));
-    function load<T>(type: 'renderer' | 'editor' | 'exporters', kind: string): Promise<T> {
-      const key: LoadKey = `${type}:${kind}`;
+    function load<T>(type: 'renderer' | 'editor' | 'exporters', format: string): Promise<T> {
+      const key: LoadKey = `${type}:${format}`;
       let promise = loads.current.get(key) as Promise<T> | undefined;
       if (!promise) {
         const group =
@@ -102,10 +102,10 @@ export function ArtifactProvider(props: ArtifactProviderProps) {
             : type === 'editor'
               ? loadersRef.current?.editors
               : loadersRef.current?.exporters;
-        const loader = group?.[kind];
+        const loader = group?.[format];
         promise = loader
           ? (loader() as Promise<T>)
-          : Promise.reject(new Error(`No ${type} loader registered for kind "${kind}".`));
+          : Promise.reject(new Error(`No ${type} loader registered for kind "${format}".`));
         loads.current.set(key, promise);
       }
       return promise;
@@ -122,14 +122,14 @@ export function ArtifactProvider(props: ArtifactProviderProps) {
       ...(props.resolveAssetUrl ? { resolveAssetUrl: props.resolveAssetUrl } : {}),
       ...(props.assets ? { assets: props.assets } : {}),
       exportFormats: props.exportFormats ?? {},
-      hasRenderer: (kind) => Boolean(loadersRef.current?.renderers?.[kind]),
-      hasEditor: (kind) => Boolean(loadersRef.current?.editors?.[kind]),
-      hasExporters: (kind) => Boolean(loadersRef.current?.exporters?.[kind]),
-      loadRenderer: (kind) => load<RendererModule>('renderer', kind),
-      loadEditor: (kind) => load<EditorModule>('editor', kind),
-      loadExporters: (kind) => load('exporters', kind),
-      resetLoad: (type, kind) => {
-        loads.current.delete(`${type}:${kind}`);
+      hasRenderer: (format) => Boolean(loadersRef.current?.renderers?.[format]),
+      hasEditor: (format) => Boolean(loadersRef.current?.editors?.[format]),
+      hasExporters: (format) => Boolean(loadersRef.current?.exporters?.[format]),
+      loadRenderer: (format) => load<RendererModule>('renderer', format),
+      loadEditor: (format) => load<EditorModule>('editor', format),
+      loadExporters: (format) => load('exporters', format),
+      resetLoad: (type, format) => {
+        loads.current.delete(`${type}:${format}`);
       },
       ...(nonce ? { nonce } : {}),
     };

package/src/styles.ts

@@ -139,7 +139,7 @@ export const artkitCss = `
 .ak-button:hover:not(:disabled){background:var(--ak-color-hover);border-color:var(--ak-color-border-strong)}
 .ak-button:active:not(:disabled){background:var(--ak-color-active)}
 .ak-button:disabled{opacity:.4;cursor:not-allowed}
-.ak-button[data-variant="primary"]{border-color:transparent;background:var(--ak-gradient-button);color:var(--ak-color-on-primary)}
+.ak-button[data-variant="primary"]{border-color:transparent;background:var(--ak-gradient-button);color:var(--ak-color-on-primary);border-radius:var(--ak-radius-pill)}
 .ak-button[data-variant="primary"]:hover:not(:disabled){background:var(--ak-gradient-button-hover);border-color:transparent}
 .ak-button[data-variant="primary"]:active:not(:disabled){background:var(--ak-gradient-button-active)}
 .ak-button[data-variant="quiet"]{border-color:transparent;background:transparent;color:var(--ak-color-muted)}
@@ -172,11 +172,11 @@ export const artkitCss = `
 .ak-card-title{font-weight:700;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;margin:0 0 4px;font-size:14px;font-family:var(--ak-font-heading)}
 .ak-card-meta{display:flex;flex-wrap:wrap;gap:6px;align-items:center;color:var(--ak-color-muted);font-size:12px}
 .ak-panel{display:flex;flex-direction:column;height:100%;min-height:0;background:var(--ak-color-background);border:1px solid var(--ak-color-border);border-radius:var(--ak-radius);overflow:hidden}
-.ak-panel-header{display:flex;flex-wrap:wrap;align-items:center;gap:8px;padding:16px;border-bottom:1px solid var(--ak-color-border)}
+.ak-panel-header{display:flex;flex-wrap:wrap;align-items:center;gap:8px;padding:16px;border-bottom:1px solid var(--ak-color-border-soft)}
 .ak-panel-title{flex:1;min-width:120px;margin:0;font-size:16px;line-height:22px;font-weight:700;font-family:var(--ak-font-heading)}
-.ak-panel-toolbar{display:flex;flex-wrap:wrap;align-items:center;gap:8px;padding:12px 16px;border-bottom:1px solid var(--ak-color-border)}
+.ak-panel-toolbar{display:flex;flex-wrap:wrap;align-items:center;gap:8px;padding:12px 16px;border-bottom:1px solid var(--ak-color-border-soft)}
 .ak-panel-body{flex:1;min-height:0;overflow:auto;padding:16px}
-.ak-tabs{display:flex;gap:4px;padding:0 16px;border-bottom:1px solid var(--ak-color-border);overflow-x:auto;scrollbar-width:none}
+.ak-tabs{display:flex;gap:4px;padding:0 16px;border-bottom:1px solid var(--ak-color-border-soft);overflow-x:auto;scrollbar-width:none}
 .ak-tab{display:inline-flex;align-items:center;gap:8px;height:36px;padding:0 12px;font:inherit;font-size:14px;font-weight:600;border:0;border-bottom:2px solid transparent;background:none;color:var(--ak-color-muted);cursor:pointer;white-space:nowrap}
 .ak-tab:hover{color:var(--ak-color-text)}
 .ak-tab[aria-selected="true"]{color:var(--ak-color-text);border-bottom-color:var(--ak-color-primary)}

package/dist/components/approval.d.ts

@@ -1,34 +0,0 @@
-import type { Artifact } from '@artkit-ai/core';
-import { type CSSProperties } from 'react';
-import { type Slots } from './shared.js';
-export type ArtifactApprovalPart = 'header' | 'diff' | 'actions' | 'reason';
-export interface ArtifactApprovalProps {
-    id?: string;
-    artifact?: Artifact;
-    /** Require a reason to reject (default true). */
-    requireReason?: boolean;
-    onApproved?(artifact: Artifact): void;
-    onRejected?(artifact: Artifact, reason: string): void;
-    className?: string;
-    slots?: Slots<ArtifactApprovalPart>;
-}
-/**
- * Review of the version waiting for approval (spec §13.1, §15.3): diff against the last published
- * version (`meta.publishedVersion`) or the previous one, plus approve and reject with a reason.
- */
-export declare function ArtifactApproval(props: ArtifactApprovalProps): import("react").JSX.Element;
-export interface RejectFormProps {
-    busy: boolean;
-    requireReason: boolean;
-    reason: string;
-    onReasonChange(reason: string): void;
-    onSubmit(): void;
-    onCancel(): void;
-    textareaProps?: {
-        className?: string;
-        style?: CSSProperties;
-    };
-}
-/** Inline rejection form shared by the approval view and the panel. Escape cancels. */
-export declare function RejectForm(props: RejectFormProps): import("react").JSX.Element;
-//# sourceMappingURL=approval.d.ts.map