TOKEN=$(curl -s -XPOST localhost:38080/api/v1/auth/dev-login -H 'content-type: application/json' -d '{"email":"admin@obscura.local"}' | python3 -c 'import sys,json;print(json.load(sys.stdin)["token"])')
curl -s localhost:38080/api/v1/me -H "authorization: Bearer $TOKEN" | python3 -c 'import sys,json;print(sorted(json.load(sys.stdin)["enabled_modules"]))'

    uploadTitle: 'Upload document',
    writeTitle: 'Write document',
    dropHint: 'Drag a file here, or browse',
    dropBrowse: 'browse',
    titleFromFile: 'Title (from file name — edit if needed)',
    folderBoxTitle: 'Where should this go?',
    folderCurrent: 'Current folder',
    folderBrowse: 'Browse for another folder…',
    folderSuggesting: 'Finding folders…',
    folderMatch: '{{pct}}% match',
    folderNone: 'No suggestions — choose a folder',

    uploadTitle: 'Unggah dokumen',
    writeTitle: 'Tulis dokumen',
    dropHint: 'Seret berkas ke sini, atau telusuri',
    dropBrowse: 'telusuri',
    titleFromFile: 'Judul (dari nama berkas — ubah bila perlu)',
    folderBoxTitle: 'Simpan ke mana?',
    folderCurrent: 'Folder saat ini',
    folderBrowse: 'Telusuri folder lain…',
    folderSuggesting: 'Mencari folder…',
    folderMatch: '{{pct}}% cocok',
    folderNone: 'Tidak ada saran — pilih folder',

cd /home/efran/remote-development/obscura/web && npx tsc --noEmit
cd /home/efran/remote-development/obscura
git add web/src/i18n/locales/en.ts web/src/i18n/locales/id.ts
git commit -m "feat(web): i18n keys for the New Document redesign"

// A reusable "where should this go?" folder chooser: AI folder suggestions (semantic module),
// the current folder (always offered), and a Browse fallback (the existing MoveModal tree).
// Auto-runs the suggestion when its query settles; degrades to current-folder + browse when the
// semantic module is not licensed. Controlled: the parent owns the selected folder id + path.
import { useEffect, useState } from 'react'
import { RadioButtonGroup, RadioButton, InlineLoading, Button } from '@carbon/react'
import { useTranslation } from 'react-i18next'
import { useMe } from '@/api/me'
import { moduleEnabled } from '@/lib/nav'
import { useSuggestFolder, type FolderSuggestion } from '@/api/semantic'
import { MoveModal } from './MoveModal'

const CURRENT = '__current__'
const BROWSE = '__browse__'

export interface FolderChoice {
  folderId: string | null
  path: string
}

interface Props {
  // The suggestion query. For upload: {title, filename}; for write: {title, text}.
  query: { title?: string; text?: string; filename?: string }
  // Whether to run the suggestion at all (e.g. only once a file is chosen).
  enabled: boolean
  currentFolderId: string | null
  currentFolderPath: string
  value: FolderChoice
  onChange: (choice: FolderChoice) => void
}

