clay-server 5.1.0-beta.1 → 5.1.0-beta.2

package/lib/public/modules/knowledge-db-workbench.js

@@ -0,0 +1,234 @@
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+import { iconHtml, refreshIcons } from './icons.js';
+import { isRecordEdit, buildRecordAttempt, buildCreateAttempt, isCurrentAttempt, applyRecordSave, updateViewPresentation } from './knowledge-db-edit-state.js';
+
+var requestCounter = 0;
+var pending = {};
+var renderOwner = null;
+var openOwnerDocument = null;
+var identityOwner = null;
+
+function setDialogBackground(panel, inert) {
+  Array.prototype.forEach.call(panel.children, function (child) {
+    if (child.classList.contains('knowledge-db-dialog')) return;
+    if (inert) { child.dataset.knowledgeDialogWasInert = child.inert ? 'true' : 'false'; child.dataset.knowledgeDialogAriaHidden = child.getAttribute('aria-hidden') == null ? '' : child.getAttribute('aria-hidden'); child.inert = true; child.setAttribute('aria-hidden', 'true'); }
+    else if (child.dataset.knowledgeDialogWasInert !== undefined) { child.inert = child.dataset.knowledgeDialogWasInert === 'true'; if (child.dataset.knowledgeDialogAriaHidden === '') child.removeAttribute('aria-hidden'); else child.setAttribute('aria-hidden', child.dataset.knowledgeDialogAriaHidden); delete child.dataset.knowledgeDialogWasInert; delete child.dataset.knowledgeDialogAriaHidden; }
+  });
+}
+
+function workspaceKey() { return store.get('currentSlug') || ''; }
+function allStates() { return store.get('mateKnowledgeDatabaseWorkspaces') || {}; }
+function stateFor(key) { return allStates()[key] || { databases: {}, createDraft: null, dialog: null, error: '' }; }
+function setState(key, value) { var states = Object.assign({}, allStates()); states[key] = value; store.set({ mateKnowledgeDatabaseWorkspaces: states }); }
+function patchState(key, patch) { setState(key, Object.assign({}, stateFor(key), patch)); }
+function databaseState(key, id) { return stateFor(key).databases[id] || { database: null, records: [], nextCursor: null, selectedRecord: null, recordDetail: null, edit: null, loading: true, error: '' }; }
+function setDatabaseState(key, id, value) { var outer = stateFor(key); var databases = Object.assign({}, outer.databases); databases[id] = value; setState(key, Object.assign({}, outer, { databases: databases })); }
+function patchDatabase(key, id, patch) { setDatabaseState(key, id, Object.assign({}, databaseState(key, id), patch)); }
+function mainState(key) { var all = store.get('mateKnowledgeWorkspaces') || {}; return all[key] || null; }
+function patchMain(key, patch) { var all = Object.assign({}, store.get('mateKnowledgeWorkspaces') || {}); if (!all[key]) return; all[key] = Object.assign({}, all[key], patch); store.set({ mateKnowledgeWorkspaces: all }); }
+function ownerToken(key) { var main = mainState(key) || {}; return { ownerSelection: main.selected || null, ownerSelectionVersion: main.selectionVersion || 0 }; }
+function stillOwns(key, tracked) { var main = mainState(key); return !!(main && main.selected === tracked.ownerSelection && (main.selectionVersion || 0) === tracked.ownerSelectionVersion); }
+function operationId(prefix) { requestCounter++; return prefix + '_' + Date.now() + '_' + requestCounter; }
+function send(key, type, details, track) {
+  var ws = getWs(); if (key !== workspaceKey() || !ws || ws.readyState !== 1) return null;
+  var requestId = 'knowledge-db-' + Date.now() + '-' + (++requestCounter); pending[requestId] = Object.assign({ key: key, type: type, socket: ws }, track || {});
+  try { ws.send(JSON.stringify(Object.assign({ type: type, requestId: requestId }, details || {}))); return requestId; }
+  catch (cause) { delete pending[requestId]; return null; }
+}
+function escapeText(value) { var span = document.createElement('span'); span.textContent = String(value == null ? '' : value); return span.innerHTML.replace(/"/g, '"').replace(/'/g, '''); }
+function escapeAttr(value) { return escapeText(value).replace(/"/g, '"').replace(/'/g, '''); }
+function selectedFile(key) { var state = mainState(key); return state && state.selected && state.drafts[state.selected] ? state.drafts[state.selected].file : null; }
+function active(key) { var file = selectedFile(key); return file && file.itemType === 'db' ? databaseState(key, file.id) : null; }
+function titleField(database) { return database && database.schema.filter(function (field) { return field.type === 'title' && !field.archived; })[0]; }
+function fieldById(database, id) { return database.schema.filter(function (field) { return field.id === id; })[0] || null; }
+function optionName(field, id) { var option = (field.options || []).filter(function (item) { return item.id === id; })[0]; return option ? option.name : 'Missing option'; }
+function displayValue(field, value, references) {
+  if (value === null || value === undefined || value === '') return '<span class="knowledge-db-empty">—</span>';
+  if (field.type === 'boolean') return value ? 'Yes' : 'No';
+  if (field.type === 'select') return escapeText(optionName(field, value));
+  if (field.type === 'multi-select') return value.map(function (id) { return '<span class="knowledge-db-pill">' + escapeText(optionName(field, id)) + '</span>'; }).join(' ');
+  if (field.type === 'reference') { var reference = (references || []).filter(function (item) { return item.fieldId === field.id; })[0] || { status: 'missing' }; var label = reference.label || value.id; if (reference.status !== 'available') return '<span class="knowledge-db-reference is-' + escapeText(reference.status) + '">' + iconHtml('circle-alert') + escapeText(label) + ' (' + escapeText(reference.status) + ')</span>'; return '<button type="button" class="knowledge-db-reference" data-db-reference="' + escapeText(value.id) + '" data-db-reference-type="' + escapeText(value.type) + '" data-db-reference-database="' + escapeText(value.databaseId || '') + '">' + iconHtml(value.type === 'text' ? 'file-text' : 'link') + escapeText(label) + '</button>'; }
+  return escapeText(value);
+}
+function query(key, databaseId, append, cursorValue) { var state = databaseState(key, databaseId); var viewId = state.selectedViewId || state.database && state.database.views[0] && state.database.views[0].id || null; var epoch = (state.queryEpoch || 0) + 1; patchDatabase(key, databaseId, { loading: true, queryEpoch: epoch, error: state.syncPending ? state.error : '' }); var sent = send(key, 'knowledge_db_query', { databaseId: databaseId, viewId: viewId, cursor: cursorValue || null, limit: 50, archived: state.showArchived === true }, { databaseId: databaseId, append: append === true, queryEpoch: epoch, viewId: viewId, archived: state.showArchived === true }); if (!sent) patchDatabase(key, databaseId, { loading: false, error: 'Reconnect to query this database.' }); }
+
+export function configureKnowledgeDbWorkbench(callback) { renderOwner = typeof callback === 'function' ? callback : callback.render; openOwnerDocument = callback.openDocument || null; identityOwner = callback.documentIdentity || null; }
+export function openKnowledgeDatabase(file) {
+  var key = workspaceKey(); patchDatabase(key, file.id, { loading: true, error: '' });
+  if (!send(key, 'knowledge_db_read', { databaseId: file.id }, { databaseId: file.id })) patchDatabase(key, file.id, { loading: false, error: 'Reconnect to open this database.' });
+}
+export function showKnowledgeCreateMenu(panel) {
+  var existing = panel.querySelector('.knowledge-create-menu'); if (existing) { existing.remove(); return; }
+  var menu = document.createElement('div'); menu.className = 'knowledge-create-menu'; menu.setAttribute('role', 'menu'); menu.innerHTML = '<button type="button" role="menuitem" data-db-create-document>' + iconHtml('file-plus-2') + '<span>New document<small>Markdown text</small></span></button><button type="button" role="menuitem" data-db-create-database>' + iconHtml('database') + '<span>New database<small>Typed table</small></span></button>';
+  panel.querySelector('.knowledge-topbar').appendChild(menu); refreshIcons(menu); menu.querySelector('button').focus();
+}
+export function beginKnowledgeDatabaseCreate(panel) {
+  var key = workspaceKey(); var owner = ownerToken(key); var existing = stateFor(key).createDraft; patchState(key, { createDraft: Object.assign({}, existing || { name: '', saving: false, error: '', operationId: operationId('create') }, owner), error: '' }); patchMain(key, { fullscreen: true }); if (renderOwner) renderOwner({ forceDocument: true });
+  setTimeout(function () { var input = panel.querySelector('[data-db-new-name]'); if (input) input.focus(); }, 0);
+}
+export function beginKnowledgeDatabaseRecovery(panel, item) {
+  var key = workspaceKey(); var owner = ownerToken(key); patchState(key, { recoveryDraft: { item: item, operationId: operationId('recover-database'), saving: false, error: '', ownerSelection: owner.ownerSelection, ownerSelectionVersion: owner.ownerSelectionVersion } }); patchMain(key, { fullscreen: true }); if (renderOwner) renderOwner({ forceDocument: true });
+}
+function submitCreate(panel) {
+  var key = workspaceKey(); var draft = stateFor(key).createDraft; var input = panel.querySelector('[data-db-new-name]'); var name = input && input.value.trim(); if (!name) { patchState(key, { createDraft: Object.assign({}, draft, { name: '', saving: false, error: 'Enter a database name.' }) }); if (renderOwner) renderOwner({ forceDocument: true }); return; }
+  var attempt = buildCreateAttempt(draft, name); draft = Object.assign({}, draft, { name: draft.attempt ? draft.name : name, saving: true, retryPending: false, attempt: attempt, error: '' }); patchState(key, { createDraft: draft }); var sent = send(key, 'knowledge_db_create', { name: attempt.name, operationId: attempt.operationId }, Object.assign({ create: true, createOperationId: attempt.operationId }, ownerToken(key))); if (!sent) { patchState(key, { createDraft: Object.assign({}, draft, { saving: false, retryPending: true, error: 'Reconnect to create this database.' }) }); if (renderOwner) renderOwner({ forceDocument: true }); return; } input.disabled = true; var button = panel.querySelector('[data-db-create-submit]'); if (button) button.textContent = 'Retry create';
+}
+function selectedRecordState(key, databaseId) { var dbState = databaseState(key, databaseId); return dbState.recordDetail && dbState.recordDetail.record && dbState.recordDetail.record.id === dbState.selectedRecord ? dbState.recordDetail : null; }
+function openRecord(databaseId, recordId, keyValue) { var key = keyValue || workspaceKey(); var state = databaseState(key, databaseId); var generation = (state.recordGeneration || 0) + 1; var drafts = Object.assign({}, state.recordDrafts || {}); if (isRecordEdit(state.edit) && state.edit.recordId) drafts[state.edit.recordId] = state.edit; patchDatabase(key, databaseId, { selectedRecord: recordId, recordDetail: null, recordGeneration: generation, recordDrafts: drafts, edit: drafts[recordId] || null }); if (!send(key, 'knowledge_db_record_read', { databaseId: databaseId, recordId: recordId }, { databaseId: databaseId, recordId: recordId, recordGeneration: generation })) patchDatabase(key, databaseId, { error: 'Reconnect to open this record.' }); }
+function beginRecordEdit(databaseId, creating) {
+  var key = workspaceKey(); var state = databaseState(key, databaseId); var detail = selectedRecordState(key, databaseId); var recordId = creating ? null : detail.record.id; var saved = !creating && (state.recordDrafts || {})[recordId]; var generation = (state.editGeneration || 0) + 1; var edit = saved || { id: generation, creating: creating === true, recordId: recordId, values: creating ? {} : Object.assign({}, detail.record.values), baseVersion: detail && detail.record.revision || null, version: 0, saving: false, retryPending: false, attempt: null, operationId: operationId('record'), error: '' }; patchDatabase(key, databaseId, { editGeneration: generation, edit: Object.assign({}, edit, { id: generation }) }); patchMain(key, { fullscreen: true }); if (renderOwner) renderOwner({ forceDocument: true });
+}
+function inputValue(input, field) {
+  if (field.type === 'boolean') return input.checked;
+  if (field.type === 'number') return input.value === '' ? null : Number(input.value);
+  if (field.type === 'multi-select') return Array.prototype.filter.call(input.options, function (option) { return option.selected; }).map(function (option) { return option.value; });
+  if (field.type === 'reference') { if (!input.value.trim()) return null; var parts = input.value.trim().split(':'); return field.target === 'text' ? { type: 'text', id: input.value.trim() } : { type: 'record', databaseId: parts[0], id: parts.slice(1).join(':') }; }
+  return input.value === '' ? null : input.value;
+}
+function submitRecord(panel, databaseId) {
+  var key = workspaceKey(); var state = databaseState(key, databaseId); var values = {}; panel.querySelectorAll('[data-db-field]').forEach(function (input) { var field = fieldById(state.database, input.dataset.dbField); values[field.id] = inputValue(input, field); });
+  var attempt = buildRecordAttempt(state.edit, databaseId, state.database.revision, values); var savingEdit = Object.assign({}, state.edit, { values: values, saving: true, retryPending: false, attempt: attempt, error: '' }); patchDatabase(key, databaseId, { edit: savingEdit }); var tracking = Object.assign({ databaseId: databaseId, recordId: attempt.recordId, saveRecord: true, creating: attempt.creating, submittedVersion: attempt.submittedVersion, editId: state.edit.id, attempt: attempt }, ownerToken(key)); if (!send(key, attempt.type, attempt.payload, tracking)) { patchDatabase(key, databaseId, { edit: Object.assign({}, savingEdit, { saving: false, retryPending: true, error: 'Reconnect to save this record.' }) }); if (renderOwner) renderOwner({ forceDocument: true }); return; } var saveButton = panel.querySelector('[data-db-save-record]'); if (saveButton) saveButton.textContent = 'Retry save';
+}
+export function handleKnowledgeDbInput(event) {
+  var viewSelect = event.target.closest('[data-db-view-select]'); if (viewSelect) { var viewKey = workspaceKey(); patchDatabase(viewKey, viewSelect.dataset.dbViewSelect, { selectedViewId: viewSelect.value, records: [], nextCursor: null }); query(viewKey, viewSelect.dataset.dbViewSelect, false, null); return true; }
+  var newName = event.target.closest('[data-db-new-name]'); if (newName) { var createKey = workspaceKey(); var createDraft = stateFor(createKey).createDraft; if (createDraft && !createDraft.attempt) patchState(createKey, { createDraft: Object.assign({}, createDraft, { name: newName.value, error: '' }) }); return true; }
+  var settingsName = event.target.closest('[data-db-settings-name]'); if (settingsName) { var settingsKey = workspaceKey(); var settingsFile = selectedFile(settingsKey); var settingsState = databaseState(settingsKey, settingsFile.id); patchDatabase(settingsKey, settingsFile.id, { edit: Object.assign({}, settingsState.edit, { name: settingsName.value, error: '' }) }); return true; }
+  var schemaControl = event.target.closest('[data-db-schema-field] input, [data-db-schema-field] select'); if (schemaControl) { var schemaKey = workspaceKey(); var schemaFile = selectedFile(schemaKey); var schemaState = databaseState(schemaKey, schemaFile.id); var row = schemaControl.closest('[data-db-schema-field]'); var schemaFields = (schemaState.edit.schemaFields || schemaState.database.schema).map(function (field) { if (field.id !== row.dataset.dbSchemaField) return field; var next = Object.assign({}, field); if (schemaControl.matches('[data-schema-name]')) next.name = schemaControl.value; else if (schemaControl.matches('[data-schema-required]')) next.required = schemaControl.checked; else if (schemaControl.matches('[data-schema-archived]')) next.archived = schemaControl.checked; else if (schemaControl.matches('[data-schema-type]')) { next.type = schemaControl.value; if (next.type === 'select' || next.type === 'multi-select') next.options = next.options || []; if (next.type === 'reference') next.target = next.target || 'text'; } else if (schemaControl.matches('[data-schema-option-name]')) next.options = (field.options || []).map(function (option) { return option.id === schemaControl.dataset.optionId ? Object.assign({}, option, { name: schemaControl.value }) : option; }); else if (schemaControl.matches('[data-schema-option-archived]')) next.options = (field.options || []).map(function (option) { return option.id === schemaControl.dataset.optionId ? Object.assign({}, option, { archived: schemaControl.checked }) : option; }); else if (schemaControl.matches('[data-schema-reference-target]')) next.target = schemaControl.value; else if (schemaControl.matches('[data-schema-reference-db]')) { if (schemaControl.value.trim()) next.targetDatabaseId = schemaControl.value.trim(); else delete next.targetDatabaseId; } return next; }); patchDatabase(schemaKey, schemaFile.id, { edit: Object.assign({}, schemaState.edit, { schemaFields: schemaFields, error: '' }) }); if (schemaControl.matches('[data-schema-type]') && renderOwner) renderOwner({ forceDocument: true }); return true; }
+  var viewControl = event.target.closest('[data-view-name], [data-view-column], [data-view-filter-field], [data-view-filter-op], [data-view-filter-value], [data-view-sort-field], [data-view-sort-direction]'); if (viewControl) { var viewKeyValue = workspaceKey(); var viewFile = selectedFile(viewKeyValue); var viewDbState = databaseState(viewKeyValue, viewFile.id); var form = viewControl.closest('form'); var columns = Array.prototype.filter.call(form.querySelectorAll('[data-view-column]'), function (control) { return control.checked; }).map(function (control) { return control.value; }); var filterField = form.querySelector('[data-view-filter-field]').value; var filterOp = form.querySelector('[data-view-filter-op]').value; var filterInput = form.querySelector('[data-view-filter-value]'); var filterSchema = fieldById(viewDbState.database, filterField); var changingFilterShape = viewControl.matches('[data-view-filter-field]') || viewControl.matches('[data-view-filter-op]'); var filterValue = changingFilterShape ? null : typedFilterValue(filterSchema, filterInput, filterOp); var sortField = form.querySelector('[data-view-sort-field]').value; var draftView = updateViewPresentation(viewDbState.edit.view, { name: form.querySelector('[data-view-name]').value, columns: columns, filters: filterField ? [{ fieldId: filterField, op: filterOp, value: filterValue }] : [], sorts: sortField ? [{ fieldId: sortField, direction: form.querySelector('[data-view-sort-direction]').value }] : [] }); patchDatabase(viewKeyValue, viewFile.id, { edit: Object.assign({}, viewDbState.edit, { view: draftView, error: '' }) }); if (changingFilterShape && renderOwner) renderOwner({ forceDocument: true }); return true; }
+  var input = event.target.closest('[data-db-field]'); if (!input) return false; var key = workspaceKey(); var file = selectedFile(key); if (!file || file.itemType !== 'db') return false; var state = databaseState(key, file.id); if (!state.edit) return false; var field = fieldById(state.database, input.dataset.dbField); var values = Object.assign({}, state.edit.values); values[field.id] = inputValue(input, field); patchDatabase(key, file.id, { edit: Object.assign({}, state.edit, { values: values, version: (state.edit.version || 0) + 1, error: '' }) }); return true;
+}
+function submitSchema(panel, databaseId) {
+  var key = workspaceKey(); var state = databaseState(key, databaseId); var fields = JSON.parse(JSON.stringify(state.edit.schemaFields || state.database.schema));
+  var edit = Object.assign({}, state.edit, { schemaFields: fields, saving: true, error: '' }); patchDatabase(key, databaseId, { edit: edit }); if (!send(key, 'knowledge_db_schema_save', { databaseId: databaseId, schema: fields, expectedRevision: state.database.revision, operationId: edit.operationId }, Object.assign({ databaseId: databaseId, schemaSave: true, editId: edit.id }, ownerToken(key)))) patchDatabase(key, databaseId, { edit: Object.assign({}, edit, { saving: false, error: 'Reconnect to save the schema.' }) });
+}
+function typedFilterValue(field, input, op) {
+  if (op === 'empty' || op === 'not-empty') return null;
+  if (field.type === 'number') return input.value === '' ? null : Number(input.value);
+  if (field.type === 'boolean') return input.value === 'true';
+  if (field.type === 'multi-select' && op !== 'contains') return Array.prototype.filter.call(input.options, function (option) { return option.selected; }).map(function (option) { return option.value; });
+  if (field.type === 'reference') { var parts = input.value.split(':'); return field.target === 'text' ? { type: 'text', id: input.value } : { type: 'record', databaseId: parts[0], id: parts.slice(1).join(':') }; }
+  return input.value;
+}
+function submitView(panel, databaseId) {
+  var key = workspaceKey(); var state = databaseState(key, databaseId); var edit = state.edit;
+  var view = JSON.parse(JSON.stringify(edit.view)); view.name = view.name.trim(); var saving = Object.assign({}, edit, { view: view, saving: true, error: '' }); patchDatabase(key, databaseId, { edit: saving }); if (!send(key, 'knowledge_db_view_save', { databaseId: databaseId, view: view, expectedRevision: state.database.revision, operationId: edit.operationId }, Object.assign({ databaseId: databaseId, viewSave: true, viewId: view.id, editId: edit.id }, ownerToken(key)))) patchDatabase(key, databaseId, { edit: Object.assign({}, saving, { saving: false, error: 'Reconnect to save the view.' }) });
+}
+function archiveRecord(databaseId) { var key = workspaceKey(); var detail = selectedRecordState(key, databaseId); if (!detail) return; patchState(key, { dialog: Object.assign({ databaseId: databaseId, recordId: detail.record.id, revision: detail.record.revision, title: detail.title, operationId: operationId('archive-record') }, ownerToken(key)) }); if (renderOwner) renderOwner({ forceDocument: true }); }
+function confirmArchive() { var key = workspaceKey(); var dialog = stateFor(key).dialog; if (!dialog) return; var tracking = Object.assign({ databaseId: dialog.databaseId }, { ownerSelection: dialog.ownerSelection, ownerSelectionVersion: dialog.ownerSelectionVersion }); var sent = dialog.kind === 'database' ? send(key, 'knowledge_db_archive', { databaseId: dialog.databaseId, expectedRevision: dialog.revision, operationId: dialog.operationId }, Object.assign({}, tracking, { archiveDatabase: true })) : send(key, 'knowledge_db_record_archive', { databaseId: dialog.databaseId, recordId: dialog.recordId, expectedRevision: dialog.revision, operationId: dialog.operationId }, Object.assign({}, tracking, { recordId: dialog.recordId, archive: true })); if (!sent) { patchState(key, { dialog: Object.assign({}, dialog, { error: 'Reconnect to archive this item. Retry will use the same operation id.' }) }); if (renderOwner) renderOwner({ forceDocument: true }); return; } patchState(key, { dialog: null }); if (renderOwner) renderOwner({ forceDocument: true }); }
+function closeArchiveDialog(panel) { var dialog = stateFor(workspaceKey()).dialog; patchState(workspaceKey(), { dialog: null }); if (renderOwner) renderOwner({ forceDocument: true }); setTimeout(function () { var selector = dialog && dialog.kind === 'database' ? '[data-db-archive-database]' : '[data-db-archive-record]'; var button = panel.querySelector(selector); if (button) button.focus(); }, 0); }
+
+export function handleKnowledgeDbClick(event, panel) {
+  var createDocument = event.target.closest('[data-db-create-document]'); if (createDocument) { panel.querySelector('.knowledge-create-menu').remove(); return 'document'; }
+  if (event.target.closest('[data-db-create-database]')) { panel.querySelector('.knowledge-create-menu').remove(); beginKnowledgeDatabaseCreate(panel); return true; }
+  if (event.target.closest('[data-db-resume-create]')) { var resumeKey = workspaceKey(); var resumed = Object.assign({}, stateFor(resumeKey).createDraft, ownerToken(resumeKey)); patchState(resumeKey, { createDraft: resumed }); patchMain(resumeKey, { fullscreen: true }); if (renderOwner) renderOwner({ forceDocument: true }); return true; }
+  if (event.target.closest('[data-db-create-submit]')) { submitCreate(panel); return true; }
+  if (event.target.closest('[data-db-create-cancel]')) { patchState(workspaceKey(), { createDraft: null }); patchMain(workspaceKey(), { fullscreen: false }); if (renderOwner) renderOwner({ forceDocument: true }); return true; }
+  var reference = event.target.closest('[data-db-reference]'); if (reference) { var referenceKey = workspaceKey(); if (reference.dataset.dbReferenceType === 'text') { if (openOwnerDocument) openOwnerDocument('local:' + reference.dataset.dbReference); } else { var databaseIdentity = identityOwner ? identityOwner({ id: reference.dataset.dbReferenceDatabase, itemType: 'db', common: false }) : 'local:' + reference.dataset.dbReferenceDatabase; if (openOwnerDocument) openOwnerDocument(databaseIdentity); openRecord(reference.dataset.dbReferenceDatabase, reference.dataset.dbReference, referenceKey); } return true; }
+  var row = event.target.closest('[data-db-record]'); if (row) { openRecord(row.dataset.dbDatabase, row.dataset.dbRecord); return true; }
+  var edit = event.target.closest('[data-db-edit-record]'); if (edit) { beginRecordEdit(edit.dataset.dbEditRecord, false); return true; }
+  var add = event.target.closest('[data-db-add-record]'); if (add) { beginRecordEdit(add.dataset.dbAddRecord, true); return true; }
+  var save = event.target.closest('[data-db-save-record]'); if (save) { submitRecord(panel, save.dataset.dbSaveRecord); return true; }
+  if (event.target.closest('[data-db-cancel-edit]')) { var cancelKey = workspaceKey(); var file = selectedFile(cancelKey); var cancelState = databaseState(cancelKey, file.id); var cancelDrafts = Object.assign({}, cancelState.recordDrafts || {}); if (isRecordEdit(cancelState.edit) && cancelState.edit.recordId) delete cancelDrafts[cancelState.edit.recordId]; patchDatabase(cancelKey, file.id, { edit: null, recordDrafts: cancelDrafts }); patchMain(cancelKey, { fullscreen: false }); if (renderOwner) renderOwner({ forceDocument: true }); return true; }
+  var schema = event.target.closest('[data-db-edit-schema]'); if (schema) { var schemaKey = workspaceKey(); var schemaState = databaseState(schemaKey, schema.dataset.dbEditSchema); var schemaGeneration = (schemaState.editGeneration || 0) + 1; patchDatabase(schemaKey, schema.dataset.dbEditSchema, { editGeneration: schemaGeneration, edit: { id: schemaGeneration, schema: true, schemaFields: JSON.parse(JSON.stringify(schemaState.database.schema)), operationId: operationId('schema'), saving: false, error: '' } }); patchMain(schemaKey, { fullscreen: true }); if (renderOwner) renderOwner({ forceDocument: true }); return true; }
+  var settings = event.target.closest('[data-db-settings]'); if (settings) { var settingsKey = workspaceKey(); var settingsState = databaseState(settingsKey, settings.dataset.dbSettings); var settingsGeneration = (settingsState.editGeneration || 0) + 1; patchDatabase(settingsKey, settings.dataset.dbSettings, { editGeneration: settingsGeneration, edit: { id: settingsGeneration, settings: true, name: settingsState.database.name, operationId: operationId('rename-database'), saving: false, error: '' } }); patchMain(settingsKey, { fullscreen: true }); if (renderOwner) renderOwner({ forceDocument: true }); return true; }
+  var saveSettings = event.target.closest('[data-db-save-settings]'); if (saveSettings) { var saveSettingsKey = workspaceKey(); var saveSettingsState = databaseState(saveSettingsKey, saveSettings.dataset.dbSaveSettings); var databaseName = panel.querySelector('[data-db-settings-name]').value.trim(); var settingsEdit = Object.assign({}, saveSettingsState.edit, { name: databaseName, saving: true, error: '' }); patchDatabase(saveSettingsKey, saveSettings.dataset.dbSaveSettings, { edit: settingsEdit }); if (!send(saveSettingsKey, 'knowledge_db_rename', { databaseId: saveSettings.dataset.dbSaveSettings, name: databaseName, expectedRevision: saveSettingsState.database.revision, operationId: settingsEdit.operationId }, Object.assign({ databaseId: saveSettings.dataset.dbSaveSettings, editId: settingsEdit.id, renameDatabase: true }, ownerToken(saveSettingsKey)))) patchDatabase(saveSettingsKey, saveSettings.dataset.dbSaveSettings, { edit: Object.assign({}, settingsEdit, { saving: false, error: 'Reconnect to rename this database.' }) }); return true; }
+  var archiveDatabase = event.target.closest('[data-db-archive-database]'); if (archiveDatabase) { var archiveKey = workspaceKey(); var archiveState = databaseState(archiveKey, archiveDatabase.dataset.dbArchiveDatabase); patchState(archiveKey, { dialog: Object.assign({ kind: 'database', databaseId: archiveState.database.id, revision: archiveState.database.revision, title: archiveState.database.name, operationId: operationId('archive-database') }, ownerToken(archiveKey)) }); if (renderOwner) renderOwner({ forceDocument: true }); return true; }
+  var archivedRecords = event.target.closest('[data-db-archived-records]'); if (archivedRecords) { var archivedKey = workspaceKey(); var archivedId = archivedRecords.dataset.dbArchivedRecords; var archivedState = databaseState(archivedKey, archivedId); patchDatabase(archivedKey, archivedId, { showArchived: !archivedState.showArchived, records: [], selectedRecord: null, recordDetail: null }); query(archivedKey, archivedId, false, null); return true; }
+  var beginRecover = event.target.closest('[data-db-begin-recover-record]'); if (beginRecover) { var recoverKey = workspaceKey(); var recoverState = databaseState(recoverKey, beginRecover.dataset.dbBeginRecoverRecord); var recoverDetail = selectedRecordState(recoverKey, recoverState.database.id); var recoverGeneration = (recoverState.editGeneration || 0) + 1; patchDatabase(recoverKey, recoverState.database.id, { editGeneration: recoverGeneration, edit: { id: recoverGeneration, recover: true, recordId: recoverDetail.record.id, baseVersion: recoverDetail.record.revision, operationId: operationId('recover-record'), saving: false, error: '' } }); patchMain(recoverKey, { fullscreen: true }); if (renderOwner) renderOwner({ forceDocument: true }); return true; }
+  var confirmRecover = event.target.closest('[data-db-confirm-recover-record]'); if (confirmRecover) { var confirmKey = workspaceKey(); var confirmState = databaseState(confirmKey, confirmRecover.dataset.dbConfirmRecoverRecord); var recoverEdit = Object.assign({}, confirmState.edit, { saving: true }); patchDatabase(confirmKey, confirmState.database.id, { edit: recoverEdit }); if (!send(confirmKey, 'knowledge_db_record_recover', { databaseId: confirmState.database.id, recordId: recoverEdit.recordId, expectedRevision: recoverEdit.baseVersion, operationId: recoverEdit.operationId }, Object.assign({ databaseId: confirmState.database.id, recordId: recoverEdit.recordId, editId: recoverEdit.id, recoverRecord: true }, ownerToken(confirmKey)))) patchDatabase(confirmKey, confirmState.database.id, { edit: Object.assign({}, recoverEdit, { saving: false, error: 'Reconnect to recover this record.' }) }); return true; }
+  var addField = event.target.closest('[data-db-add-field]'); if (addField) { var addState = databaseState(workspaceKey(), addField.dataset.dbAddField); var fields = (addState.edit.schemaFields || addState.database.schema).concat([{ id: 'fld_ui_' + Date.now(), name: 'New field', type: 'text', required: false, archived: false }]); patchDatabase(workspaceKey(), addState.database.id, { edit: Object.assign({}, addState.edit, { schema: true, schemaFields: fields }) }); if (renderOwner) renderOwner({ forceDocument: true }); return true; }
+  var addOption = event.target.closest('[data-db-add-option]'); if (addOption) { var optionKey = workspaceKey(); var optionFile = selectedFile(optionKey); var optionState = databaseState(optionKey, optionFile.id); var optionFields = (optionState.edit.schemaFields || optionState.database.schema).map(function (field) { if (field.id !== addOption.dataset.dbAddOption) return field; return Object.assign({}, field, { options: (field.options || []).concat([{ id: 'opt_ui_' + Date.now() + '_' + (++requestCounter), name: 'New option', archived: false }]) }); }); patchDatabase(optionKey, optionFile.id, { edit: Object.assign({}, optionState.edit, { schemaFields: optionFields }) }); if (renderOwner) renderOwner({ forceDocument: true }); return true; }
+  var schemaSave = event.target.closest('[data-db-save-schema]'); if (schemaSave) { submitSchema(panel, schemaSave.dataset.dbSaveSchema); return true; }
+  var views = event.target.closest('[data-db-edit-views]'); if (views) { var viewKey = workspaceKey(); var viewState = databaseState(viewKey, views.dataset.dbEditViews); var selected = viewState.database.views.filter(function (view) { return view.id === (viewState.selectedViewId || viewState.database.views[0].id); })[0] || viewState.database.views[0]; var viewGeneration = (viewState.editGeneration || 0) + 1; patchDatabase(viewKey, viewState.database.id, { editGeneration: viewGeneration, edit: { id: viewGeneration, view: JSON.parse(JSON.stringify(selected)), operationId: operationId('view'), saving: false, error: '' } }); patchMain(viewKey, { fullscreen: true }); if (renderOwner) renderOwner({ forceDocument: true }); return true; }
+  var newView = event.target.closest('[data-db-new-view]'); if (newView) { var newViewKey = workspaceKey(); var newViewState = databaseState(newViewKey, newView.dataset.dbNewView); var newGeneration = (newViewState.editGeneration || 0) + 1; patchDatabase(newViewKey, newViewState.database.id, { editGeneration: newGeneration, edit: { id: newGeneration, operationId: operationId('view'), saving: false, error: '', view: { id: 'view_ui_' + Date.now(), name: 'New view', columns: newViewState.database.schema.filter(function (field) { return !field.archived; }).map(function (field) { return field.id; }), filters: [], sorts: [] } } }); if (renderOwner) renderOwner({ forceDocument: true }); return true; }
+  var saveView = event.target.closest('[data-db-save-view]'); if (saveView) { submitView(panel, saveView.dataset.dbSaveView); return true; }
+  var archive = event.target.closest('[data-db-archive-record]'); if (archive) { archiveRecord(archive.dataset.dbArchiveRecord); return true; }
+  if (event.target.closest('[data-db-dialog-cancel]')) { closeArchiveDialog(panel); return true; }
+  if (event.target.closest('[data-db-dialog-confirm]')) { confirmArchive(); return true; }
+  var sync = event.target.closest('[data-db-sync]'); if (sync) { var syncId = sync.dataset.dbSync; patchDatabase(workspaceKey(), syncId, { error: '', syncPending: true }); send(workspaceKey(), 'knowledge_db_sync', { databaseId: syncId }, { databaseId: syncId, sync: true }); return true; }
+  var more = event.target.closest('[data-db-more]'); if (more) { var moreKey = workspaceKey(); var state = databaseState(moreKey, more.dataset.dbMore); query(moreKey, more.dataset.dbMore, true, state.nextCursor); return true; }
+  var back = event.target.closest('[data-db-record-back]'); if (back) { patchDatabase(workspaceKey(), back.dataset.dbRecordBack, { selectedRecord: null, recordDetail: null, edit: null }); if (renderOwner) renderOwner({ forceDocument: true }); return true; }
+  if (event.target.closest('[data-db-cancel-recover-database]')) { patchState(workspaceKey(), { recoveryDraft: null }); patchMain(workspaceKey(), { fullscreen: false }); if (renderOwner) renderOwner({ forceDocument: true }); return true; }
+  if (event.target.closest('[data-db-confirm-recover-database]')) { var recoveryKey = workspaceKey(); var recovery = stateFor(recoveryKey).recoveryDraft; if (!recovery) return true; recovery = Object.assign({}, recovery, { saving: true, error: '' }); patchState(recoveryKey, { recoveryDraft: recovery }); var recoveryTrack = Object.assign({ databaseId: recovery.item.id, recoverDatabase: true, recoveryOperationId: recovery.operationId }, ownerToken(recoveryKey)); if (!send(recoveryKey, 'knowledge_db_recover', { databaseId: recovery.item.id, expectedRevision: recovery.item.revision, operationId: recovery.operationId }, recoveryTrack)) { patchState(recoveryKey, { recoveryDraft: Object.assign({}, recovery, { saving: false, error: 'Reconnect to recover this database.' }) }); if (renderOwner) renderOwner({ forceDocument: true }); } return true; }
+  return false;
+}
+
+export function handleKnowledgeDbKeydown(event, panel) {
+  var keyboardRow = event.target.closest && event.target.closest('[data-db-record]'); if (keyboardRow && (event.key === 'Enter' || event.key === ' ')) { event.preventDefault(); openRecord(keyboardRow.dataset.dbDatabase, keyboardRow.dataset.dbRecord); return true; }
+  var dialog = panel && panel.querySelector('.knowledge-db-dialog'); if (!dialog) return false;
+  if (event.key === 'Escape') { event.preventDefault(); closeArchiveDialog(panel); return true; }
+  if (event.key !== 'Tab') return false; var controls = dialog.querySelectorAll('button:not(:disabled)'); if (!controls.length) return false; var first = controls[0]; var last = controls[controls.length - 1];
+  if (event.shiftKey && document.activeElement === first) { event.preventDefault(); last.focus(); return true; } if (!event.shiftKey && document.activeElement === last) { event.preventDefault(); first.focus(); return true; } return false;
+}
+
+function fieldInput(field, value) {
+  var attrs = ' data-db-field="' + escapeText(field.id) + '"' + (field.required ? ' required' : '');
+  if (field.type === 'boolean') return '<input type="checkbox"' + attrs + (value === true ? ' checked' : '') + '>';
+  if (field.type === 'select' || field.type === 'multi-select') return '<select' + attrs + (field.type === 'multi-select' ? ' multiple' : '') + '><option value="">—</option>' + (field.options || []).filter(function (option) { return !option.archived; }).map(function (option) { var selected = field.type === 'multi-select' ? Array.isArray(value) && value.indexOf(option.id) !== -1 : value === option.id; return '<option value="' + escapeText(option.id) + '"' + (selected ? ' selected' : '') + '>' + escapeText(option.name) + '</option>'; }).join('') + '</select>';
+  var type = field.type === 'number' ? 'number' : field.type === 'date' ? 'date' : 'text'; var shown = field.type === 'reference' && value ? (value.databaseId ? value.databaseId + ':' : '') + value.id : value == null ? '' : value;
+  return '<input type="' + type + '"' + attrs + ' value="' + escapeText(shown) + '"' + (field.type === 'number' ? ' step="any"' : '') + '>';
+}
+function renderCreate(body, toolbar, state) { var pendingCreate = !!state.createDraft.attempt; toolbar.innerHTML = '<span class="knowledge-preview-name">New database</span><button type="button" data-db-create-cancel>Cancel</button><button type="button" class="primary" data-db-create-submit>' + (pendingCreate ? 'Retry create' : 'Create') + '</button>'; body.innerHTML = '<form class="knowledge-db-form" onsubmit="return false"><h2>Create database</h2><label>Name<input data-db-new-name value="' + escapeText(state.createDraft.name) + '" maxlength="120" autocomplete="off"' + (pendingCreate ? ' disabled' : '') + '></label>' + (state.createDraft.error ? '<p class="knowledge-inline-error">' + escapeText(state.createDraft.error) + '</p>' : '') + '<p>' + (pendingCreate ? 'This name is fixed for the pending operation. Retry uses the same request.' : 'A required title field and Table view will be created. You can refine the schema after creation.') + '</p></form>'; }
+function renderCreatePaused(body, toolbar, state) { toolbar.innerHTML = '<span class="knowledge-preview-name">Database draft</span><button type="button" class="primary" data-db-resume-create>Resume fullscreen</button>'; body.innerHTML = '<div class="knowledge-db-form"><h2>Database draft saved</h2><p>' + (state.createDraft.name ? escapeText(state.createDraft.name) : 'Untitled database') + ' remains available. Resume fullscreen to create it.</p></div>'; }
+function renderDatabaseRecovery(body, toolbar, draft) { toolbar.innerHTML = '<span class="knowledge-preview-name">Recover database</span><button type="button" data-db-cancel-recover-database>Cancel</button><button type="button" class="primary" data-db-confirm-recover-database>' + (draft.saving ? 'Retry recovery' : 'Recover') + '</button>'; body.innerHTML = '<div class="knowledge-db-form"><h2>Recover ' + escapeText(draft.item.name) + '?</h2><p>Review this mutation in fullscreen. Its schema, records, views, and history will return to this Mate’s Knowledge.</p>' + (draft.error ? '<p class="knowledge-inline-error">' + escapeText(draft.error) + '</p>' : '') + '</div>'; }
+function renderTable(body, dbState) {
+  var database = dbState.database; var view = database.views.filter(function (item) { return item.id === dbState.selectedViewId; })[0] || database.views[0] || { columns: database.schema.filter(function (field) { return !field.archived; }).map(function (field) { return field.id; }) }; var fields = view.columns.map(function (id) { return fieldById(database, id); }).filter(Boolean);
+  var html = '<div class="knowledge-db-table-wrap"><table class="knowledge-db-table"><thead><tr>' + fields.map(function (field) { return '<th scope="col">' + escapeText(field.name) + '</th>'; }).join('') + '</tr></thead><tbody>';
+  html += dbState.records.map(function (record) { return '<tr tabindex="0" data-db-record="' + escapeText(record.id) + '" data-db-database="' + escapeText(database.id) + '">' + fields.map(function (field) { return '<td>' + displayValue(field, record.values[field.id], record.references) + '</td>'; }).join('') + '</tr>'; }).join('');
+  html += '</tbody></table>' + (!dbState.records.length && !dbState.loading ? '<p class="knowledge-empty">No records in this view.</p>' : '') + (dbState.nextCursor ? '<button type="button" class="knowledge-search-more" data-db-more="' + escapeText(database.id) + '">Load more</button>' : '') + '</div>'; body.innerHTML = html;
+}
+function renderRecord(body, dbState) { var detail = selectedRecordState(workspaceKey(), dbState.database.id); if (!detail) { body.innerHTML = '<p class="knowledge-empty">Loading record…</p>'; return; } var history = (detail.history || []).map(function (entry) { return '<li><b>' + escapeText(entry.action || 'update') + '</b><span>Revision ' + escapeText(entry.revision) + ' · ' + new Date(entry.at).toLocaleString() + '</span></li>'; }).join(''); body.innerHTML = '<article class="knowledge-db-record"><button type="button" data-db-record-back="' + escapeText(dbState.database.id) + '">' + iconHtml('arrow-left') + 'Table</button><h2>' + escapeText(detail.title) + '</h2><dl>' + dbState.database.schema.filter(function (field) { return !field.archived; }).map(function (field) { return '<dt>' + escapeText(field.name) + '</dt><dd>' + displayValue(field, detail.record.values[field.id], detail.record.references) + '</dd>'; }).join('') + '</dl><p class="knowledge-db-attribution">Revision ' + detail.record.revision + ' · updated ' + new Date(detail.record.updatedAt).toLocaleString() + '</p>' + (history ? '<h3>Recent history</h3><ol class="knowledge-db-history">' + history + '</ol>' : '') + '</article>'; }
+function renderRecordForm(body, toolbar, dbState) { var edit = dbState.edit; var values = edit.values || {}; toolbar.innerHTML = '<span class="knowledge-preview-name">' + (edit.creating ? 'New record' : 'Edit record') + '</span>' + (!edit.creating ? '<button type="button" class="danger" data-db-archive-record="' + escapeText(dbState.database.id) + '">Archive</button>' : '') + '<button type="button" data-db-cancel-edit>Cancel</button><button type="button" class="primary" data-db-save-record="' + escapeText(dbState.database.id) + '">' + (edit.saving ? 'Retry save' : 'Save') + '</button>'; body.innerHTML = '<form class="knowledge-db-form" onsubmit="return false"><h2>' + (edit.creating ? 'New record' : 'Edit record') + '</h2>' + dbState.database.schema.filter(function (field) { return !field.archived; }).map(function (field) { return '<label>' + escapeText(field.name) + fieldInput(field, values[field.id]) + '</label>'; }).join('') + (edit.error ? '<p class="knowledge-inline-error">' + escapeText(edit.error) + '</p>' : '') + '</form>'; }
+function renderSettings(body, toolbar, dbState) { var edit = dbState.edit; toolbar.innerHTML = '<span class="knowledge-preview-name">Database settings</span><button type="button" data-db-cancel-edit>Cancel</button><button type="button" class="primary" data-db-save-settings="' + escapeText(dbState.database.id) + '">' + (edit.saving ? 'Retry rename' : 'Save name') + '</button>'; body.innerHTML = '<form class="knowledge-db-form" onsubmit="return false"><h2>Database settings</h2><label>Name<input data-db-settings-name value="' + escapeText(edit.name) + '" maxlength="120"></label>' + (edit.error ? '<p class="knowledge-inline-error">' + escapeText(edit.error) + '</p>' : '') + '<section class="knowledge-danger-zone"><h3>Archive database</h3><p>Records, schema, views, and history remain recoverable.</p><button type="button" class="danger" data-db-archive-database="' + escapeText(dbState.database.id) + '">Archive database</button></section></form>'; }
+function renderRecover(body, toolbar, dbState) { var edit = dbState.edit; toolbar.innerHTML = '<span class="knowledge-preview-name">Recover record</span><button type="button" data-db-cancel-edit>Cancel</button><button type="button" class="primary" data-db-confirm-recover-record="' + escapeText(dbState.database.id) + '">' + (edit.saving ? 'Retry recovery' : 'Recover') + '</button>'; body.innerHTML = '<div class="knowledge-db-form"><h2>Recover archived record?</h2><p>This restores the exact record at revision ' + escapeText(edit.baseVersion) + '.</p>' + (edit.error ? '<p class="knowledge-inline-error">' + escapeText(edit.error) + '</p>' : '') + '</div>'; }
+function optionEditor(field) { return '<fieldset class="knowledge-db-options"><legend>Options</legend>' + (field.options || []).map(function (option) { return '<div class="knowledge-db-option"><input aria-label="Option name" data-schema-option-name data-option-id="' + escapeText(option.id) + '" value="' + escapeText(option.name) + '"><label class="knowledge-db-check"><input type="checkbox" data-schema-option-archived data-option-id="' + escapeText(option.id) + '"' + (option.archived ? ' checked' : '') + '>Archived</label></div>'; }).join('') + '<button type="button" data-db-add-option="' + escapeText(field.id) + '">' + iconHtml('plus') + 'Add option</button></fieldset>'; }
+function renderSchema(body, toolbar, dbState) { var fields = dbState.edit.schemaFields || dbState.database.schema; toolbar.innerHTML = '<span class="knowledge-preview-name">Edit schema</span><button type="button" data-db-add-field="' + escapeText(dbState.database.id) + '">' + iconHtml('plus') + 'Add field</button><button type="button" data-db-cancel-edit>Cancel</button><button type="button" class="primary" data-db-save-schema="' + escapeText(dbState.database.id) + '">Save schema</button>'; body.innerHTML = '<form class="knowledge-db-form knowledge-db-schema" onsubmit="return false"><h2>Schema</h2><p>Field and option ids stay stable. Archive populated fields and options instead of removing them.</p>' + fields.map(function (field) { var existing = !!fieldById(dbState.database, field.id); return '<fieldset data-db-schema-field="' + escapeText(field.id) + '"><label>Name<input data-schema-name value="' + escapeText(field.name) + '"></label><label>Type<select data-schema-type' + (existing ? ' disabled' : '') + '>' + ['title','text','number','boolean','date','select','multi-select','reference'].map(function (type) { return '<option' + (field.type === type ? ' selected' : '') + '>' + type + '</option>'; }).join('') + '</select></label>' + (field.type === 'select' || field.type === 'multi-select' ? optionEditor(field) : '') + (field.type === 'reference' ? '<label>Target<select data-schema-reference-target><option value="text"' + (field.target === 'text' ? ' selected' : '') + '>Text item</option><option value="record"' + (field.target === 'record' ? ' selected' : '') + '>Database record</option></select></label><label>Target database id<input data-schema-reference-db value="' + escapeText(field.targetDatabaseId || '') + '"></label>' : '') + '<label class="knowledge-db-check"><input type="checkbox" data-schema-required' + (field.required ? ' checked' : '') + '>Required</label><label class="knowledge-db-check"><input type="checkbox" data-schema-archived' + (field.archived ? ' checked' : '') + (field.type === 'title' ? ' disabled' : '') + '>Archived</label></fieldset>'; }).join('') + '</form>'; }
+function filterControl(field, filter) { var value = filter.value; if (!field) return '<input data-view-filter-value value="">'; if (field.type === 'boolean') return '<select data-view-filter-value><option value="true"' + (value === true ? ' selected' : '') + '>True</option><option value="false"' + (value === false ? ' selected' : '') + '>False</option></select>'; if (field.type === 'select' || field.type === 'multi-select') { var multiple = field.type === 'multi-select' && filter.op !== 'contains'; return '<select data-view-filter-value' + (multiple ? ' multiple' : '') + '>' + (field.options || []).filter(function (option) { return !option.archived; }).map(function (option) { var selected = multiple ? Array.isArray(value) && value.indexOf(option.id) !== -1 : value === option.id; return '<option value="' + escapeText(option.id) + '"' + (selected ? ' selected' : '') + '>' + escapeText(option.name) + '</option>'; }).join('') + '</select>'; } var type = field.type === 'number' ? 'number' : field.type === 'date' ? 'date' : 'text'; var shown = field.type === 'reference' && value ? (value.databaseId ? value.databaseId + ':' : '') + value.id : value == null ? '' : value; return '<input type="' + type + '" data-view-filter-value value="' + escapeText(shown) + '"' + (type === 'number' ? ' step="any"' : '') + '>'; }
+function renderView(body, toolbar, dbState) {
+  var view = dbState.edit.view; var filter = view.filters[0] || {}; var sort = view.sorts[0] || {}; var fields = dbState.database.schema.filter(function (field) { return !field.archived; }); var filterField = fieldById(dbState.database, filter.fieldId); var complex = view.filters.length > 1 || view.sorts.length > 1; var disabled = complex ? ' disabled' : '';
+  toolbar.innerHTML = '<span class="knowledge-preview-name">Edit Table view</span><button type="button" data-db-new-view="' + escapeText(dbState.database.id) + '">New view</button><button type="button" data-db-cancel-edit>Cancel</button><button type="button" class="primary" data-db-save-view="' + escapeText(dbState.database.id) + '">Save view</button>';
+  body.innerHTML = '<form class="knowledge-db-form" onsubmit="return false"><h2>Table view</h2>' + (complex ? '<p>All existing filters and sorts will be preserved in order. Their controls are locked in this compact editor; the name and columns remain editable.</p>' : '') + (dbState.edit.error ? '<p class="knowledge-inline-error">' + escapeText(dbState.edit.error) + '</p>' : '') + '<label>Name<input data-view-name value="' + escapeText(view.name) + '"></label><fieldset><legend>Columns</legend>' + fields.map(function (field) { return '<label class="knowledge-db-check"><input type="checkbox" data-view-column value="' + escapeText(field.id) + '"' + (view.columns.indexOf(field.id) !== -1 ? ' checked' : '') + '>' + escapeText(field.name) + '</label>'; }).join('') + '</fieldset><label>Filter field<select data-view-filter-field' + disabled + '><option value="">No filter</option>' + fields.map(function (field) { return '<option value="' + escapeText(field.id) + '"' + (filter.fieldId === field.id ? ' selected' : '') + '>' + escapeText(field.name) + '</option>'; }).join('') + '</select></label><label>Filter operator<select data-view-filter-op' + disabled + '>' + ['eq','neq','contains','gt','gte','lt','lte','empty','not-empty'].map(function (op) { return '<option' + (filter.op === op ? ' selected' : '') + '>' + op + '</option>'; }).join('') + '</select></label><label>Filter value<span class="knowledge-db-filter-control">' + filterControl(filterField, filter).replace(/^(<[^ >]+)/, '$1' + disabled) + '</span></label><label>Sort field<select data-view-sort-field' + disabled + '><option value="">No sort</option>' + fields.map(function (field) { return '<option value="' + escapeText(field.id) + '"' + (sort.fieldId === field.id ? ' selected' : '') + '>' + escapeText(field.name) + '</option>'; }).join('') + '</select></label><label>Direction<select data-view-sort-direction' + disabled + '><option value="asc"' + (sort.direction !== 'desc' ? ' selected' : '') + '>Ascending</option><option value="desc"' + (sort.direction === 'desc' ? ' selected' : '') + '>Descending</option></select></label></form>';
+}
+
+export function renderKnowledgeDatabase(panel) {
+  var staleDialog = panel.querySelector('.knowledge-db-dialog'); if (staleDialog) { setDialogBackground(panel, false); staleDialog.remove(); }
+  var key = workspaceKey(); var outer = stateFor(key); var body = panel.querySelector('.knowledge-document-body'); var toolbar = panel.querySelector('.knowledge-document-toolbar'); var main = mainState(key); if (outer.createDraft) { var createContext = main && main.selected === outer.createDraft.ownerSelection && (main.selectionVersion || 0) === outer.createDraft.ownerSelectionVersion; if (createContext) { if (main.fullscreen) renderCreate(body, toolbar, outer); else renderCreatePaused(body, toolbar, outer); return true; } } if (outer.recoveryDraft) { var recoveryOwns = main && main.fullscreen && main.selected === outer.recoveryDraft.ownerSelection && (main.selectionVersion || 0) === outer.recoveryDraft.ownerSelectionVersion; if (recoveryOwns) { renderDatabaseRecovery(body, toolbar, outer.recoveryDraft); return true; } }
+  var file = selectedFile(key); if (!file || file.itemType !== 'db') return false; var dbState = databaseState(key, file.id); var database = dbState.database; var mayEdit = !!(main && main.fullscreen && file.writable !== false);
+  panel.querySelector('.knowledge-details').hidden = true; if (!database) { toolbar.innerHTML = '<span class="knowledge-preview-name">' + escapeText(file.name) + '</span>'; body.innerHTML = '<p class="knowledge-empty">Loading database…</p>'; return true; }
+  if (mayEdit && dbState.edit && dbState.edit.schema) renderSchema(body, toolbar, dbState); else if (mayEdit && dbState.edit && dbState.edit.view) renderView(body, toolbar, dbState); else if (mayEdit && dbState.edit && dbState.edit.settings) renderSettings(body, toolbar, dbState); else if (mayEdit && dbState.edit && dbState.edit.recover) renderRecover(body, toolbar, dbState); else if (mayEdit && dbState.edit) renderRecordForm(body, toolbar, dbState); else {
+    var mutationTools = file.writable === false ? '' : '<button type="button" data-db-edit-views="' + escapeText(database.id) + '">Views</button><button type="button" data-db-add-record="' + escapeText(database.id) + '">' + iconHtml('plus') + 'New record</button><button type="button" data-db-edit-schema="' + escapeText(database.id) + '">' + iconHtml('settings-2') + 'Schema</button><button type="button" data-db-settings="' + escapeText(database.id) + '">Settings</button>';
+    toolbar.innerHTML = '<span class="knowledge-preview-name">' + escapeText(database.name) + '</span><select class="knowledge-db-view-select" data-db-view-select="' + escapeText(database.id) + '" aria-label="Table view">' + database.views.map(function (view) { return '<option value="' + escapeText(view.id) + '"' + ((dbState.selectedViewId || database.views[0].id) === view.id ? ' selected' : '') + '>' + escapeText(view.name) + '</option>'; }).join('') + '</select><span class="knowledge-readonly">' + (dbState.totals ? dbState.totals.count : database.recordCount) + ' records</span>' + mutationTools;
+    toolbar.innerHTML += '<button type="button" data-db-archived-records="' + escapeText(database.id) + '">' + (dbState.showArchived ? 'Active records' : 'Archived records') + '</button>';
+    if (dbState.selectedRecord && selectedRecordState(key, database.id)) { if (file.writable !== false) toolbar.innerHTML += dbState.recordDetail && dbState.recordDetail.record.archivedAt ? '<button type="button" data-db-begin-recover-record="' + escapeText(database.id) + '">Recover fullscreen</button>' : '<button type="button" data-db-edit-record="' + escapeText(database.id) + '">' + iconHtml('pencil') + 'Edit fullscreen</button>'; renderRecord(body, dbState); } else renderTable(body, dbState);
+  }
+  if (dbState.error) body.insertAdjacentHTML('afterbegin', '<p class="knowledge-inline-error">' + escapeText(dbState.error) + (dbState.syncPending ? ' <button type="button" data-db-sync="' + escapeText(database.id) + '">Retry sync</button>' : '') + '</p>');
+  if (outer.dialog) { var dialog = document.createElement('div'); dialog.className = 'knowledge-db-dialog'; dialog.setAttribute('role', 'dialog'); dialog.setAttribute('aria-modal', 'true'); dialog.innerHTML = '<div><h2>Archive this ' + (outer.dialog.kind === 'database' ? 'database' : 'record') + '?</h2><p>' + escapeText(outer.dialog.title || 'This item') + ' can be recovered later.</p>' + (outer.dialog.error ? '<p class="knowledge-inline-error">' + escapeText(outer.dialog.error) + '</p>' : '') + '<div><button type="button" data-db-dialog-cancel>Cancel</button><button type="button" class="danger" data-db-dialog-confirm>Archive</button></div></div>'; panel.appendChild(dialog); setDialogBackground(panel, true); dialog.querySelector('[data-db-dialog-cancel]').focus(); }
+  refreshIcons(panel); return true;
+}
+
+export function handleKnowledgeDbMessage(msg) {
+  var tracked = msg.requestId && pending[msg.requestId]; if (!tracked) return false; delete pending[msg.requestId]; var key = tracked.key; if (tracked.socket !== getWs()) return true; var dbId = tracked.databaseId; var state = dbId ? databaseState(key, dbId) : null; var currentWorkspace = key === workspaceKey(); var preserveActiveForm = false; var forceDocument = true;
+  if (msg.type === 'knowledge_db_created') {
+    var database = msg.database; var currentCreate = stateFor(key).createDraft; var knownDatabase = !!(stateFor(key).databases[database.id] && stateFor(key).databases[database.id].database); var matchesCreation = !!(currentCreate && currentCreate.attempt && currentCreate.attempt.operationId === tracked.createOperationId); var ownsCreation = matchesCreation && stillOwns(key, tracked); forceDocument = ownsCreation; preserveActiveForm = !matchesCreation;
+    if (matchesCreation) patchState(key, { createDraft: null, error: '' });
+    var main = mainState(key); if (main) { var file = Object.assign({}, database, { itemType: 'db', writable: true }); var identity = identityOwner ? identityOwner(file) : 'local:' + file.id; var drafts = Object.assign({}, main.drafts); if (!drafts[identity]) drafts[identity] = { file: file, content: '', writable: true, dirty: false, mode: 'read' }; var files = main.files.some(function (item) { return item.id === file.id; }) ? main.files : main.files.concat([file]); var tabs = main.tabs.indexOf(identity) === -1 ? main.tabs.concat([identity]) : main.tabs; var createPatch = { files: files, drafts: drafts, tabs: tabs }; if (ownsCreation) { createPatch.selected = identity; createPatch.fullscreen = false; } patchMain(key, createPatch); }
+    if (!knownDatabase) { setDatabaseState(key, database.id, { database: database, records: [], nextCursor: null, selectedRecord: null, recordDetail: null, edit: null, loading: false, error: msg.projectionPending ? msg.projectionError : '', syncPending: msg.projectionPending === true }); if (currentWorkspace) query(key, database.id, false, null); }
+  }
+  else if (msg.type === 'knowledge_db_content') { patchDatabase(key, dbId, { database: msg.database, loading: false, error: '' }); if (currentWorkspace) query(key, dbId, false, null); }
+  else if (msg.type === 'knowledge_db_query_results') { if (tracked.queryEpoch !== state.queryEpoch || tracked.viewId !== (state.selectedViewId || state.database && state.database.views[0] && state.database.views[0].id || null)) return true; patchDatabase(key, dbId, { records: tracked.append ? state.records.concat(msg.records || []) : msg.records || [], nextCursor: msg.nextCursor || null, loading: false, totals: msg.totals, error: state.syncPending ? state.error : '' }); }
+  else if (msg.type === 'knowledge_db_record_content') { if (state.selectedRecord !== tracked.recordId || state.recordGeneration !== tracked.recordGeneration) return true; patchDatabase(key, dbId, { recordDetail: msg, error: '' }); }
+  else if (msg.type === 'knowledge_db_record_created' || msg.type === 'knowledge_db_record_updated') { var ownsEdit = state.edit && state.edit.id === tracked.editId; var applied = ownsEdit ? applyRecordSave(state.edit, msg.record, operationId('record'), tracked.attempt) : { edit: state.edit, later: false, stale: true }; if (applied.stale) return true; var selectedRecord = ownsEdit && tracked.creating ? msg.record.id : state.selectedRecord; var recordDetail = selectedRecord === msg.record.id ? { database: state.database, record: msg.record, title: msg.record.values[titleField(state.database).id], history: state.recordDetail && state.recordDetail.history || [] } : state.recordDetail; var recordDrafts = Object.assign({}, state.recordDrafts || {}); if (tracked.recordId) delete recordDrafts[tracked.recordId]; if (applied.later) recordDrafts[msg.record.id] = applied.edit; patchDatabase(key, dbId, { edit: applied.edit, recordDrafts: recordDrafts, selectedRecord: selectedRecord, recordDetail: recordDetail, database: Object.assign({}, state.database, { revision: msg.databaseRevision }), error: msg.projectionPending ? msg.projectionError : '', syncPending: msg.projectionPending === true }); preserveActiveForm = applied.later; if (ownsEdit && !applied.later && stillOwns(key, tracked) && currentWorkspace && selectedFile(key) && selectedFile(key).id === dbId) patchMain(key, { fullscreen: false }); if (currentWorkspace) query(key, dbId, false, null); }
+  else if (msg.type === 'knowledge_db_schema_saved' || msg.type === 'knowledge_db_view_saved') { var ownsSchemaEdit = state.edit && state.edit.id === tracked.editId; patchDatabase(key, dbId, { database: msg.database, selectedViewId: tracked.viewId || state.selectedViewId, edit: ownsSchemaEdit ? null : state.edit, error: msg.projectionPending ? msg.projectionError : '', syncPending: msg.projectionPending === true }); if (ownsSchemaEdit && stillOwns(key, tracked) && currentWorkspace && selectedFile(key) && selectedFile(key).id === dbId) patchMain(key, { fullscreen: false }); if (currentWorkspace) query(key, dbId, false, null); }
+  else if (msg.type === 'knowledge_db_record_archived' || msg.type === 'knowledge_db_record_recovered') { if (state.selectedRecord === tracked.recordId) patchDatabase(key, dbId, { selectedRecord: null, recordDetail: null, edit: null, database: Object.assign({}, state.database, { revision: msg.databaseRevision }), error: msg.projectionPending ? msg.projectionError : '', syncPending: msg.projectionPending === true }); if (currentWorkspace) query(key, dbId, false, null); }
+  else if (msg.type === 'knowledge_db_renamed') { var renamedMain = mainState(key); var renamedIdentity = renamedMain && renamedMain.tabs.filter(function (item) { return renamedMain.drafts[item] && renamedMain.drafts[item].file.id === dbId; })[0]; if (renamedMain && renamedIdentity) { var renamedDrafts = Object.assign({}, renamedMain.drafts); renamedDrafts[renamedIdentity] = Object.assign({}, renamedDrafts[renamedIdentity], { file: Object.assign({}, renamedDrafts[renamedIdentity].file, { name: msg.database.name, revision: msg.database.revision }) }); var renamePatch = { drafts: renamedDrafts, files: renamedMain.files.map(function (file) { return file.id === dbId ? Object.assign({}, file, { name: msg.database.name, revision: msg.database.revision }) : file; }) }; if (stillOwns(key, tracked)) renamePatch.fullscreen = false; patchMain(key, renamePatch); } patchDatabase(key, dbId, { database: msg.database, edit: null, error: msg.projectionPending ? msg.projectionError : '', syncPending: msg.projectionPending === true }); }
+  else if (msg.type === 'knowledge_db_archived') { var archivedMain = mainState(key); if (archivedMain) { var archivedIdentity = archivedMain.tabs.filter(function (item) { return archivedMain.drafts[item] && archivedMain.drafts[item].file.id === dbId; })[0]; var archivedTabs = archivedMain.tabs.filter(function (item) { return item !== archivedIdentity; }); var archivedDrafts = Object.assign({}, archivedMain.drafts); delete archivedDrafts[archivedIdentity]; var archivePatch = { files: archivedMain.files.filter(function (file) { return file.id !== dbId; }), tabs: archivedTabs, drafts: archivedDrafts }; if (stillOwns(key, tracked)) { archivePatch.selected = archivedTabs.length ? archivedTabs[archivedTabs.length - 1] : null; archivePatch.fullscreen = false; } patchMain(key, archivePatch); } patchState(key, { dialog: null }); }
+  else if (msg.type === 'knowledge_db_recovered') { var recovered = msg.database; var ownsRecovery = stillOwns(key, tracked) && stateFor(key).recoveryDraft && stateFor(key).recoveryDraft.operationId === tracked.recoveryOperationId; var recoveredMain = mainState(key); if (recoveredMain) { var recoveredFile = Object.assign({}, recovered, { itemType: 'db', writable: true }); var recoveredIdentity = identityOwner ? identityOwner(recoveredFile) : 'local:' + recovered.id; var recoveredDrafts = Object.assign({}, recoveredMain.drafts); recoveredDrafts[recoveredIdentity] = { file: recoveredFile, content: '', writable: true, dirty: false, mode: 'read' }; var recoveryPatch = { files: recoveredMain.files.filter(function (file) { return file.id !== recovered.id; }).concat([recoveredFile]), drafts: recoveredDrafts, tabs: recoveredMain.tabs.indexOf(recoveredIdentity) === -1 ? recoveredMain.tabs.concat([recoveredIdentity]) : recoveredMain.tabs, deletedFiles: (recoveredMain.deletedFiles || []).filter(function (file) { return file.id !== recovered.id; }) }; if (ownsRecovery) { recoveryPatch.selected = recoveredIdentity; recoveryPatch.fullscreen = false; } patchMain(key, recoveryPatch); } patchState(key, { recoveryDraft: null }); patchDatabase(key, recovered.id, { database: recovered, records: [], loading: false, error: '', edit: null }); if (currentWorkspace) query(key, recovered.id, false, null); }
+  else if (msg.type === 'knowledge_db_synced') patchDatabase(key, dbId, { database: msg.database, error: msg.projectionPending ? msg.projectionError : '', syncPending: msg.projectionPending === true });
+  else if (msg.type === 'knowledge_error') { if (tracked.create) { var failedCreate = stateFor(key).createDraft; if (failedCreate && failedCreate.attempt && failedCreate.attempt.operationId === tracked.createOperationId) patchState(key, { createDraft: Object.assign({}, failedCreate, { saving: false, retryPending: false, attempt: null, operationId: operationId('create'), error: msg.error }) }); } else if (tracked.recoverDatabase && stateFor(key).recoveryDraft) patchState(key, { recoveryDraft: Object.assign({}, stateFor(key).recoveryDraft, { saving: false, error: msg.error }) }); else if (state && state.edit && (!tracked.editId || state.edit.id === tracked.editId) && (!tracked.saveRecord || isCurrentAttempt(state.edit, tracked.attempt))) patchDatabase(key, dbId, { edit: Object.assign({}, state.edit, { saving: false, retryPending: false, attempt: null, operationId: tracked.saveRecord ? operationId('record') : state.edit.operationId, error: msg.error }), loading: false, error: '' }); else if (dbId && !tracked.saveRecord) patchDatabase(key, dbId, { loading: false, error: msg.error }); else if (!dbId) patchState(key, { error: msg.error }); }
+  else return false;
+  var visibleFile = currentWorkspace ? selectedFile(key) : null; var affectsVisibleDatabase = !dbId || visibleFile && visibleFile.itemType === 'db' && visibleFile.id === dbId; var activeForm = document.activeElement && document.activeElement.closest && document.activeElement.closest('.knowledge-db-form'); var backgroundOnly = msg.type === 'knowledge_db_query_results' || msg.type === 'knowledge_db_synced';
+  if (currentWorkspace && affectsVisibleDatabase && !preserveActiveForm && !(activeForm && backgroundOnly) && renderOwner) renderOwner({ forceDocument: forceDocument });
+  else if (currentWorkspace && !affectsVisibleDatabase && ['knowledge_db_created', 'knowledge_db_renamed', 'knowledge_db_archived', 'knowledge_db_recovered'].indexOf(msg.type) !== -1 && renderOwner) renderOwner({ forceDocument: false });
+  return true;
+}

