@sparkelf/dsh-knowledge-base 0.0.0-stage → 0.1.1

package/lib/types/client/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Knowledge-base Client plugin.
+ *
+ * Registers three official DSH surfaces:
+ * - `sidebar.panellist` gives the left-sidebar menu entry.
+ * - The matching `main` key gives the management page the entry selects. The
+ *   page replaces the conversation area and carries its own master-detail
+ *   layout: a menu and the knowledge tree on the left, a content region on the
+ *   right.
+ * - `settings.section` gives the connection and status page.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+import { type KnowledgeKey } from './locales.ts';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        'settings.knowledgeBase': KnowledgeKey;
+    }
+}
+/**
+ * Client services required for these contributions.
+ *
+ * `sessions` and `workspaces` are here because the `@`-reference dialog inserts into a
+ * conversation draft, and that insert resolves the target session's scope through
+ * `ctx.sessions` before it can write anything. Without the injection the service is not
+ * on this plugin's ctx at all: the call throws `cannot get property "sessions" without
+ * inject`, `referenceInChat` catches it into a `console.warn`, and the reader sees a
+ * dialog that closes and inserts nothing -- the exact "clicked, nothing happened"
+ * symptom this injection fixes at the root rather than by reporting the failure.
+ *
+ * `workspaces` is the other half: the mention is spelled relative to the workspace that
+ * owns the session, so the insert needs that root to project the path.
+ */
+export declare const inject: string[];
+/**
+ * Register the knowledge-base navigation entry and Settings section.
+ * @param ctx - DSH client context with locale and slot registries.
+ */
+export declare function apply(ctx: ClientContext): void;

package/lib/types/client/insertReadiness.d.ts

@@ -0,0 +1,60 @@
+/**
+ * When to keep waiting for a freshly created conversation, and when to give up.
+ *
+ * Lifted out of the picker's `createNew` because the part worth testing is a decision,
+ * not a render: "retry, insert, or report failure" is a pure function of two booleans
+ * and a clock, and the failure mode when it is wrong is silence — the dialog closes and
+ * nothing happens, which is exactly the bug class this whole surface exists to end.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+/** What one readiness attempt found. */
+export interface ReadinessProbe {
+    /** Whether a session id could be resolved at all (the catalog has it). */
+    hasTarget: boolean;
+    /** Whether the insert actually landed (the workspace could resolve the root). */
+    inserted: boolean;
+}
+/** What the caller should do next. */
+export type ReadinessAction = 
+/** Try again shortly: the ordinary race, not a refusal. */
+'retry'
+/** Everything landed. */
+ | 'done'
+/** Out of time with no session to target. */
+ | 'failed-no-target'
+/** Out of time with a session but nothing inserted. */
+ | 'failed-insert';
+/**
+ * Decide the next move for one readiness attempt.
+ *
+ * The deadline is passed in rather than read here so the decision is reproducible in a
+ * test: a function that read the clock itself could only be tested by waiting.
+ *
+ * The ordering matters. "No target yet" and "target but no insert" are different
+ * failures and get different messages; collapsing them would tell a reader "could not
+ * insert" when in fact no conversation was ever identified.
+ * @param probe - what this attempt observed.
+ * @param expired - whether the wait budget is already spent.
+ * @returns The action the caller should take.
+ */
+export declare function decideReadiness(probe: ReadinessProbe, expired: boolean): ReadinessAction;
+/**
+ * Whether the wait budget is spent.
+ *
+ * Split out and tested because the naive version of this comparison is what broke: a
+ * deadline computed inside the retry function is recomputed on every pass, so it never
+ * expires and the "report a failure" branch becomes unreachable. A test that pins
+ * `deadline === now` to `true` is the cheapest way to keep that from coming back.
+ * @param now - current epoch milliseconds.
+ * @param deadline - the instant the budget runs out.
+ * @returns True once `now` has reached the deadline.
+ */
+export declare function isExpired(now: number, deadline: number): boolean;
+/**
+ * The deadline for a wait that starts now.
+ * @param now - current epoch milliseconds.
+ * @param budgetMs - how long the caller is willing to wait.
+ * @returns The instant the budget runs out.
+ */
+export declare function deadlineFrom(now: number, budgetMs: number): number;