export function FolderSuggestBox({ query, enabled, currentFolderId, currentFolderPath, value, onChange }: Props) {
  const { t } = useTranslation()
  const me = useMe()
  const semanticEnabled = moduleEnabled(me.data?.enabledModules, 'semantic')
  const suggest = useSuggestFolder()
  const [rows, setRows] = useState<FolderSuggestion[]>([])
  const [browseOpen, setBrowseOpen] = useState(false)

  // Serialize the query so the effect only re-runs when the meaningful inputs change.
  const qKey = `${query.title ?? ''}${query.text ?? ''}${query.filename ?? ''}`
  useEffect(() => {
    if (!enabled || !semanticEnabled) {
      setRows([])
      return
    }
    if (!query.title && !query.text && !query.filename) return
    let cancelled = false
    const handle = setTimeout(() => {
      suggest.mutate(
        { title: query.title, text: query.text, filename: query.filename },
        {
          onSuccess: (r) => {
            if (!cancelled) setRows(r)
          },
        },
      )
    }, 400)
    return () => {
      cancelled = true
      clearTimeout(handle)
    }
  }, [qKey, enabled, semanticEnabled]) // eslint-disable-line react-hooks/exhaustive-deps

  // Suggestions minus the current folder (it gets its own always-present row).
  const aiRows = rows.filter((r) => r.folderId !== currentFolderId)

  // The selected radio value is derived from the controlled folderId.
  const selectedValue =
    value.folderId === currentFolderId ? CURRENT : value.folderId ?? CURRENT

  const pick = (v: string) => {
    if (v === CURRENT) return onChange({ folderId: currentFolderId, path: currentFolderPath })
    if (v === BROWSE) return setBrowseOpen(true)
    const row = aiRows.find((r) => r.folderId === v)
    if (row) onChange({ folderId: row.folderId, path: row.path })
  }

  return (
    <div className="foldersuggest">
      <p className="foldersuggest__title">{t('newDoc.folderBoxTitle')}</p>
      {suggest.isPending && <InlineLoading description={t('newDoc.folderSuggesting')} />}
      <RadioButtonGroup
        name="folder-suggest"
        orientation="vertical"
        valueSelected={selectedValue}
        onChange={(v) => pick(String(v))}
      >
        {aiRows.map((r) => (
          <RadioButton
            key={r.folderId}
            id={`fs-${r.folderId}`}
            value={r.folderId}
            labelText={`${r.path}  ·  ${t('newDoc.folderMatch', { pct: Math.round(r.score * 100) })}`}
          />
        ))}
        <RadioButton
          id="fs-current"
          value={CURRENT}
          labelText={`${currentFolderPath || '/'}  ·  ${t('newDoc.folderCurrent')}`}
        />
        <RadioButton id="fs-browse" value={BROWSE} labelText={t('newDoc.folderBrowse')} />
      </RadioButtonGroup>
      {value.folderId !== currentFolderId && value.folderId !== null && !aiRows.some((r) => r.folderId === value.folderId) && (
        <p className="foldersuggest__picked">{value.path}</p>
      )}
      {browseOpen && (
        <MoveModal
          open
          itemName={t('newDoc.folderBoxTitle')}
          onClose={() => setBrowseOpen(false)}
          onSubmit={(targetFolderId) => {
            setBrowseOpen(false)
            onChange({ folderId: targetFolderId, path: targetFolderId ? '' : (currentFolderPath || '/') })
          }}
        />
      )}
    </div>
  )
}

.foldersuggest { margin-top: 1rem; }
.foldersuggest__title { font-size: 0.75rem; color: var(--cds-text-secondary); margin-bottom: 0.25rem; }
.foldersuggest__picked { font-size: 0.75rem; color: var(--cds-text-secondary); margin-top: 0.25rem; word-break: break-all; }