package/lib/public/modules/knowledge-history-state.js

@@ -0,0 +1,55 @@
+export function liveHistoryTarget(documentKey, draft) {
+  if (!draft || draft.newDocument || !draft.file || !draft.file.id) return null;
+  return { documentId: draft.file.id, documentKey: documentKey, name: draft.file.name, revision: draft.revision || null, deleted: false };
+}
+
+export function deletedHistoryTarget(documentId, name) {
+  if (!documentId || !name) return null;
+  return { documentId: documentId, documentKey: null, name: name, revision: null, deleted: true };
+}
+
+export function beginHistoryRequest(state, target, requestId) {
+  return Object.assign({}, state, { historyRequestId: requestId,
+    historyView: Object.assign({}, target, { versions: [], preview: null, loading: true }) });
+}
+
+export function receiveHistoryVersions(state, tracked, versions) {
+  if (!tracked || state.historyRequestId !== tracked.requestId) return state;
+  return Object.assign({}, state, { historyRequestId: null,
+    historyView: Object.assign({}, tracked.historyTarget, { versions: versions || [], preview: null, loading: false }) });
+}
+
+export function beginHistoryPreview(state, requestId) {
+  if (!state.historyView) return state;
+  return Object.assign({}, state, { historyPreviewRequestId: requestId,
+    historyView: Object.assign({}, state.historyView, { preview: null, loading: true }) });
+}
+
+export function receiveHistoryPreview(state, tracked, selected) {
+  if (!tracked || state.historyPreviewRequestId !== tracked.requestId) return state;
+  return Object.assign({}, state, { historyPreviewRequestId: null,
+    historyView: Object.assign({}, tracked.historyTarget, { versions: state.historyView && state.historyView.versions || [], preview: selected, loading: false }) });
+}
+
+export function clearHistoryView(state) {
+  return Object.assign({}, state, { historyRequestId: null, historyPreviewRequestId: null, historyView: null });
+}
+
+function escapeText(value) {
+  var span = document.createElement('span'); span.textContent = String(value || ''); return span.innerHTML;
+}
+
+export function historyToolbarHtml(history, fullscreen) {
+  return '<strong class="knowledge-preview-name">' + escapeText(history.name) + '</strong><span class="knowledge-readonly">History preview · read only</span>' +
+    (fullscreen ? '<button type="button" data-history-restore="' + escapeText(history.preview.version) + '">Restore this version</button>' : '<button type="button" data-history-review>Review restore fullscreen</button>') +
+    '<button type="button" data-document-action="history-exit">Exit preview</button>';
+}
+
+export function historyVersionsHtml(history) {
+  if (!history) return '';
+  if (history.loading) return '<p>Loading history…</p>';
+  if (!history.versions || !history.versions.length) return '';
+  return '<small>VERSIONS OF ' + escapeText(history.name) + '</small>' + history.versions.map(function (item) {
+    return '<button type="button" class="knowledge-link-item" data-history-preview="' + escapeText(item.version) + '">' + escapeText(new Date(Number(item.version.split('-')[0])).toLocaleString()) + '</button>';
+  }).join('');
+}

