@tiinex/app 0.1.1

package/src/schemas/workspace/workspace.canonicalReferenceDialog.views.jsx

@@ -0,0 +1,63 @@
+import React, { useEffect, useMemo, useState } from 'react';
+import { Badge } from '../../ui/primitives/Badge.jsx';
+import { Button } from '../../ui/primitives/Button.jsx';
+import { Modal } from '../../ui/primitives/Modal.jsx';
+
+export const CANONICAL_REFERENCE_SELECTION_ROLE = 'reference-target';
+
+export function CanonicalReferenceDialog({ record, action, workspaceId = '', targets = [], selectionSession = null, selectionResult = null, onBeginSelection, onSelectionConsumed, onDismiss, onCreate }) {
+  const [selected, setSelected] = useState(null);
+  const [error, setError] = useState('');
+  const ownerKey = useMemo(() => `reference:${String(action?.definitionKey || action?.id || '')}:${String(workspaceId)}:${String(record?.id || '')}`, [action?.definitionKey, action?.id, workspaceId, record?.id]);
+  const enabled = useMemo(() => (Array.isArray(targets) ? targets : []).filter((item) => item?.enabled), [targets]);
+  useEffect(() => {
+    if (selectionResult?.ok && selectionResult.ownerKey === ownerKey && selectionResult.role === CANONICAL_REFERENCE_SELECTION_ROLE) {
+      setSelected(selectionResult.candidate); setError(''); onSelectionConsumed?.(selectionResult.sessionId);
+    }
+  }, [selectionResult, ownerKey, onSelectionConsumed]);
+  if (selectionSession?.ok && selectionSession.ownerKey === ownerKey) return null;
+  function beginSelection() {
+    if (!enabled.length) return setError('No qualified Reference target is currently available.');
+    const started = onBeginSelection?.({
+      role: CANONICAL_REFERENCE_SELECTION_ROLE,
+      ownerKey,
+      originWorkspaceId: workspaceId,
+      title: 'Choose Reference target',
+      guidance: 'Choose one qualified Task in the visible workspace surface. Reference remains a typed non-parent relation; Parent and provenance do not change.',
+      presentation: { verse: 'feed' },
+      candidates: enabled
+    });
+    if (started?.ok === false) setError(started.notice || 'Reference target selection could not start.');
+  }
+  async function submit(event) {
+    event.preventDefault();
+    if (!selected) return setError('Choose one qualified Reference target.');
+    setError('');
+    const result = await onCreate?.(record, action, selected);
+    if (result?.ok === false) setError(result.notice || 'Reference Relation could not be created.');
+  }
+  return (
+    <Modal title={action?.label || 'Reference'} onDismiss={onDismiss} className="tx-dialog-reference-review">
+      <form className="tx-form" onSubmit={submit} data-form="canonical-reference-form">
+        <p className="tx-muted">Create one browser-local Relation artifact from <strong>{record?.title || 'the selected Topic'}</strong> to a distinct qualified Task. Target selection happens in the workspace surface so spatial/source context remains visible.</p>
+        <div className="tx-dialog-actions tx-reference-picker-actions">
+          <Button type="button" variant="primary" icon="reference" onClick={beginSelection}>{selected ? 'Change target in workspace' : 'Choose target in workspace'}</Button>
+        </div>
+        {selected ? (
+          <div className="tx-record-action-result" data-reference-review="true">
+            <div className="tx-card-badges"><Badge>Relation</Badge><Badge>non-parent</Badge><Badge>local draft</Badge></div>
+            <p><strong>Subject:</strong> {record?.title || record?.path || 'Topic'}</p>
+            <p><strong>Target:</strong> {selected.title || selected.path || 'Task'}</p>
+            {selected.path ? <p><strong>Target path:</strong> <code>{selected.path}</code></p> : null}
+            <p className="tx-muted">The Relation preserves subject/object identity and explicit non-Parent meaning. Neither participant is mutated and no truth, evidence, authority, dependency, or Parent ancestry is implied.</p>
+          </div>
+        ) : <p className="tx-muted">No target selected yet.</p>}
+        {error ? <p className="tx-form-error" role="alert">{error}</p> : null}
+        <div className="tx-dialog-actions">
+          <Button type="button" variant="ghost" onClick={onDismiss}>Cancel</Button>
+          <Button type="submit" variant="primary" icon="reference" disabled={!selected}>Create local Relation</Button>
+        </div>
+      </form>
+    </Modal>
+  );
+}