cd /home/efran/remote-development/obscura/web && npx tsc --noEmit && npx vite build
cd /home/efran/remote-development/obscura
git add web/src/features/documents/FolderSuggestBox.tsx web/src/features/documents/*.css web/src/styles 2>/dev/null; git add -A
git commit -m "feat(web): reusable FolderSuggestBox (AI + current folder + browse, degrades)"

// Upload-document modal: drag-and-drop first, then the metadata form expands once a file is
// chosen. Title autofills from the file name. Filing uses FolderSuggestBox (default = current).
import { useEffect, useState } from 'react'
import { Dropdown, InlineNotification, Modal, TextInput, FileUploaderDropContainer } from '@carbon/react'
import { useTranslation } from 'react-i18next'
import { type Classification } from '@/lib/classification'
import { useActiveClassifications } from '@/api/classifications'
import { useIdFormats } from '@/api/docid'
import { ACCEPTED_UPLOAD_TYPES } from '@/api/files'
import { FolderSuggestBox, type FolderChoice } from './FolderSuggestBox'

const ID_NONE = '__none__'
const titleCase = (s: string) => s.charAt(0).toUpperCase() + s.slice(1)
const stripExt = (name: string) => name.replace(/\.[^./\\]+$/, '')

function extractCustoms(pattern: string): string[] {
  const re = /\{custom:([^}]+)\}/g
  const out: string[] = []
  const seen = new Set<string>()
  let m: RegExpExecArray | null
  while ((m = re.exec(pattern)) !== null) {
    const n = m[1]!.trim().toLowerCase()
    if (n && !seen.has(n)) { seen.add(n); out.push(n) }
  }
  return out
}

export interface UploadDocumentInput {
  title: string
  classification: Classification
  docType: string
  formatId: string
  customVars: Record<string, string>
  file: File
  folderId: string | null
}

interface Props {
  open: boolean
  busy?: boolean
  error?: string | null
  currentFolderId: string | null
  currentFolderPath: string
  onSubmit: (input: UploadDocumentInput) => void
  onClose: () => void
}

export function UploadDocumentModal({ open, busy, error, currentFolderId, currentFolderPath, onSubmit, onClose }: Props) {
  const { t } = useTranslation()
  const { data: formats = [] } = useIdFormats()
  const levels = useActiveClassifications()
  const CLASS_ITEMS = levels.map((c) => ({ id: c.code, label: c.label }))

  const [file, setFile] = useState<File | null>(null)
  const [title, setTitle] = useState('')
  const [classification, setClassification] = useState<Classification>('none')
  const [docType, setDocType] = useState('')
  const [formatId, setFormatId] = useState('')
  const [customVars, setCustomVars] = useState<Record<string, string>>({})
  const [folder, setFolder] = useState<FolderChoice>({ folderId: currentFolderId, path: currentFolderPath })

  useEffect(() => {
    if (open) {
      setFile(null); setTitle(''); setClassification('none'); setDocType(''); setCustomVars({})
      setFolder({ folderId: currentFolderId, path: currentFolderPath })
    }
  }, [open]) // eslint-disable-line react-hooks/exhaustive-deps

  useEffect(() => {
    if (!open) return
    const def = formats.find((f) => f.isDefault)
    setFormatId(def ? def.id : '')
  }, [open, formats])

  const onFile = (f: File | null) => {
    setFile(f)
    if (f && !title.trim()) setTitle(stripExt(f.name))
  }

  const formatItems = [{ id: ID_NONE, label: t('newDoc.noId') }, ...formats.map((f) => ({ id: f.id, label: `${f.name} · ${f.pattern}` }))]
  const selectedFormat = formatItems.find((i) => i.id === (formatId || ID_NONE)) ?? formatItems[0]
  const selectedPattern = formats.find((f) => f.id === formatId)?.pattern ?? ''
  const customNames = extractCustoms(selectedPattern)
  const customsFilled = customNames.every((n) => (customVars[n] ?? '').trim() !== '')

  const trimmed = title.trim()
  const canSubmit = !!file && !!trimmed && !busy && customsFilled
  const submit = () => {
    if (!canSubmit || !file) return
    const vars: Record<string, string> = {}
    for (const n of customNames) vars[n] = (customVars[n] ?? '').trim()
    onSubmit({ title: trimmed, classification, docType: docType.trim(), formatId, customVars: vars, file, folderId: folder.folderId })
  }

  return (
    <Modal
      open={open}
      size="sm"
      modalHeading={t('newDoc.uploadTitle')}
      primaryButtonText={t('newDoc.create')}
      secondaryButtonText={t('detail.cancel')}
      primaryButtonDisabled={!canSubmit}
      onRequestClose={onClose}
      onRequestSubmit={submit}
    >
      {error && (
        <InlineNotification kind="error" lowContrast title={t('newDoc.failed')} subtitle={error} hideCloseButton />
      )}
      {!file ? (
        <FileUploaderDropContainer
          labelText={t('newDoc.dropHint')}
          accept={ACCEPTED_UPLOAD_TYPES}
          multiple={false}
          onAddFiles={(_e, { addedFiles }) => onFile(addedFiles?.[0] ?? null)}
        />
      ) : (
        <>
          <div className="newdoc__file-chip">
            <span className="newdoc__file-name">{file.name}</span>
            <button type="button" className="newdoc__file-remove" onClick={() => setFile(null)}>✕</button>
          </div>
          <TextInput
            id="upload-doc-title"
            labelText={t('newDoc.titleFromFile')}
            value={title}
            onChange={(e) => setTitle(e.target.value)}
            data-modal-primary-focus
          />
          <div className="newdoc__field">
            <Dropdown
              id="upload-doc-classification"
              titleText={t('newDoc.classification')}
              label={CLASS_ITEMS.find((i) => i.id === classification)?.label ?? classification}
              items={CLASS_ITEMS}
              selectedItem={CLASS_ITEMS.find((i) => i.id === classification) ?? null}
              itemToString={(i) => i?.label ?? ''}
              onChange={({ selectedItem }) => selectedItem && setClassification(selectedItem.id)}
            />
          </div>
          <div className="newdoc__field">
            <TextInput id="upload-doc-type" labelText={t('newDoc.docType')} placeholder={t('newDoc.docTypePlaceholder')} value={docType} onChange={(e) => setDocType(e.target.value)} />
          </div>
          <div className="newdoc__field">
            <Dropdown
              id="upload-doc-format"
              titleText={t('newDoc.format')}
              helperText={t('newDoc.formatHint')}
              label={selectedFormat?.label ?? ''}
              items={formatItems}
              selectedItem={selectedFormat}
              itemToString={(i) => i?.label ?? ''}
              onChange={({ selectedItem }) => setFormatId(selectedItem && selectedItem.id !== ID_NONE ? selectedItem.id : '')}
            />
          </div>
          {customNames.map((name) => (
            <div className="newdoc__field" key={name}>
              <TextInput id={`upload-doc-custom-${name}`} labelText={titleCase(name)} placeholder={t('newDoc.customHint', { name })} value={customVars[name] ?? ''} onChange={(e) => setCustomVars((p) => ({ ...p, [name]: e.target.value }))} />
            </div>
          ))}
          <FolderSuggestBox
            query={{ title, filename: file.name }}
            enabled={!!file}
            currentFolderId={currentFolderId}
            currentFolderPath={currentFolderPath}
            value={folder}
            onChange={setFolder}
          />
        </>
      )}
    </Modal>
  )
}

.newdoc__file-chip { display: flex; align-items: center; justify-content: space-between; gap: 0.5rem; padding: 0.5rem 0.75rem; background: var(--cds-layer); margin-bottom: 0.5rem; }
.newdoc__file-name { word-break: break-all; }
.newdoc__file-remove { background: none; border: 0; cursor: pointer; color: var(--cds-text-secondary); }

cd /home/efran/remote-development/obscura/web && npx tsc --noEmit && npx vite build
cd /home/efran/remote-development/obscura
git add -A
git commit -m "feat(web): drag-drop-first UploadDocumentModal with title autofill + folder box"

// "Write document" modal: collects a title, classification and optional Document ID for a new
// in-app authored document, then hands off to the editor (the caller navigates). Upload lives in
// UploadDocumentModal. (Phase B replaces this with a direct-to-editor + Save-modal flow.)
import { useEffect, useState } from 'react'
import { Dropdown, InlineNotification, Modal, TextInput } from '@carbon/react'
import { useTranslation } from 'react-i18next'
import { type Classification } from '@/lib/classification'
import { useActiveClassifications } from '@/api/classifications'
import { useIdFormats } from '@/api/docid'

const ID_NONE = '__none__'
const titleCase = (s: string) => s.charAt(0).toUpperCase() + s.slice(1)

export interface NewDocumentInput {
  title: string
  classification: Classification
  docType: string
  formatId: string
  customVars: Record<string, string>
}

function extractCustoms(pattern: string): string[] {
  const re = /\{custom:([^}]+)\}/g
  const out: string[] = []
  const seen = new Set<string>()
  let m: RegExpExecArray | null
  while ((m = re.exec(pattern)) !== null) {
    const n = m[1]!.trim().toLowerCase()
    if (n && !seen.has(n)) { seen.add(n); out.push(n) }
  }
  return out
}

interface Props {
  open: boolean
  busy?: boolean
  error?: string | null
  onSubmit: (input: NewDocumentInput) => void
  onClose: () => void
}

export function NewDocumentModal({ open, busy, error, onSubmit, onClose }: Props) {
  const { t } = useTranslation()
  const { data: formats = [] } = useIdFormats()
  const levels = useActiveClassifications()
  const CLASS_ITEMS = levels.map((c) => ({ id: c.code, label: c.label }))
  const [title, setTitle] = useState('')
  const [classification, setClassification] = useState<Classification>('none')
  const [docType, setDocType] = useState('')
  const [formatId, setFormatId] = useState('')
  const [customVars, setCustomVars] = useState<Record<string, string>>({})

  useEffect(() => {
    if (open) { setTitle(''); setClassification('none'); setDocType(''); setCustomVars({}) }
  }, [open]) // eslint-disable-line react-hooks/exhaustive-deps
  useEffect(() => {
    if (!open) return
    const def = formats.find((f) => f.isDefault)
    setFormatId(def ? def.id : '')
  }, [open, formats])

  const formatItems = [{ id: ID_NONE, label: t('newDoc.noId') }, ...formats.map((f) => ({ id: f.id, label: `${f.name} · ${f.pattern}` }))]
  const selectedFormat = formatItems.find((i) => i.id === (formatId || ID_NONE)) ?? formatItems[0]
  const selectedPattern = formats.find((f) => f.id === formatId)?.pattern ?? ''
  const customNames = extractCustoms(selectedPattern)
  const customsFilled = customNames.every((n) => (customVars[n] ?? '').trim() !== '')

  const trimmed = title.trim()
  const submit = () => {
    if (!trimmed || busy || !customsFilled) return
    const vars: Record<string, string> = {}
    for (const n of customNames) vars[n] = (customVars[n] ?? '').trim()
    onSubmit({ title: trimmed, classification, docType: docType.trim(), formatId, customVars: vars })
  }

  return (
    <Modal
      open={open}
      size="sm"
      modalHeading={t('newDoc.writeTitle')}
      primaryButtonText={t('newDoc.create')}
      secondaryButtonText={t('detail.cancel')}
      primaryButtonDisabled={!trimmed || busy || !customsFilled}
      onRequestClose={onClose}
      onRequestSubmit={submit}
    >
      {error && <InlineNotification kind="error" lowContrast title={t('newDoc.failed')} subtitle={error} hideCloseButton />}
      <TextInput id="new-doc-title" labelText={t('newDoc.titleLabel')} placeholder={t('newDoc.titlePlaceholder')} value={title}
        onChange={(e) => setTitle(e.target.value)} onKeyDown={(e) => { if (e.key === 'Enter') submit() }} data-modal-primary-focus />
      <div className="newdoc__field">
        <Dropdown id="new-doc-classification" titleText={t('newDoc.classification')}
          label={CLASS_ITEMS.find((i) => i.id === classification)?.label ?? classification}
          items={CLASS_ITEMS} selectedItem={CLASS_ITEMS.find((i) => i.id === classification) ?? null}
          itemToString={(i) => i?.label ?? ''} onChange={({ selectedItem }) => selectedItem && setClassification(selectedItem.id)} />
      </div>
      <div className="newdoc__field">
        <TextInput id="new-doc-type" labelText={t('newDoc.docType')} placeholder={t('newDoc.docTypePlaceholder')} value={docType} onChange={(e) => setDocType(e.target.value)} />
      </div>
      <div className="newdoc__field">
        <Dropdown id="new-doc-format" titleText={t('newDoc.format')} helperText={t('newDoc.formatHint')} label={selectedFormat?.label ?? ''}
          items={formatItems} selectedItem={selectedFormat} itemToString={(i) => i?.label ?? ''}
          onChange={({ selectedItem }) => setFormatId(selectedItem && selectedItem.id !== ID_NONE ? selectedItem.id : '')} />
      </div>
      {customNames.map((name) => (
        <div className="newdoc__field" key={name}>
          <TextInput id={`new-doc-custom-${name}`} labelText={titleCase(name)} placeholder={t('newDoc.customHint', { name })}
            value={customVars[name] ?? ''} onChange={(e) => setCustomVars((p) => ({ ...p, [name]: e.target.value }))} />
        </div>
      ))}
    </Modal>
  )
}

import { NewDocumentModal, type NewDocumentInput } from './NewDocumentModal'
import { UploadDocumentModal, type UploadDocumentInput } from './UploadDocumentModal'

  const [uploadOpen, setUploadOpen] = useState(false)
  const [uploadError, setUploadError] = useState<string | null>(null)

  // A display path for the current folder (used as the "Current folder" option label).
  const currentFolderPath = currentFolderId
    ? (folders.find((f) => f.id === currentFolderId)?.name ?? '')
    : '/'

  // Write path: create a stub in the current folder and open the editor (unchanged behavior).
  const submitNewDoc = async ({ title, classification, docType, formatId, customVars }: NewDocumentInput) => {
    setSavingDoc(true)
    setNewDocError(null)
    try {
      const id = await createDocument.mutateAsync({ title, folderId: currentFolderId, classification, docType, formatId, customVars })
      if (!id) return
      setNewDocOpen(false)
      navigate(`/documents/d/${id}/edit?folder=${folderParam ?? 'root'}`)
    } catch (e) {
      setNewDocError(errMsg(e))
    } finally {
      setSavingDoc(false)
    }
  }

  // Upload path: create the doc in the SELECTED folder, upload the file as version 1, open detail.
  const submitUpload = async ({ title, classification, docType, formatId, customVars, file, folderId }: UploadDocumentInput) => {
    setSavingDoc(true)
    setUploadError(null)
    try {
      const id = await createDocument.mutateAsync({ title, folderId, classification, docType, formatId, customVars })
      if (!id) return
      setUploadOpen(false)
      try { await uploadVersion(id, file) } catch { /* stub created; retry from detail */ }
      navigate(`/documents/d/${id}?folder=${folderId ?? 'root'}`)
    } catch (e) {
      setUploadError(errMsg(e))
    } finally {
      setSavingDoc(false)
    }
  }

            <Button kind="tertiary" size="sm" renderIcon={Edit} onClick={() => setNewDocOpen(true)}>
              {t('newDoc.writeTitle')}
            </Button>
            <Button kind="primary" size="sm" renderIcon={DocumentAdd} onClick={() => setUploadOpen(true)}>
              {t('newDoc.uploadTitle')}
            </Button>

      <UploadDocumentModal
        open={uploadOpen}
        busy={savingDoc}
        error={uploadError}
        currentFolderId={currentFolderId}
        currentFolderPath={currentFolderPath}
        onSubmit={submitUpload}
        onClose={() => { setUploadOpen(false); setUploadError(null) }}
      />