package/lib/public/modules/knowledge-markdown-editor.js

@@ -0,0 +1,57 @@
+var activeEditor = null;
+
+function relativeName(from, to) {
+  var source = String(from || '').split('/'); source.pop(); var target = String(to || '').replace(/\.md$/i, '').split('/');
+  while (source.length && target.length && source[0] === target[0]) { source.shift(); target.shift(); }
+  return new Array(source.length + 1).join('../') + target.join('/');
+}
+
+function wikiHint(editor, files, currentName) {
+  var cursor = editor.getCursor(); var line = editor.getLine(cursor.line); var before = line.slice(0, cursor.ch); var open = before.lastIndexOf('[[', cursor.ch);
+  if (open === -1 || before.slice(open + 2).indexOf(']]') !== -1) return null;
+  var typed = before.slice(open + 2).split('|')[0].split('#')[0].toLowerCase();
+  var list = (files || []).filter(function (file) { return file.itemType !== 'db' && (!typed || file.name.toLowerCase().indexOf(typed) !== -1); }).slice(0, 30).map(function (file) {
+    return { text: relativeName(currentName, file.name) + ']]', displayText: file.name };
+  });
+  return { list: list, from: window.CodeMirror.Pos(cursor.line, open + 2), to: cursor };
+}
+
+function maybeComplete(editor, change, files, currentName) {
+  if (!change || change.origin === 'setValue' || change.origin === 'complete') return;
+  var cursor = editor.getCursor(); var line = editor.getLine(cursor.line).slice(0, cursor.ch);
+  if (line.lastIndexOf('[[') === -1 || line.lastIndexOf(']]') > line.lastIndexOf('[[')) return;
+  editor.showHint({ completeSingle: false, hint: function (cm) { return wikiHint(cm, files, currentName); } });
+}
+
+export function mountKnowledgeEditor(host, options) {
+  destroyKnowledgeEditor();
+  var textarea = document.createElement('textarea'); textarea.setAttribute('aria-label', 'Markdown source'); host.appendChild(textarea);
+  if (!window.CodeMirror) { textarea.value = options.value || ''; textarea.className = 'knowledge-editor-fallback'; textarea.addEventListener('input', function () { options.onChange(textarea.value, null); }); activeEditor = { fallback: textarea }; return activeEditor; }
+  var editor = window.CodeMirror.fromTextArea(textarea, {
+    value: options.value || '', mode: { name: 'markdown', highlightFormatting: true }, lineWrapping: true, lineNumbers: false,
+    indentUnit: 2, tabSize: 2, indentWithTabs: false, inputStyle: 'contenteditable', spellcheck: true,
+    extraKeys: { 'Ctrl-Space': function (cm) { cm.showHint({ completeSingle: false, hint: function (item) { return wikiHint(item, options.files, options.currentName); } }); },
+      'Tab': function (cm) { cm.execCommand('indentMore'); }, 'Shift-Tab': function (cm) { cm.execCommand('indentLess'); },
+      'Enter': 'newlineAndIndentContinueMarkdownList' },
+  });
+  editor.setValue(options.value || ''); editor.clearHistory();
+  if (options.history) { try { editor.setHistory(options.history); } catch (error) {} }
+  if (options.cursor) { try { editor.setCursor(options.cursor); } catch (error) {} }
+  editor.on('change', function (cm, change) { options.onChange(cm.getValue(), cm.getCursor()); maybeComplete(cm, change, options.files, options.currentName); });
+  editor.on('cursorActivity', function (cm) { if (options.onCursor) options.onCursor(cm.getCursor()); });
+  activeEditor = editor; setTimeout(function () { editor.refresh(); editor.focus(); }, 0); return editor;
+}
+
+export function captureKnowledgeEditor() {
+  if (!activeEditor) return null;
+  if (activeEditor.fallback) return { content: activeEditor.fallback.value, cursor: null, history: null, scroll: activeEditor.fallback.scrollTop || 0 };
+  return { content: activeEditor.getValue(), cursor: activeEditor.getCursor(), history: activeEditor.getHistory(), scroll: activeEditor.getScrollInfo().top };
+}
+
+export function scrollKnowledgeEditor(top) { if (activeEditor && !activeEditor.fallback) activeEditor.scrollTo(null, top || 0); }
+export function destroyKnowledgeEditor() {
+  if (!activeEditor) return;
+  if (!activeEditor.fallback) { try { activeEditor.toTextArea(); } catch (error) {} }
+  else if (activeEditor.fallback.parentNode) activeEditor.fallback.parentNode.removeChild(activeEditor.fallback);
+  activeEditor = null;
+}