package/lib/types/client/knowledgeMenuCopy.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copy for the Share dialog.
+ *
+ * The context menu's own labels are NOT here: they are `action*` keys in the shared
+ * namespace (`locales.ts`), because they are the same sentences the rest of the knowledge
+ * surface uses for the same verbs, and two copies of one sentence drift. What stays local
+ * is the dialog's copy, which is longer, dialog-specific, and not addressable from the
+ * settings namespace -- putting it in `locales.ts` would also mean touching a file several
+ * other changes are editing at once.
+ *
+ * `SHARE_ZH` is typed as the English record, so a key added to one and forgotten in the
+ * other fails to compile rather than rendering an English sentence inside a Chinese
+ * dialog.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+import type { ShareDialogCopy } from './KnowledgeShareDialog.tsx';
+/**
+ * Resolve the share-dialog copy for one locale tag.
+ * @param locale - the reader's locale tag, as the page received it.
+ * @returns The English or Chinese record.
+ */
+export declare function shareCopyFor(locale: string | undefined): ShareDialogCopy;

package/lib/types/client/locales.d.ts

@@ -0,0 +1,505 @@
+/**
+ * Knowledge-base Settings copy, in the shape every locale-backed DSH client
+ * plugin uses: one English object is the key set, and each other locale is a
+ * complete record over that key set so a missing translation fails to compile.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client/locales
+ */
+/** English knowledge-base copy. */
+export declare const en: {
+    readonly nav: "Knowledge base";
+    readonly title: "Knowledge base";
+    readonly description: "Browse the mounted knowledge tree. Retrieval reads those directories directly, so there is nothing to index.";
+    readonly storageMode: "Storage";
+    readonly storageModeIntro: "Storage location";
+    readonly storageModeLocal: "Local";
+    readonly storageModeRemote: "Remote (NFS)";
+    readonly storageModeLocalHint: "Stored in the workspace. No mount or sync.";
+    readonly storageModeRemoteHint: "Documents live in a shared NFS view that is synchronized from the authoritative tree. Requires a mount and a storage host.";
+    readonly connection: "Connection";
+    readonly host: "Storage host";
+    readonly actualRoot: "Authoritative path";
+    readonly viewRoot: "Your view";
+    readonly mountPoint: "Mounted at";
+    readonly backendUnset: "Not configured";
+    readonly backendError: "DataOps knowledge API is not answering:";
+    readonly status: "Status";
+    readonly visibleFiles: "Visible files";
+    readonly unknown: "Unknown";
+    readonly lastSync: "Last synced";
+    readonly neverSynced: "Never";
+    readonly indexing: "Scanning";
+    readonly idle: "Idle";
+    readonly actions: "Actions";
+    readonly buildIndex: "Rescan";
+    readonly refresh: "Refresh";
+    readonly loading: "Loading…";
+    readonly unavailable: "Knowledge base is unavailable.";
+    readonly unavailableDetail: "The plugin could not reach its own Host routes. This state is shown instead of hidden so the failure is diagnosable.";
+    readonly unauthorized: "Your DataOps session cannot read the knowledge base.";
+    readonly retry: "Retry";
+    readonly grants: "Authorized paths";
+    readonly grantsEmpty: "No paths are authorized for you yet.";
+    readonly grantsManaged: "Authorization is managed in DataOps.";
+    readonly menu: "Sections";
+    readonly 'menu.search': "Search";
+    readonly actionDownload: "Download";
+    readonly actionRename: "Rename…";
+    readonly actionPin: "Pin";
+    readonly actionUnpin: "Unpin";
+    readonly actionReference: "Reference in chat";
+    readonly actionPermissions: "Permissions…";
+    readonly renamePrompt: "New name";
+    readonly renameFailed: "Could not rename: the file may already exist or you may not have write access.";
+    readonly downloadFailed: "Could not download this file.";
+    readonly 'menu.home': "Home";
+    readonly 'menu.permissions': "Permissions";
+    readonly 'menu.indexing': "Directories & counts";
+    readonly 'menu.trash': "Trash";
+    readonly brand: "Wanxiang Knowledge";
+    readonly collapseRail: "Collapse the sidebar";
+    readonly expandRail: "Expand the sidebar";
+    readonly sectionKnowledge: "Knowledge base";
+    readonly sectionPinned: "Pinned";
+    readonly actionFilter: "Filter this tree";
+    readonly actionNew: "New knowledge document";
+    readonly filterPlaceholder: "Filter by file name…";
+    readonly filterNoMatch: "No file in this tree matches that filter.";
+    readonly homeNewTitle: "New";
+    readonly homeNewBody: "Start a knowledge document from a blank page.";
+    readonly homeUploadTitle: "Upload";
+    readonly homeUploadBody: "Bring existing files into the knowledge base.";
+    readonly homeTemplateTitle: "Templates";
+    readonly homeTemplateBody: "Start from a template the team already uses.";
+    readonly homeTabRecent: "Recently opened";
+    readonly homeTabMine: "Owned by me";
+    readonly homeTabShared: "Shares";
+    readonly homeTabStarred: "Starred";
+    readonly homeColTitle: "Title";
+    readonly homeColLocation: "Location";
+    readonly homeColOwner: "Owner";
+    readonly cardItemNewDoc: "New document";
+    readonly cardItemNewFolder: "New folder";
+    readonly cardItemUploadFile: "Upload file";
+    readonly cardItemUploadFolder: "Upload folder";
+    readonly cardItemOpenTemplates: "Open template library";
+    readonly uploadDone: "Uploaded {n} file(s).";
+    readonly uploadPartial: "Uploaded {ok}, failed {failed}: {names}";
+    readonly cardNotYet: "Not available in this build yet";
+    readonly cardBusyCreating: "Creating...";
+    readonly cardCreated: "Created";
+    readonly cardCreateFailed: "Could not create it";
+    readonly cardNeedsPath: "Enter a name first";
+    readonly templateTitle: "Template library";
+    readonly templateSearch: "Search templates";
+    readonly templateEmpty: "No templates yet. Add one under Manage.";
+    readonly templateUnavailable: "Templates could not be read just now. Try again later.";
+    readonly templateLoading: "Loading templates...";
+    readonly templateClose: "Close";
+    readonly templatePick: "Use this template";
+    readonly homeColOwnerUnset: "Not recorded";
+    readonly homeColCreated: "Created";
+    readonly homeColOpened: "Last opened";
+    readonly homeEmpty: "Nothing here yet.";
+    readonly trashEmpty: "Trash is empty";
+    readonly trashPending: "Deleting a document is not enabled yet. The knowledge tree is shared, and how long a deletion is kept is still being decided.";
+    readonly mountPointMissing: "The knowledge tree is not mounted in this workspace.";
+    readonly viewNotBuilt: "Your visible directory has not been generated yet.";
+    readonly viewNotBuiltHint: "It is generated on first read, or from \"Rebuild my visible directory\".";
+    readonly path: "Path";
+    readonly subjectType: "Principal kind";
+    readonly subjectId: "Principal";
+    readonly permission: "Permission";
+    readonly grant: "Grant";
+    readonly granting: "Granting…";
+    readonly grantDone: "Granted.";
+    readonly grantNeedsPath: "Enter a path and a principal.";
+    readonly grantNeedsUser: "A user principal takes a user UUID, not a username.";
+    readonly revoke: "Revoke";
+    readonly revokeDone: "Revoked.";
+    readonly colPrincipal: "Principal";
+    readonly colKind: "Kind";
+    readonly colPermission: "Permission";
+    readonly colResources: "Accessible paths";
+    readonly colLatest: "Latest grant";
+    readonly actionsUnit: "{count} permission(s)";
+    readonly resourcesUnit: "{count} path(s)";
+    readonly grantsUnit: "{count} grant(s)";
+    readonly grantsByPrincipal: "Authorized by principal";
+    readonly grantsByPrincipalHint: "One row per principal: what it may do, and which paths that covers.";
+    readonly actionRead: "Read only";
+    readonly actionWrite: "Read and write";
+    readonly actionManage: "Manage";
+    readonly grantedAt: "Granted at";
+    readonly 'subject.user': "User";
+    readonly 'subject.user.hint': "User UUID, or pick from the list";
+    readonly 'subject.role': "Role";
+    readonly 'subject.role.hint': "Role code, or pick from the list";
+    readonly 'subject.department': "Department";
+    readonly 'subject.department.hint': "Department code, or pick from the list";
+    readonly 'subject.group': "Group";
+    readonly 'subject.group.hint': "Group code, or pick from the list";
+    readonly chooseOption: "Choose…";
+    readonly pickerUnavailable: "The directory is unavailable; type the identifier instead.";
+    readonly rescan: "Rescan";
+    readonly referenceFile: "Reference in chat";
+    readonly refPickerTitle: "Reference in a conversation";
+    readonly refPickerHint: "Choose the conversation that should receive this reference.";
+    readonly refPickerSearch: "Filter conversations";
+    readonly refPickerNew: "New conversation";
+    readonly refPickerNewHint: "Start a fresh conversation with this reference already in the draft.";
+    readonly refPickerCreating: "Starting a conversation…";
+    readonly refPickerNoSessions: "No conversations yet. Start a new one above.";
+    readonly refPickerNoMatch: "No conversation matches that filter.";
+    readonly refPickerNoTarget: "The host did not return a conversation to reference.";
+    readonly refPickerCreateFailed: "Could not start a conversation. Try again, or pick an existing one.";
+    readonly refPickerDone: "Reference added to the conversation draft.";
+    readonly refPickerDismiss: "Dismiss";
+    readonly pinFile: "Pin";
+    readonly unpinFile: "Unpin";
+    readonly viewSection: "Visible tree";
+    readonly viewExplainer: "Grants decide what a user may read, but the workspace mounts the shared export, so a view must also be built on disk. Sync rebuilds your own view from what DataOps currently allows.";
+    readonly viewSync: "Rebuild my visible tree";
+    readonly viewSyncing: "Rebuilding…";
+    readonly viewSynced: "Checked {considered} paths, {resolved} allowed; linked {linked}, removed {unlinked}.";
+    readonly viewSyncFailed: "Could not rebuild the view.";
+    readonly permNew: "New grant";
+    readonly permNewHint: "Grant a principal access to one path.";
+    readonly permCount: "{count} principal(s)";
+    readonly overviewByPerson: "By person";
+    readonly overviewByResource: "By resource";
+    readonly overviewEmpty: "No grants yet. Grant a document or folder to someone to see them here.";
+    readonly overviewHeld: "{count} item(s)";
+    readonly overviewRoles: "Roles";
+    readonly overviewActions: "Actions";
+    readonly overviewRolesHeading: "Roles in use";
+    readonly overviewNoActions: "None";
+    readonly grantDialogHint: "Pick the principal kind first: the backend matches a different identifier per kind.";
+    readonly colExpiry: "Valid until";
+    readonly expiryNever: "No expiry";
+    readonly overviewTabsLabel: "Grant views";
+    readonly overviewStatPrincipals: "Principals";
+    readonly overviewStatResources: "Paths";
+    readonly overviewStatGrants: "Grants";
+    readonly overviewStatRoles: "Roles in use";
+    readonly overviewColResource: "Resource";
+    readonly overviewColHolders: "Who has access";
+    readonly overviewColKindOfResource: "Type";
+    readonly overviewKindFile: "File";
+    readonly overviewKindDirectory: "Folder";
+    readonly revokeConfirmTitle: "Revoke this access?";
+    readonly revokeConfirmBody: "This removes {count} grant(s) for {name}. The file itself is untouched.";
+    readonly revokeConfirmNeeds: "Removes every grant this row lists.";
+    readonly confirm: "Confirm";
+    readonly cancel: "Cancel";
+    readonly revoking: "Revoking…";
+    readonly colDirectory: "Directory";
+    readonly colFileCount: "Files";
+    readonly colSearchable: "Searchable";
+    readonly colLastChange: "Last change";
+    readonly searchableYes: "Searchable";
+    readonly searchableNo: "Not searchable";
+    readonly partialCountMark: "+";
+    readonly partialCountHint: "A subdirectory could not be read, so this count is a lower bound.";
+    readonly rootDirectory: "All files";
+    readonly directoriesEmpty: "No directory to report yet.";
+    readonly rescanAll: "Rescan all";
+    readonly rescanRow: "Rescan";
+    readonly colTrashName: "Name";
+    readonly colTrashOrigin: "Original location";
+    readonly colTrashDeletedAt: "Deleted at";
+    readonly colTrashRetention: "Retention left";
+    readonly trashRestore: "Restore";
+    readonly trashRestored: "Restored. If access to it was withdrawn while it sat here, it stays hidden.";
+    readonly trashNoExpiry: "No expiry";
+    readonly trashReadFailed: "Could not read the trash.";
+    readonly trashWriteFailed: "That did not go through.";
+    readonly trashPurge: "Delete permanently";
+    readonly trashEmptyRow: "Trash is empty";
+    readonly permissionReadable: "You may read this";
+    readonly permissionDenied: "Not authorized for you";
+    readonly rescanning: "Scanning…";
+    readonly rescanDone: "Rescanned.";
+    readonly rescanFailed: "Could not rescan.";
+    readonly notMounted: "Not mounted";
+    readonly previewEmpty: "Select a file to preview it.";
+    readonly previewBinary: "This file is binary and cannot be shown as text.";
+    readonly previewBinarySize: "This file is binary and cannot be shown as text. {size} bytes.";
+    readonly previewFailed: "Could not read this file.";
+    readonly previewTruncated: "This file is large; only the start is shown.";
+    readonly modifiedAt: "Modified";
+    readonly openedInSidebar: "Opened in the file window on the right.";
+    readonly copyCode: "Copy";
+    readonly copiedCode: "Copied";
+    readonly retrieval: "Retrieval";
+    readonly recentFiles: "Files, newest changes shown with their time";
+    readonly searchPlaceholder: "Search by file name or content…";
+    readonly searching: "Searching…";
+    readonly searchEmpty: "No document matches that term.";
+    readonly treeEmpty: "No documents in the knowledge base yet.";
+    readonly searchFailed: "Search failed.";
+    readonly filesUnit: "files";
+    readonly indexStarted: "Rescan started.";
+    readonly indexFailed: "Could not scan the directories.";
+    readonly readOnly: "Read-only here";
+    readonly deploy: "Deployment";
+    readonly deployIntro: "Prepare document parsing and the shared storage export. Every step is safe to run again.";
+    readonly deployHost: "Target host";
+    readonly deployNoHosts: "No SSH hosts are configured";
+    readonly deployHostsError: "Could not read the SSH host list:";
+    readonly deployNoCredential: "This host has no credential configured. Add one in the SSH Manager first.";
+    readonly deployRun: "Run";
+    readonly deployRunning: "Running…";
+    readonly deploySucceeded: "Succeeded";
+    readonly deployFailed: "Failed";
+    readonly 'step.probe': "Check environment";
+    readonly 'step.mineru-install': "Install MinerU and models";
+    readonly 'step.mineru-service': "Start the parsing service";
+    readonly 'step.mineru-verify': "Verify parsing";
+    readonly 'step.nfs-deploy': "Deploy the storage export";
+    readonly 'step.nfs-verify': "Verify hardlinks across NFS";
+    readonly outlineTitle: "Outline";
+    readonly gridRoot: "Knowledge base";
+    readonly viewList: "List";
+    readonly viewGrid: "Grid";
+    readonly viewExplorer: "System file tree";
+    readonly filesSelected: "{count} selected";
+    readonly moveSelected: "Move to…";
+    readonly pinSelected: "Pin";
+    readonly clearSelection: "Clear";
+    readonly moveFailed: "Could not move: {reason}";
+    readonly 'menu.settings': "Settings";
+    readonly settingsReviewHeading: "Review before publishing";
+    readonly settingsReviewHint: "";
+    readonly settingsReviewLabel: "Require review";
+    readonly settingsReviewOn: "On";
+    readonly settingsReviewOff: "Off";
+    readonly settingsReadOnly: "You can read these settings but not change them: changing review requires write access.";
+    readonly settingsLoading: "Loading settings...";
+    readonly settingsLoadFailed: "Could not read the settings.";
+    readonly settingsSaved: "Saved.";
+    readonly settingsSaveFailed: "Could not save the setting.";
+    readonly settingsPendingHeading: "Waiting for review";
+    readonly settingsPendingHint: "";
+    readonly settingsPendingEmpty: "Nothing is waiting for review.";
+    readonly pendingReadOnly: "You can see the queue but not decide it: approving or rejecting requires write access.";
+    readonly pendingApproved: "Approved and published.";
+    readonly pendingRejected: "Rejected and discarded.";
+    readonly pendingDecideFailed: "Could not record the decision.";
+    readonly colPendingWhen: "Submitted";
+    readonly colPendingSubmitter: "Submitter";
+    readonly colPendingTarget: "Target";
+    readonly colPendingSize: "Size";
+    readonly colPendingDecision: "Decision";
+    readonly pendingApprove: "Approve";
+    readonly pendingReject: "Reject";
+    readonly auditActionApprove: "Approve";
+    readonly auditActionReject: "Reject";
+    readonly auditOutcomeRejected: "Rejected";
+    readonly settingsAuditHeading: "Audit trail";
+    readonly settingsAuditHint: "";
+    readonly settingsAuditEmpty: "No recorded changes yet.";
+    readonly colAuditWhen: "When";
+    readonly colAuditActor: "Actor";
+    readonly colAuditAction: "Action";
+    readonly colAuditTarget: "Target";
+    readonly colAuditOutcome: "Result";
+    readonly auditActionCreate: "Create";
+    readonly auditActionUpload: "Upload";
+    readonly auditActionMove: "Move";
+    readonly auditActionEdit: "Edit";
+    readonly auditOutcomeApplied: "Applied";
+    readonly auditOutcomePending: "Pending review";
+    readonly storageProtocol: "Protocol";
+    readonly protocolNfs: "NFS";
+    readonly protocolSshfs: "SSHFS";
+    readonly protocolNfsHint: "Mounts the export directly. Needs the storage host to accept NFS from this host.";
+    readonly protocolSshfsHint: "Mounts over SSH. Use it where NFS cannot reach, such as a host behind NAT.";
+    readonly nfsServer: "NFS server";
+    readonly nfsServerPlaceholder: "e.g. 10.0.0.5";
+    readonly sshHost: "Host";
+    readonly sshHostPlaceholder: "e.g. 154.201.72.205";
+    readonly sshUser: "User";
+    readonly sshUserPlaceholder: "e.g. root";
+    readonly sshPort: "Port";
+    readonly sshRemotePath: "Remote path";
+    readonly sshRemotePathPlaceholder: "e.g. /srv/kb-nfs";
+    readonly sshMountOptions: "Mount options";
+    readonly sshMountOptionsPlaceholder: "e.g. ro,allow_other";
+    readonly sshKey: "Private key";
+    readonly sshKeyUnset: "Not set";
+    readonly sshKeyConfigured: "Configured";
+    readonly sshKeyMissing: "Not configured";
+    readonly save: "Save";
+    readonly saving: "Saving...";
+    readonly savedOk: "Saved.";
+    readonly savedRestart: "Mount changes take effect after the workspace container restarts.";
+    readonly saveBadPort: "Port must be a whole number between 1 and 65535.";
+    readonly bucketGlobal: "Everyone";
+    readonly bucketDepartment: "Department";
+    readonly bucketPersonal: "Personal";
+    readonly 'step.nfs-mount': "Mount the storage export";
+    readonly 'step.sshfs-mount': "Mount the share over SSHFS";
+    readonly 'step.sshfs-verify': "Verify the SSHFS mount";
+    readonly deployLocalOnly: "Deployment steps run on a remote host. This workspace stores documents locally, so there is nothing to deploy.";
+    readonly shareGroupReceived: "Inbound";
+    readonly shareGroupGiven: "Outbound";
+    readonly shareColRelation: "Sharing";
+    readonly shareColAudience: "Shared with";
+    readonly shareColPermission: "Permission";
+    readonly shareReceivedEmpty: "Nothing has been shared with you yet.";
+    readonly shareGivenEmpty: "You have not shared anything yet.";
+    readonly shareGivenRelation: "Me → {audience}";
+    readonly shareReceivedRelation: "From resource owner";
+    readonly shareUnknownAudience: "Unknown principal";
+    readonly refPickerBack: "Back";
+    readonly actionFavoriteMany: "Add {n} to favourites";
+    readonly actionUnfavoriteMany: "Remove {n} from favourites";
+    readonly actionCopyMany: "Copy {n} items";
+    readonly actionCutMany: "Cut {n} items";
+    readonly actionDeleteMany: "Delete {n} items (move to trash)";
+    readonly refPickerBatchTitle: "Reference {n} items in a chat";
+    readonly refPickerFailed: "Could not insert the reference into that chat.";
+    readonly dropHomeHint: "Drop to upload into your personal folder";
+    readonly progressTitle: "Progress";
+    readonly progressRoot: "Root";
+    readonly overviewByRole: "By role";
+    readonly sourceDirect: "Direct";
+    readonly sourceViaRole: "Via role {role}";
+    readonly sourceUnavailable: "Inheritance unavailable (requires admin access)";
+    readonly emptyByPerson: "No account is granted access directly.";
+    readonly emptyByRole: "No role is granted access.";
+    readonly emptyByResource: "No resource is granted access.";
+    readonly actionsUnknown: "Unknown";
+    readonly actionsUnknownHint: "Could not determine the full permission set";
+    readonly colAccount: "Account";
+    readonly colSource: "Source";
+    readonly roleMemberCount: "{count} member(s)";
+    readonly homeStarredEmpty: "Nothing starred yet.";
+    readonly menuExtractMarkdown: "Extract Markdown";
+    readonly extractRunning: "Extracting…";
+    readonly extractDone: "Markdown extracted";
+    readonly extractExists: "Markdown already exists";
+    readonly extractUnsupported: "This file type cannot be extracted";
+    readonly extractFailed: "Extraction failed: {reason}";
+    readonly dropFailed: "{ok} uploaded, {n} failed: {names}";
+    readonly dropDismiss: "Dismiss";
+    readonly dropUploading: "Uploading…";
+    readonly dropNeedsFolder: "Drop onto a folder";
+    readonly dropNoFiles: "No files to upload";
+    readonly progressUploadGroup: "Uploads";
+    readonly progressExtractGroup: "Extractions";
+    readonly progressUploading: "Uploading {done}/{total}";
+    readonly progressPending: "Queued";
+    readonly progressExtracting: "Extracting";
+    readonly progressExtractingVia: "Extracting ({via})";
+    readonly progressSucceeded: "Done";
+    readonly progressFailed: "Failed: {reason}";
+    readonly progressUnsupported: "This file type has no extractor";
+    readonly progressRetry: "Retry";
+    readonly progressCollapse: "Collapse";
+    readonly progressExpand: "Expand";
+    readonly progressSummary: "{uploaded} uploaded, {failed} failed";
+    readonly progressSummaryExtract: "{done} extracted, {failed} failed";
+    readonly progressRetrying: "Retrying…";
+    readonly progressRetryFailed: "Retry failed: {reason}";
+    readonly auditPagePrev: "Previous";
+    readonly auditPageNext: "Next";
+    readonly auditPageOf: "Page {page} of {pages}";
+    readonly auditPageSize: "Rows";
+    readonly auditPageSizeOption: "{size}";
+    readonly auditPageTotal: "{total} entries";
+    readonly settingsMineruHeading: "MinerU service address";
+    readonly settingsMineruHint: "Where documents are parsed. Leave it empty to use the port this deployment was configured with.";
+    readonly settingsMineruPlaceholder: "Leave empty to derive from the configured port";
+    readonly settingsMineruDerived: "Currently derived from the configured port.";
+    readonly settingsMineruExplicit: "Currently using the address above.";
+    readonly settingsSave: "Save";
+    readonly settingsSaving: "Saving…";
+    readonly ownerGlobal: "Everyone";
+    readonly ownerSelf: "Me";
+    readonly favoriteMark: "Favorited";
+    readonly actionCopy: "Copy";
+    readonly actionCut: "Cut";
+    readonly actionPaste: "Paste";
+    readonly actionPasteCopy: "Paste as copy";
+    readonly actionPasteCut: "Paste as move";
+    readonly actionDelete: "Delete";
+    readonly actionFavorite: "Add to favorites";
+    readonly actionUnfavorite: "Remove from favorites";
+    readonly actionShare: "Share";
+    readonly pasteFailed: "Could not paste.";
+    readonly deleteFailed: "Could not delete.";
+    readonly templateSubtitle: "Start from a document your team already agreed on.";
+    readonly templateTabLibrary: "Templates";
+    readonly templateTabManage: "Manage";
+    readonly templateUseInto: "Create in";
+    readonly templateUsing: "Copying…";
+    readonly templateUsed: "Created {path}";
+    readonly templateUseFailed: "Could not use this template.";
+    readonly templateNoMatch: "No template matches that search.";
+    readonly templateUnavailableReason: "Templates could not be read: {reason}";
+    readonly templateFileBadge: "file";
+    readonly templateAdd: "Add template";
+    readonly templateEdit: "Edit";
+    readonly templateRemove: "Take offline";
+    readonly templateManageEmpty: "No templates yet. Add one to get started.";
+    readonly templateName: "Name";
+    readonly templateNamePlaceholder: "For example: weekly report";
+    readonly templateDescription: "Description";
+    readonly templateDescriptionPlaceholder: "One line about when to use it";
+    readonly templateCategory: "Category";
+    readonly templateCategoryPlaceholder: "For example: report";
+    readonly templateTags: "Tags";
+    readonly templateTagsPlaceholder: "Comma separated, optional";
+    readonly templateDocument: "Document";
+    readonly templateFileChosen: "Using {name}";
+    readonly templateFileKept: "Keeping the stored file: {name}";
+    readonly templateFileUnreadable: "Could not read that file.";
+    readonly templateNeedTitle: "Give the template a name.";
+    readonly templateNeedFile: "Choose a document for the template.";
+    readonly templateSave: "Save";
+    readonly templateSaving: "Saving…";
+    readonly templateSaved: "Template saved.";
+    readonly templateSaveFailed: "Could not save the template.";
+    readonly templateRemoveTitle: "Take this template offline?";
+    readonly templateRemoveBody: "\"{name}\" will stop appearing in the library. The document is removed too.";
+    readonly templateRemoved: "Template taken offline.";
+    readonly templateRemoveFailed: "Could not take the template offline.";
+    readonly 'menu.audit': "Audit";
+    readonly auditTabReview: "Review";
+    readonly auditTabLog: "Log";
+    readonly auditTabsLabel: "Audit views";
+    readonly readFailed: "Could not read the authorization list.";
+    readonly grantFailed: "Could not grant access.";
+    readonly revokeFailed: "Could not revoke access.";
+    readonly createDialogHint: "Name it, then choose where it goes.";
+    readonly createUploadHint: "Choose files, then where they go.";
+    readonly createName: "Name";
+    readonly createDocPlaceholder: "For example: meeting-notes";
+    readonly createFolderPlaceholder: "For example: 2026-specs";
+    readonly createDestinationPicker: "Location";
+    readonly createDestination: "Destination";
+    readonly createAtRoot: "Top level";
+    readonly createAtUp: "Up one level";
+    readonly createLoading: "Loading folders…";
+    readonly createNoSubfolders: "No folders inside this one.";
+    readonly createListingFailed: "Could not list this folder; you can still create here.";
+    readonly createWillCreate: "Will create: {path}";
+    readonly createSubmit: "Create";
+    readonly createUpload: "Upload";
+    readonly createProgress: "Uploading {done}/{total}…";
+    readonly createPickFiles: "Choose at least one file.";
+    readonly createFiles: "Files";
+    readonly createMoreFiles: "+{n} more";
+    readonly createDone: "Created {path}";
+    readonly createNameEmpty: "Enter a name.";
+    readonly createNameSeparator: "A name cannot contain / or \\";
+    readonly createNameTraversal: "A name cannot be . or ..";
+    readonly deployAboutRemote: "What remote deployment does";
+    readonly deployAboutRemoteBody: "A remote deployment syncs documents from a shared NFS or SSHFS export. Its wizard prepares that host, installs the parsing service, and verifies the mount.";
+};
+/** Stable key set shared by every knowledge-base locale. */
+export type KnowledgeKey = keyof typeof en;
+/** Chinese knowledge-base copy. */
+export declare const zh: Record<KnowledgeKey, string>;