cd /home/efran/remote-development/obscura/web && npx tsc --noEmit && npx vite build
cd /home/efran/remote-development/obscura
git add -A
git commit -m "feat(web): split New Document into Upload + Write buttons; wire redesigned upload modal"

cd /home/efran/remote-development/obscura
docker compose -f deploy/docker-compose.yml --env-file deploy/mekari.env up -d --build web obscura

    // SetDocumentReference sets documents.reference for a document that has none yet.
    // kernel.ErrNotFound if absent.
    SetDocumentReference(ctx context.Context, docID, reference string) error

// SetDocumentReference sets documents.reference. kernel.ErrNotFound if the document is absent.
func (s *Store) SetDocumentReference(ctx context.Context, docID, reference string) error {
    tag, err := s.db.Exec(ctx).Exec(ctx, `UPDATE documents SET reference = $2 WHERE id = $1`, docID, reference)
    if err != nil {
        return fmt.Errorf("dms set document reference: %w", err)
    }
    if tag.RowsAffected() == 0 {
        return &kernel.Error{Kind: kernel.ErrNotFound, Code: "dms.document.not_found", Message: "document not found"}
    }
    return nil
}

// AssignReference assigns a Document ID (reference) to a document that has NONE yet, using the
// chosen format. Rejects if a reference is already present (references are immutable once set) —
// this is the deferred-assignment path for in-app authored documents whose ID is chosen at first
// save rather than at create. Returns the rendered reference.
func (s *Service) AssignReference(ctx context.Context, docID string, formatID *string, customs map[string]string) (string, error) {
    if docID == "" {
        return "", &kernel.Error{Kind: kernel.ErrValidation, Code: "dms.document.id_required", Message: "document id is required"}
    }
    var ref string
    err := s.uow.Do(ctx, func(ctx context.Context) error {
        doc, err := s.repo.GetDocument(ctx, docID)
        if err != nil {
            return err
        }
        if strings.TrimSpace(doc.Reference) != "" {
            return &kernel.Error{Kind: kernel.ErrConflict, Code: "dms.docid.already_assigned", Message: "this document already has an ID"}
        }
        r, err := s.allocateReference(ctx, formatID, doc.DocType, doc.Classification, customs)
        if err != nil {
            return err
        }
        if r == "" {
            return nil // no format / numbering disabled → nothing to assign
        }
        if err := s.repo.SetDocumentReference(ctx, docID, r); err != nil {
            return err
        }
        ref = r
        return nil
    })
    return ref, err
}