package/src/schemas/workspace/workspace.canonicalTaskDialog.views.jsx

@@ -0,0 +1,169 @@
+import React, { useEffect, useMemo, useState } from 'react';
+import { Button } from '../../ui/primitives/Button.jsx';
+import { Modal } from '../../ui/primitives/Modal.jsx';
+import { TextareaField, TextField } from '../../ui/primitives/Field.jsx';
+import { firstMissingSchemaFactoryAuthoringInput, initialSchemaFactoryAuthoringValues, isSchemaFactoryViewerCreateAction, normalizeSchemaFactoryAuthoringValues } from '../schema.factory.viewerProjection.js';
+
+export const CANONICAL_STORAGE_PLACEMENT_SELECTION_ROLE = 'storage-placement';
+export const CANONICAL_CONTINUITY_PARENT_SELECTION_ROLE = 'continuity-parent';
+
+const SHORT_FIELD_NAMES = new Set(['Summary', 'Source Role', 'Target Role', 'Interpretation Action']);
+
+export function CanonicalAuthoringDialog({ record, action, workspaceId = '', placementTargets = [], selectionSession = null, selectionResult = null, onBeginSelection, onSelectionConsumed, onDismiss, onCreate, onBack = null }) {
+  const requiredInputs = Array.isArray(action?.authoring?.requiredInputs) ? action.authoring.requiredInputs : [];
+  const fixedInputs = action?.authoring?.fixedInputs || {};
+  const factoryAuthoring = isSchemaFactoryViewerCreateAction(action);
+  const inputDescriptors = Object.fromEntries((Array.isArray(action?.authoring?.inputDescriptors) ? action.authoring.inputDescriptors : []).map((descriptor) => [descriptor.name, descriptor]));
+  const editableInputs = requiredInputs.filter((name) => !Object.prototype.hasOwnProperty.call(fixedInputs, name));
+  const initialValues = factoryAuthoring
+    ? { ...initialSchemaFactoryAuthoringValues(action), ...fixedInputs }
+    : Object.fromEntries(requiredInputs.map((name) => [name, Object.prototype.hasOwnProperty.call(fixedInputs, name) ? fixedInputs[name] : '']));
+  const [values, setValues] = useState(() => initialValues);
+  const [error, setError] = useState('');
+  const [placementFolder, setPlacementFolder] = useState('');
+  const [parentReviewed, setParentReviewed] = useState(false);
+  const ownerBase = useMemo(() => `authoring:${String(action?.definitionKey || action?.id || '')}:${String(workspaceId)}:${String(record?.id || 'root')}`, [action?.definitionKey, action?.id, workspaceId, record?.id]);
+  useEffect(() => {
+    if (!selectionResult?.ok || !String(selectionResult.ownerKey || '').startsWith(`${ownerBase}:`)) return;
+    if (selectionResult.role === CANONICAL_STORAGE_PLACEMENT_SELECTION_ROLE) setPlacementFolder(String(selectionResult.candidate?.path || ''));
+    if (selectionResult.role === CANONICAL_CONTINUITY_PARENT_SELECTION_ROLE) setParentReviewed(true);
+    setError(''); onSelectionConsumed?.(selectionResult.sessionId);
+  }, [selectionResult, ownerBase, onSelectionConsumed]);
+  const required = new Set(requiredInputs);
+  const schemaLabel = action?.authoring?.schemaLabel || action?.authoring?.schemaId || 'Artifact';
+  function set(name, value) { setValues((current) => ({ ...current, [name]: value })); }
+  async function submit(event) {
+    event.preventDefault();
+    const finalValues = factoryAuthoring
+      ? { ...normalizeSchemaFactoryAuthoringValues(action, values), ...fixedInputs }
+      : { ...values, ...fixedInputs };
+    const missing = factoryAuthoring
+      ? firstMissingSchemaFactoryAuthoringInput(action, finalValues)
+      : [...required].find((name) => finalValues[name] === undefined || String(finalValues[name]).trim() === '');
+    if (missing) return setError(`${missing} is required.`);
+    setError('');
+    const result = await onCreate?.(record, action, finalValues, { placementFolder, workspaceId });
+    if (result?.ok === false) setError(result.notice || `${schemaLabel} could not be created.`);
+  }
+  function beginPlacementSelection() {
+    const candidates = (Array.isArray(placementTargets) ? placementTargets : []).filter((item) => item?.enabled !== false);
+    if (!candidates.length) return setError('No qualified same-workspace storage folder is available.');
+    onBeginSelection?.({ role: CANONICAL_STORAGE_PLACEMENT_SELECTION_ROLE, ownerKey: `${ownerBase}:placement`, originWorkspaceId: workspaceId, title: 'Choose storage folder', guidance: 'Choose a same-workspace folder. This changes only browser-local storage placement; Parent, Reference and source provenance stay unchanged.', presentation: { verse: 'tree' }, candidates });
+  }
+  function beginParentReview() {
+    if (!record?.id || !workspaceId) return setError('Continuity Parent is not available for workspace selection.');
+    onBeginSelection?.({ role: CANONICAL_CONTINUITY_PARENT_SELECTION_ROLE, ownerKey: `${ownerBase}:parent`, originWorkspaceId: workspaceId, title: 'Review Continuity Parent', guidance: 'This Transition fixes the Parent. The workspace surface identifies that exact parent; selecting another artifact is not authorized.', presentation: { verse: 'feed' }, candidates: [{ kind:'record', key:`continuity-parent:${workspaceId}:${record.id}`, workspaceId, id:record.id, title:record.title || record.path || 'Parent', path:record.path || '', schemaId:record.schemaId || '', enabled:true, boundary:'Fixed by the qualified Transition; review only, not an arbitrary Parent override.' }] });
+  }
+  const focusInput = editableInputs[0] || requiredInputs[0] || '';
+  if (selectionSession?.ok && String(selectionSession.ownerKey || '').startsWith(`${ownerBase}:`)) return null;
+  return (
+    <Modal title={action?.label || `Create ${schemaLabel}`} onDismiss={onDismiss} initialFocus={focusInput ? authoringInputId(focusInput) : undefined}>
+      <form className="tx-form" onSubmit={submit} data-form="canonical-authoring-form">
+        {requiredInputs.map((name) => {
+          const id = authoringInputId(name);
+          const fixed = Object.prototype.hasOwnProperty.call(fixedInputs, name);
+          const descriptor = inputDescriptors[name] || null;
+          const common = { key: name, id, label: authoringFieldLabel(name, schemaLabel), value: fixed ? fixedInputs[name] : values[name], required: required.has(name) };
+          if (fixed) return <TextField {...common} onChange={() => {}} readOnly aria-readonly="true" />;
+          if (descriptor?.kind === 'ordinary-group') return <StructuredGroupAuthoringInput key={name} descriptor={descriptor} value={values[name]} onChange={(value) => set(name, value)} />;
+          if (descriptor?.kind === 'named-declaration-section') return <NamedDeclarationAuthoringInput key={name} descriptor={descriptor} value={values[name]} onChange={(value) => set(name, value)} />;
+          if (factoryAuthoring && ['ordinary-field', 'root-current-summary-body-title'].includes(descriptor?.kind)) return <TextField {...common} onChange={(value) => set(name, value)} autoFocus={name === focusInput} />;
+          if (SHORT_FIELD_NAMES.has(name)) return <TextField {...common} onChange={(value) => set(name, value)} autoFocus={name === focusInput} />;
+          return <TextareaField {...common} onChange={(value) => set(name, value)} rows={3} autoFocus={name === focusInput} />;
+        })}
+        <section className="tx-authoring-placement-controls" aria-label="Continuity and storage placement">
+          {action?.continuityMode === 'parent' && record ? <div><strong>Continuity Parent</strong><p className="tx-muted">{record.title || record.path || 'Selected artifact'} · fixed by the qualified Transition.</p><Button type="button" variant="ghost" icon="lineage" onClick={beginParentReview}>{parentReviewed ? 'Review Parent again' : 'Review Parent in workspace'}</Button></div> : null}
+          <div><strong>Storage placement</strong><p className="tx-muted">{placementFolder ? `Explicit same-workspace folder: ${placementFolder}` : 'Automatic canonical placement'}</p><Button type="button" variant="ghost" icon="folderOpen" onClick={beginPlacementSelection}>{placementFolder ? 'Change storage folder' : 'Choose storage folder'}</Button>{placementFolder ? <Button type="button" variant="ghost" onClick={() => setPlacementFolder('')}>Use automatic</Button> : null}</div>
+        </section>
+        <p className="tx-muted">{factoryAuthoring
+          ? `Creates one standalone browser-local ${schemaLabel} through its qualified Artifact Creation Contract and shared factory renderer/validator. No canonical Transition, Parent, or source provenance is invented.`
+          : action?.continuityMode === 'root' ? `Creates one standalone browser-local ${schemaLabel} through the selected qualified canonical Transition. No Parent or source provenance is invented.` : `Creates one browser-local ${schemaLabel} through the qualified canonical Transition from ${record?.title || 'the selected artifact'}. The selected source artifact remains unchanged; no remote write is performed.`}</p>
+        {error ? <p className="tx-form-error" role="alert">{error}</p> : null}
+        <div className="tx-dialog-actions">
+          {onBack ? <Button type="button" variant="ghost" onClick={onBack}>Back</Button> : <Button type="button" variant="ghost" onClick={onDismiss}>Cancel</Button>}
+          <Button type="submit" variant="primary" icon={action?.icon || 'create'}>Create local {schemaLabel.toLowerCase()}</Button>
+        </div>
+      </form>
+    </Modal>
+  );
+}
+
+function StructuredGroupAuthoringInput({ descriptor = {}, value = {}, onChange }) {
+  const current = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  const fields = [...descriptor.requiredFields, ...descriptor.optionalFields];
+  function setField(field, next) { onChange?.({ ...current, [field]: next }); }
+  return (
+    <fieldset className="tx-authoring-structured-group" data-authoring-binding="ordinary-group">
+      <legend>{descriptor.name}</legend>
+      <p className="tx-muted">Structured fields from the qualified factory descriptor.</p>
+      {fields.map((field) => <TextField key={field} id={structuredInputId(descriptor.name, field)} label={field} value={current[field] || ''} onChange={(next) => setField(field, next)} required={descriptor.requiredFields.includes(field)} />)}
+    </fieldset>
+  );
+}
+
+function NamedDeclarationAuthoringInput({ descriptor = {}, value, onChange }) {
+  const literalNone = value === 'none';
+  const entries = Array.isArray(value) ? value : [];
+  function blankEntry() { return { name: '', fields: Object.fromEntries(descriptor.requiredFields.map((field) => [field, ''])) }; }
+  function updateEntry(index, updater) { onChange?.(entries.map((entry, entryIndex) => entryIndex === index ? updater(entry || blankEntry()) : entry)); }
+  function removeEntry(index) {
+    const next = entries.filter((_, entryIndex) => entryIndex !== index);
+    if (!next.length && descriptor.allowLiteralNone) onChange?.('none');
+    else onChange?.(next.length ? next : [blankEntry()]);
+  }
+  return (
+    <fieldset className="tx-authoring-named-declarations" data-authoring-binding="named-declaration-section">
+      <legend>{descriptor.name}</legend>
+      <p className="tx-muted">Repeatable named declarations remain structured; they are not flattened into free text.</p>
+      {literalNone ? <p className="tx-muted">Declared as <strong>none</strong>.</p> : entries.map((entry, index) => (
+        <section className="tx-authoring-declaration-entry" key={`${descriptor.name}-${index}`}>
+          <TextField id={structuredInputId(descriptor.name, `name-${index}`)} label="Declaration name" value={entry?.name || ''} onChange={(next) => updateEntry(index, (current) => ({ ...current, name: next }))} required />
+          {[...descriptor.requiredFields, ...descriptor.optionalFields].map((field) => <TextField key={field} id={structuredInputId(descriptor.name, `${field}-${index}`)} label={field} value={entry?.fields?.[field] || ''} onChange={(next) => updateEntry(index, (current) => ({ ...current, fields: { ...(current?.fields || {}), [field]: next } }))} required={descriptor.requiredFields.includes(field)} />)}
+          {entries.length > 1 || descriptor.allowLiteralNone ? <Button type="button" variant="ghost" onClick={() => removeEntry(index)}>Remove declaration</Button> : null}
+        </section>
+      ))}
+      <div className="tx-authoring-structured-actions">
+        {literalNone ? <Button type="button" variant="ghost" icon="add" onClick={() => onChange?.([blankEntry()])}>Add declaration</Button> : <Button type="button" variant="ghost" icon="add" onClick={() => onChange?.([...entries, blankEntry()])}>Add another</Button>}
+        {!literalNone && descriptor.allowLiteralNone ? <Button type="button" variant="ghost" onClick={() => onChange?.('none')}>Declare none</Button> : null}
+      </div>
+    </fieldset>
+  );
+}
+
+// Compatibility export for callers/tests that imported the first canonical slice by its old component name.
+export const CanonicalTaskCreateDialog = CanonicalAuthoringDialog;
+
+function authoringInputId(name = '') { return `canonicalAuthoring-${String(name).toLowerCase().replace(/[^a-z0-9]+/g, '-')}`; }
+function structuredInputId(group = '', field = '') { return `${authoringInputId(group)}-${String(field).toLowerCase().replace(/[^a-z0-9]+/g, '-')}`; }
+function authoringFieldLabel(name = '', schemaLabel = 'Artifact') { return name === 'Summary' ? `${schemaLabel} title` : name; }
+
+
+export function WorkspaceCanonicalCreateDialog({ workspace, actions = [], placementTargets = [], selectionSession = null, selectionResult = null, onBeginSelection, onSelectionConsumed, onDismiss, onCreate }) {
+  const qualifiedActions = (Array.isArray(actions) ? actions : []).filter((action) => action?.productCapable === true && action?.enabled !== false && action?.productScope === 'workspace');
+  const [selectedDefinitionKey, setSelectedDefinitionKey] = useState('');
+  const selected = qualifiedActions.find((action) => action.definitionKey === selectedDefinitionKey) || null;
+  if (selected) {
+    return <CanonicalAuthoringDialog record={null} action={selected} workspaceId={workspace?.id || ''} placementTargets={placementTargets} selectionSession={selectionSession} selectionResult={selectionResult} onBeginSelection={onBeginSelection} onSelectionConsumed={onSelectionConsumed} onDismiss={onDismiss} onBack={() => setSelectedDefinitionKey('')} onCreate={onCreate} />;
+  }
+  return (
+    <Modal title="Create artifact" onDismiss={onDismiss} className="tx-workspace-entrypoint-choice-modal">
+      <div className="tx-workspace-entrypoint-choice-copy">
+        <p className="tx-kicker">{workspace?.name || workspace?.title || 'Workspace'}</p>
+        <p>Choose a qualified artifact type. Tiinex will ask only for the fields owned by that type's exact creation contract.</p>
+      </div>
+      {qualifiedActions.length ? (
+        <div className="tx-workspace-entrypoint-choice-actions" role="group" aria-label="Qualified artifact types">
+          {qualifiedActions.map((action) => (
+            <div className="tx-workspace-entrypoint-choice-option" key={action.definitionKey}>
+              <Button variant="primary" icon={action.icon || 'create'} onClick={() => setSelectedDefinitionKey(action.definitionKey)}>{action.label || action.authoring?.schemaLabel || 'Artifact'}</Button>
+              <small><strong>{action.authoring?.schemaLabel || action.authoring?.schemaId || 'Artifact'}.</strong> {action.description || 'Create one browser-local artifact through this qualified canonical Transition.'}</small>
+            </div>
+          ))}
+        </div>
+      ) : <p className="tx-muted">No standalone artifact type is currently qualified for creation in this workspace.</p>}
+      <div className="tx-dialog-actions">
+        <Button variant="subtle" onClick={onDismiss}>Cancel</Button>
+      </div>
+    </Modal>
+  );
+}