package/lib/public/modules/knowledge-preview-links.js

@@ -0,0 +1,70 @@
+function applyTarget(element, link) {
+  if (link.documentKey) {
+    element.dataset.openDocument = link.documentKey;
+    if (link.heading) element.dataset.openHeading = link.heading;
+  } else if (link.self && link.heading) element.dataset.outlineHeading = link.heading;
+  else if (link.unresolved && link.target) element.dataset.createLinked = link.target;
+}
+
+function decode(value) {
+  try { return decodeURIComponent(value); } catch (error) { return value; }
+}
+
+function normalizedTarget(value) {
+  return decode(String(value || '').trim().replace(/^<|>$/g, '')).replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase();
+}
+
+function renderedTarget(element) {
+  if (element.matches('button.clay-file-link')) return normalizedTarget(element.dataset.filePath);
+  return normalizedTarget(element.getAttribute('href'));
+}
+
+function matchingLink(element, links, used) {
+  var actual = renderedTarget(element);
+  if (element.matches('a') && actual.charAt(0) !== '#') return null;
+  for (var i = 0; i < links.length; i++) {
+    if (used[i] || normalizedTarget(links[i].target + (links[i].heading ? '#' + links[i].heading : '')) !== actual && normalizedTarget(links[i].target) !== actual) continue;
+    used[i] = true; return links[i];
+  }
+  return null;
+}
+
+function decorateAnchors(root, outgoing) {
+  var links = outgoing.filter(function (item) { return item.kind === 'markdown' && !item.external; }); var anchors = root.querySelectorAll('a[href], button.clay-file-link'); var used = [];
+  for (var i = 0; i < anchors.length; i++) {
+    var link = matchingLink(anchors[i], links, used); if (!link) continue;
+    anchors[i].classList.remove('clay-file-link'); delete anchors[i].dataset.filePath; delete anchors[i].dataset.fileProjectSlug; delete anchors[i].dataset.fileSessionId;
+    anchors[i].removeAttribute('title'); anchors[i].setAttribute('aria-label', 'Open Knowledge document ' + (link.label || link.target || 'link'));
+    applyTarget(anchors[i], link); anchors[i].classList.add('knowledge-inline-link');
+    if (link.documentKey || link.self || link.unresolved) anchors[i].removeAttribute('href');
+  }
+}
+
+function safeExternalTarget(value) {
+  var target = String(value || '').trim();
+  return /^(?:https?:|mailto:|tel:)/i.test(target) ? target : null;
+}
+
+function decorateWiki(root, outgoing) {
+  var links = outgoing.filter(function (item) { return item.kind === 'wiki' || item.kind === 'embed'; }); if (!links.length) return;
+  var walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT); var nodes = []; var node;
+  while ((node = walker.nextNode())) if (node.parentElement && !node.parentElement.closest('code, pre, a, button')) nodes.push(node);
+  var linkAt = 0;
+  for (var n = 0; n < nodes.length && linkAt < links.length; n++) {
+    var text = nodes[n].nodeValue || ''; var fragment = document.createDocumentFragment(); var offset = 0; var changed = false;
+    while (linkAt < links.length) {
+      var link = links[linkAt]; var at = text.indexOf(link.raw, offset); if (at === -1) break;
+      fragment.appendChild(document.createTextNode(text.slice(offset, at))); var button;
+      if (link.external && safeExternalTarget(link.target)) { button = document.createElement('a'); button.href = safeExternalTarget(link.target); button.target = '_blank'; button.rel = 'noopener noreferrer'; }
+      else if (link.external) { button = document.createElement('span'); }
+      else { button = document.createElement('button'); button.type = 'button'; applyTarget(button, link); }
+      button.className = 'knowledge-inline-link'; button.textContent = link.label || link.target || link.heading; fragment.appendChild(button);
+      offset = at + link.raw.length; linkAt++; changed = true;
+    }
+    if (changed) { fragment.appendChild(document.createTextNode(text.slice(offset))); nodes[n].parentNode.replaceChild(fragment, nodes[n]); }
+  }
+}
+
+export function decorateKnowledgePreview(root, outgoing) {
+  if (!root) return; decorateAnchors(root, outgoing || []); decorateWiki(root, outgoing || []);
+}

package/lib/public/modules/knowledge-workbench-shell.js

@@ -0,0 +1,21 @@
+var inertEntries = [];
+
+export function setKnowledgeNarrowBackground(panel, active) {
+  if (!panel) return;
+  var narrow = active && window.matchMedia('(max-width: 1023px)').matches;
+  if (narrow && !inertEntries.length) {
+    var branch = panel;
+    while (branch.parentElement && branch.parentElement !== document.body) {
+      Array.prototype.forEach.call(branch.parentElement.children, function (child) {
+        if (child === branch) return;
+        inertEntries.push({ element: child, inert: child.inert, ariaHidden: child.getAttribute('aria-hidden') });
+        child.inert = true; child.setAttribute('aria-hidden', 'true');
+      });
+      branch = branch.parentElement;
+    }
+  }
+  if (!narrow && inertEntries.length) {
+    inertEntries.forEach(function (item) { item.element.inert = item.inert; if (item.ariaHidden == null) item.element.removeAttribute('aria-hidden'); else item.element.setAttribute('aria-hidden', item.ariaHidden); });
+    inertEntries = [];
+  }
+}