// AssignDocumentID assigns a Document ID to a document that has none (deferred assignment for
// authored docs). Body: {format_id?: string, custom_vars?: {name: value}}. Returns {reference}.
func (s *Server) AssignDocumentID(w http.ResponseWriter, r *http.Request) {
    var body struct {
        FormatID   *string           `json:"format_id"`
        CustomVars map[string]string `json:"custom_vars"`
    }
    if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
        writeProblem(w, &kernel.Error{Kind: kernel.ErrValidation, Code: "request.invalid_json", Message: "invalid request body"})
        return
    }
    ref, err := s.dms.AssignReference(r.Context(), chi.URLParam(r, "docID"), body.FormatID, body.CustomVars)
    if err != nil {
        writeProblem(w, err)
        return
    }
    writeJSON(w, http.StatusOK, map[string]any{"reference": ref})
}

                r.With(s.requireAccess(dmsdomain.AccessReadWrite)).Post("/assign-id", s.AssignDocumentID)

cd /home/efran/remote-development/obscura/web && npm run gen:api

cd /home/efran/remote-development/obscura/go && go build ./... && go vet ./...
cd /home/efran/remote-development/obscura && git add -A
git commit -m "feat(dms): assign Document ID to an existing doc (deferred, immutable)"

    // DocumentIDsWithHTMLVersion returns, of the given doc ids, those that have at least one
    // text/html version (i.e. an editable authored source). Used to flag the documents list.
    DocumentIDsWithHTMLVersion(ctx context.Context, ids []string) ([]string, error)