package/src/schemas/workspace/workspace.cardActions.js

@@ -0,0 +1,9 @@
+export function appendTransitionActionsToStaticRow(actions = [], transitionActions = []) {
+  const stable = Array.isArray(actions) ? actions : [];
+  const transitions = Array.isArray(transitionActions) ? transitionActions : [];
+  if (!transitions.length) return stable;
+  // Keep learned/static controls in their stable order. Schema-owned transition
+  // affordances are dynamic, so they are appended as the right-edge group
+  // instead of inserted between static record actions.
+  return stable.concat(transitions);
+}

package/src/schemas/workspace/workspace.cards.views.jsx

@@ -0,0 +1,146 @@
+import React from 'react';
+import { Badge } from '../../ui/primitives/Badge.jsx';
+import { Button } from '../../ui/primitives/Button.jsx';
+import { Icon } from '../../ui/primitives/Icon.jsx';
+import { Modal } from '../../ui/primitives/Modal.jsx';
+import { isWorkspaceRecord, presentRecordActions, RecordActionKind } from '@tiinex/core/actions/record.actions.js';
+import { transitionProductActionsForRecord } from '../../transitions/transition.productPresentation.browser.js';
+import { AuditStatusBadge } from './workspace.auditBadge.views.jsx';
+import { SchemaReadView } from './workspace.read.views.jsx';
+import { appendTransitionActionsToStaticRow } from './workspace.cardActions.js';
+import { assetPreviewSummary, assetSourceBadge, assetSourceBoundary, compactPath, compactRecordDate, recordDisplayPath, recordLifecycleBadge, recordMaterialBadge, recordSchemaBadge, recordSchemaCanOpen, recordSourceBadge } from './workspace.viewFormatting.js';
+import { workspaceArtifactActionModel, workspaceArtifactBoundaryBadge } from '../../workspaces/workspace.artifactActions.js';
+import { RecordActionButton } from './workspace.recordActionButton.views.jsx';
+import { WORKSPACE_RECORD_PRIMARY_INTENT, workspaceRecordPrimaryIntent, workspaceRecordPrimaryLabel } from '../../workspaces/workspace.navigation.js';
+
+
+export const AssetCard = React.memo(function AssetCard({ asset, actionStateKey = '', onOpenAsset }) {
+  return (
+    <article className="tx-artifact-card tx-asset-card">
+      <div className="tx-card-badges">
+        <Badge>{assetSourceBadge(asset)}</Badge>
+        <Badge>{asset.type || 'asset'}</Badge>
+        <Badge>{asset.previewState || 'metadata-only'}</Badge>
+      </div>
+      <h3>{asset.name || asset.path || 'Local asset'}</h3>
+      {asset.path ? <div className="tx-card-pathline" title={asset.path}><Icon name="folderOpen" />{compactPath(asset.path)}</div> : null}
+      <p>{assetPreviewSummary(asset)}</p>
+      <footer className="tx-artifact-actions">
+        <Button icon="open" variant="ghost" onClick={() => onOpenAsset?.(asset.id || asset.path)}>Open</Button>
+      </footer>
+    </article>
+  );
+}, assetCardPropsEqual);
+
+export function RecordCard({ record, auditItem, actionStateKey = '', workspaceRecords = [], workspaceId = '', transitionProductContext = null, onOpenRecord, onFocusRecordLineage, onShareRecord, onRecordAction, onOpenSchema, context = 'discovery', expanded = false, onToggleExpanded, readOnly = false, selectionActive = false, selectionCandidate = null, onSelectCandidate }) {
+  const lineageContext = context === 'lineage';
+  const displayPath = recordDisplayPath(record);
+  const transitionActions = readOnly || selectionActive ? [] : transitionProductActionsForRecord(record, { surface: context, maxPrimary: 1, workspaceRecords, workspaceId, productContext: transitionProductContext });
+  const isWorkspaceArtifact = isWorkspaceRecord(record);
+  const workspaceActionModel = isWorkspaceArtifact ? workspaceArtifactActionModel(record) : null;
+  const baseActions = selectionActive ? [] : readOnly ? [{ id: RecordActionKind.open, label: 'Open', icon: 'open', enabled: true }] : presentRecordActions(record).filter((action) => action.enabled !== false && action.id !== RecordActionKind.reference && action.id !== RecordActionKind.continue);
+  const lineageAction = { id: RecordActionKind.lineage, label: lineageContext ? 'Anchor' : 'Lineage', icon: 'lineage', enabled: true };
+  const contextualActions = readOnly ? baseActions : lineageContext
+    ? [lineageAction, ...baseActions]
+    : [baseActions[0], lineageAction, ...baseActions.slice(1)].filter(Boolean);
+  const actions = appendTransitionActionsToStaticRow(contextualActions, transitionActions);
+  const dateBadge = compactRecordDate(record);
+  const schemaBadge = recordSchemaBadge(record);
+  const schemaOpenable = recordSchemaCanOpen(record);
+  const sourceBadge = recordSourceBadge(record);
+  const primaryIntent = workspaceRecordPrimaryIntent({ surface: context, selectionActive, selectionCandidate });
+  const primaryClick = () => {
+    if (primaryIntent === WORKSPACE_RECORD_PRIMARY_INTENT.select) return onSelectCandidate?.(selectionCandidate);
+    if (primaryIntent === WORKSPACE_RECORD_PRIMARY_INTENT.unavailable) return undefined;
+    if (primaryIntent === WORKSPACE_RECORD_PRIMARY_INTENT.toggleLineagePreview) return onToggleExpanded?.(record.id);
+    return onOpenRecord?.(record.id);
+  };
+  const onKey = (event) => {
+    if (event.key === 'Enter' || event.key === ' ') { event.preventDefault(); primaryClick(); }
+  };
+  return (
+    <article className={`tx-artifact-card tx-record-card tx-old-like-record-card tx-clickable-record-card ${isWorkspaceArtifact ? 'tx-workspace-artifact-record-card' : ''} ${lineageContext ? 'tx-lineage-as-record-card' : ''} ${expanded ? 'tx-record-card-expanded' : ''}`} role="button" tabIndex="0" aria-expanded={lineageContext ? expanded : undefined} aria-label={workspaceRecordPrimaryLabel({ intent: primaryIntent, title: record.title || 'artifact' })} onClick={primaryClick} onKeyDown={onKey} data-workspace-artifact-action-model={workspaceActionModel?.schema || undefined}>
+      <div className="tx-card-badges tx-legacy-card-badges">
+        {isWorkspaceArtifact ? <Badge>workspace</Badge> : null}
+        {isWorkspaceArtifact ? <Badge>{workspaceActionModel.roleLabel}</Badge> : null}
+        {isWorkspaceArtifact ? <Badge>{workspaceArtifactBoundaryBadge(record)}</Badge> : null}
+        <AuditStatusBadge record={record} item={auditItem} />
+        {recordLifecycleBadge(record) ? <Badge title="Lifecycle/publication state">{recordLifecycleBadge(record)}</Badge> : null}
+        {!readOnly && schemaOpenable ? <button type="button" className="tx-badge tx-badge-default tx-schema-nav-badge" title={`Open reading contract schema lineage for ${schemaBadge}`} aria-label={`Open reading contract schema lineage for ${schemaBadge}`} onClick={(event) => { event.stopPropagation(); onOpenSchema?.(record); }}>{schemaBadge}</button> : <Badge>{schemaBadge}</Badge>}
+        {dateBadge ? <Badge>{dateBadge}</Badge> : null}
+        <Badge>{sourceBadge}</Badge>
+        {recordMaterialBadge(record) ? <Badge title={record.materialReconciliation?.message || 'Material reconciliation'}>{recordMaterialBadge(record)}</Badge> : null}
+      </div>
+      <h3>{record.title || 'Untitled'}</h3>
+      <p>{record.summary || 'No summary available yet.'}</p>
+      {displayPath ? <div className="tx-card-pathline" title={displayPath}><Icon name="folderOpen" />{compactPath(displayPath)}</div> : null}
+      {lineageContext && expanded ? (
+        <div className="tx-record-card-read-preview" onClick={(event) => event.stopPropagation()}>
+          <SchemaReadView record={record} compact maxSections={2} showHeader={false} lineClamp />
+        </div>
+      ) : null}
+      <footer className="tx-legacy-action-row tx-artifact-actions" aria-label={selectionActive ? 'Selection action' : 'Artifact actions'} onClick={(event) => event.stopPropagation()}>
+        {selectionActive && selectionCandidate ? <Button variant="primary" icon="check" onClick={() => onSelectCandidate?.(selectionCandidate)}>Select</Button> : null}
+        {!selectionActive ? actions.map((action) => <RecordActionButton key={action.id} action={action} record={record} workspaceActionModel={workspaceActionModel} onOpenRecord={onOpenRecord} onFocusRecordLineage={onFocusRecordLineage} onShareRecord={onShareRecord} onRecordAction={onRecordAction} />) : null}
+      </footer>
+    </article>
+  );
+}
+
+
+
+export const MemoRecordCard = React.memo(RecordCard, recordCardPropsEqual);
+
+
+
+
+export function assetCardPropsEqual(previous = {}, next = {}) {
+  return previous.asset === next.asset
+    && previous.actionStateKey === next.actionStateKey
+    && Boolean(previous.onOpenAsset) === Boolean(next.onOpenAsset);
+}
+
+export function recordCardPropsEqual(previous = {}, next = {}) {
+  return previous.record === next.record
+    && previous.auditItem === next.auditItem
+    && previous.context === next.context
+    && previous.expanded === next.expanded
+    && previous.actionStateKey === next.actionStateKey
+    && previous.workspaceRecords === next.workspaceRecords
+    && previous.workspaceId === next.workspaceId
+    && previous.transitionProductContext === next.transitionProductContext
+    && previous.readOnly === next.readOnly
+    && previous.selectionActive === next.selectionActive
+    && previous.selectionCandidate === next.selectionCandidate
+    && Boolean(previous.onOpenRecord) === Boolean(next.onOpenRecord)
+    && Boolean(previous.onFocusRecordLineage) === Boolean(next.onFocusRecordLineage)
+    && Boolean(previous.onShareRecord) === Boolean(next.onShareRecord)
+    && Boolean(previous.onRecordAction) === Boolean(next.onRecordAction)
+    && Boolean(previous.onOpenSchema) === Boolean(next.onOpenSchema)
+    && Boolean(previous.onSelectCandidate) === Boolean(next.onSelectCandidate);
+}
+
+export function AssetDetailDialog({ asset, onDismiss }) {
+  return (
+    <Modal title={asset?.name || asset?.path || 'Local asset'} onDismiss={onDismiss}>
+      <div className="tx-record-detail tx-asset-detail">
+        <div className="tx-card-badges">
+          <Badge>{assetSourceBadge(asset)}</Badge>
+          <Badge>{asset?.type || 'asset'}</Badge>
+          <Badge>{asset?.previewState || 'metadata-only'}</Badge>
+        </div>
+        <dl className="tx-record-meta">
+          {asset?.path ? <div><dt>Path</dt><dd>{asset.path}</dd></div> : null}
+          {asset?.size != null ? <div><dt>Size</dt><dd>{asset.size} bytes</dd></div> : null}
+          <div><dt>Boundary</dt><dd>{assetSourceBoundary(asset)}</dd></div>
+        </dl>
+        {asset?.content ? <pre className="tx-record-markdown-preview">{String(asset.content).slice(0, 2400)}</pre> : null}
+        {asset?.dataUrl ? <img className="tx-local-asset-preview" src={asset.dataUrl} alt="" /> : null}
+        {!asset?.content && !asset?.dataUrl ? <p className="tx-muted">Preview is {asset?.previewState || 'metadata-only'}; metadata and source boundary are preserved.</p> : null}
+        <div className="tx-dialog-actions">
+          <Button variant="ghost" onClick={onDismiss}>Close</Button>
+        </div>
+      </div>
+    </Modal>
+  );
+}