// DocumentIDsWithHTMLVersion returns the subset of ids that have >=1 text/html version.
func (s *Store) DocumentIDsWithHTMLVersion(ctx context.Context, ids []string) ([]string, error) {
    if len(ids) == 0 {
        return nil, nil
    }
    rows, err := s.db.Exec(ctx).Query(ctx,
        `SELECT DISTINCT document_id::text FROM document_versions WHERE document_id::text = ANY($1::text[]) AND mime LIKE 'text/html%'`, ids)
    if err != nil {
        return nil, fmt.Errorf("editable doc ids: %w", err)
    }
    defer rows.Close()
    var out []string
    for rows.Next() {
        var id string
        if err := rows.Scan(&id); err != nil {
            return nil, err
        }
        out = append(out, id)
    }
    return out, rows.Err()
}

// EditableDocumentIDs returns which of the given documents have an editable (text/html) source
// version, for the documents-list "editable" badge.
func (s *Service) EditableDocumentIDs(ctx context.Context, ids []string) ([]string, error) {
    return s.repo.DocumentIDsWithHTMLVersion(ctx, ids)
}

    ids := make([]string, 0, len(docs))
    for _, d := range docs {
        ids = append(ids, d.ID)
    }
    editable, err := s.dms.EditableDocumentIDs(r.Context(), ids)
    if err != nil {
        writeProblem(w, err)
        return
    }
    writeJSON(w, http.StatusOK, map[string]any{"documents": nonNilDocs(docs), "editable_ids": editable})

cd /home/efran/remote-development/obscura/go && go build ./... && go vet ./...
cd /home/efran/remote-development/obscura && git add -A
git commit -m "feat(dms): editable_ids on the documents list (text/html source flag)"

export type DocFlag = 'shared' | 'locked' | 'hold' | 'editable'

import { Share, Locked, Scales, Edit } from '@carbon/icons-react'

  editable: { Icon: Edit, key: 'flag.editable' },

    const editable = new Set<string>(res.editable_ids ?? [])
    return (res.documents ?? []).map((d: ApiDocument) => toRow(d, users, editable))

function toRow(d: ApiDocument, users: Map<string, Person>, editable?: Set<string>): DocumentRow {
  const flags: DocFlag[] = []
  if (d.LegalHold) flags.push('hold')
  if (editable?.has(d.ID)) flags.push('editable')
  return {
    // ...unchanged fields...
    flags,
  }
}

const mimeLabel = (mime: string) =>
  mime.startsWith('text/html') ? t('version.editableDraft') : mime.startsWith('application/pdf') ? t('version.pdf') : mime

cd /home/efran/remote-development/obscura/web && npx tsc --noEmit && npx vite build
cd /home/efran/remote-development/obscura && git add -A
git commit -m "feat(web): editable table badge + friendly version labels"

// Assign a Document ID to an authored doc that has none yet (deferred assignment at first save).
export async function assignDocumentId(docId: string, formatId: string, customVars: Record<string, string>): Promise<string> {
  const { data, error } = await api.POST('/api/v1/documents/{docID}/assign-id', {
    params: { path: { docID: docId } },
    body: { format_id: formatId || null, custom_vars: customVars },
  })
  if (error) throw new Error((error as { detail?: string }).detail ?? 'assign id failed')
  return data?.reference ?? ''
}

// Save modal for authored documents: collect title/classification/(Document ID)/folder and either
// Save (finalize to PDF, stays editable) or Save as draft (HTML only). Reuses FolderSuggestBox.
import { useEffect, useState } from 'react'
import { Dropdown, Modal, TextInput } from '@carbon/react'
import { useTranslation } from 'react-i18next'
import { type Classification } from '@/lib/classification'
import { useActiveClassifications } from '@/api/classifications'
import { useIdFormats } from '@/api/docid'
import { FolderSuggestBox, type FolderChoice } from './FolderSuggestBox'

const ID_NONE = '__none__'

export interface SaveDocumentResult {
  action: 'save' | 'draft'
  title: string
  classification: Classification
  formatId: string
  customVars: Record<string, string>
  folderId: string | null
}

interface Props {
  open: boolean
  busy?: boolean
  editorText: string
  initialTitle: string
  needsId: boolean // true when the doc has no reference yet (show the ID picker)
  currentFolderId: string | null
  currentFolderPath: string
  onSubmit: (r: SaveDocumentResult) => void
  onClose: () => void
}

export function SaveDocumentModal({ open, busy, editorText, initialTitle, needsId, currentFolderId, currentFolderPath, onSubmit, onClose }: Props) {
  const { t } = useTranslation()
  const { data: formats = [] } = useIdFormats()
  const levels = useActiveClassifications()
  const CLASS_ITEMS = levels.map((c) => ({ id: c.code, label: c.label }))

  const [title, setTitle] = useState(initialTitle)
  const [classification, setClassification] = useState<Classification>('none')
  const [formatId, setFormatId] = useState('')
  const [folder, setFolder] = useState<FolderChoice>({ folderId: currentFolderId, path: currentFolderPath })

  useEffect(() => {
    if (open) {
      setTitle(initialTitle)
      setClassification('none')
      const def = formats.find((f) => f.isDefault)
      setFormatId(def ? def.id : '')
      setFolder({ folderId: currentFolderId, path: currentFolderPath })
    }
  }, [open]) // eslint-disable-line react-hooks/exhaustive-deps

  const formatItems = [{ id: ID_NONE, label: t('newDoc.noId') }, ...formats.map((f) => ({ id: f.id, label: `${f.name} · ${f.pattern}` }))]
  const selectedFormat = formatItems.find((i) => i.id === (formatId || ID_NONE)) ?? formatItems[0]
  const trimmed = title.trim()

  const emit = (action: 'save' | 'draft') => {
    if (!trimmed || busy) return
    onSubmit({ action, title: trimmed, classification, formatId, customVars: {}, folderId: folder.folderId })
  }

  return (
    <Modal
      open={open}
      size="sm"
      modalHeading={t('save.title')}
      primaryButtonText={t('save.save')}
      secondaryButtonText={t('save.draft')}
      primaryButtonDisabled={!trimmed || busy}
      onRequestClose={onClose}
      onRequestSubmit={() => emit('save')}
      onSecondarySubmit={() => emit('draft')}
    >
      <TextInput id="save-doc-title" labelText={t('newDoc.titleLabel')} value={title} onChange={(e) => setTitle(e.target.value)} data-modal-primary-focus />
      <div className="newdoc__field">
        <Dropdown id="save-doc-classification" titleText={t('newDoc.classification')}
          label={CLASS_ITEMS.find((i) => i.id === classification)?.label ?? classification}
          items={CLASS_ITEMS} selectedItem={CLASS_ITEMS.find((i) => i.id === classification) ?? null}
          itemToString={(i) => i?.label ?? ''} onChange={({ selectedItem }) => selectedItem && setClassification(selectedItem.id)} />
      </div>
      {needsId && (
        <div className="newdoc__field">
          <Dropdown id="save-doc-format" titleText={t('newDoc.format')} helperText={t('newDoc.formatHint')} label={selectedFormat?.label ?? ''}
            items={formatItems} selectedItem={selectedFormat} itemToString={(i) => i?.label ?? ''}
            onChange={({ selectedItem }) => setFormatId(selectedItem && selectedItem.id !== ID_NONE ? selectedItem.id : '')} />
        </div>
      )}
      <FolderSuggestBox
        query={{ title, text: editorText }}
        enabled={open}
        currentFolderId={currentFolderId}
        currentFolderPath={currentFolderPath}
        value={folder}
        onChange={setFolder}
      />
    </Modal>
  )
}