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

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

@@ -0,0 +1,438 @@
+/**
+ * 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: "Shared with me";
+    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 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>;

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

@@ -0,0 +1,62 @@
+/**
+ * Open a knowledge document in the product's own right-hand file window.
+ *
+ * The knowledge page does not draw a document preview of its own. Opening a document
+ * hands it to the host's sidebar, which is the surface every other file in the
+ * workspace opens into: tab strip, path input, preview/edit toggle, save, refresh,
+ * outline. The knowledge page owns none of that chrome.
+ *
+ * Two host services are involved, both published before any panel mounts:
+ *
+ * - `sidebarRight` (`ui-sidebar-right`) owns the column. Its `openResource` claims the
+ *   address, places it, and **reveals the column in the same step** -- the column
+ *   expands as part of opening, so a document handed to it cannot land in a collapsed
+ *   panel the reader never sees.
+ * - `sidebarRightTabs` is the tab-type registry, whose ranking decides which kind
+ *   claims a file address. Asking it keeps this open on the host's normal path instead
+ *   of hard-coding a kind.
+ *
+ * The address is built with the official `fileAddressFor`, so a document opened from
+ * here dedupes against the tab the chat file-link path already opened for the same
+ * file rather than opening a second tab onto it.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+/** Outcome of asking the host to show a document. */
+export type OpenOutcome = 'opened' | 'no-context' | 'no-registry' | 'unclaimed' | 'no-column';
+/**
+ * Ask the host to open a document in its right-hand file window.
+ *
+ * @param ctx - the client context the page was injected with.
+ * @param sessionId - the conversation the sidebar column is scoped to.
+ * @param cwd - the session's workspace root, used to shorten the address to a
+ *   session-relative one so it dedupes against chat-opened tabs.
+ * @param absolutePath - the document's absolute path inside the workspace.
+ * @returns Why it did or did not open; the caller reports the failure rather than
+ *   appearing to do nothing.
+ */
+export declare function openInSidebar(ctx: unknown, sessionId: string | undefined, cwd: string | undefined, absolutePath: string): OpenOutcome;
+/**
+ * Return the right column's width to the page.
+ *
+ * Called when the knowledge page stops showing a document. It is deliberately separate
+ * from {@link openInSidebar} rather than a mode flag: the two states need different
+ * frames, and closing the track is what restores the page's own width. A host without
+ * the layout service is left alone -- the page simply keeps whatever it had.
+ * @param ctx - the client context the page runs in.
+ */
+/**
+ * Report whether the host's right column is currently expanded.
+ *
+ * The page uses this to decide whether it may keep its own content column: a document
+ * opened in the reader means the page's column is redundant, but only while the reader
+ * is actually on screen. Reading it live (instead of tracking it in React state) keeps
+ * the page and the frame from disagreeing when the reader closes the column themselves.
+ * A host without the column service reports `false`, which keeps the page's own layout.
+ * @param ctx - the client context the page runs in.
+ * @returns whether the column is expanded right now.
+ */
+export declare function readColumnExpanded(ctx: unknown): boolean;
+export declare function closeSidebar(ctx: unknown): void;
+/** Whether a failure means the host's right column is simply not on this profile. */
+export declare function isHostMissing(outcome: OpenOutcome): boolean;

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

@@ -0,0 +1,39 @@
+/**
+ * Who a knowledge document belongs to, derived from where it is stored.
+ *
+ * The list route reports a path and a location, not an owner: ownership is a property of
+ * the bucket, and every rule below is a rule about that bucket. Keeping the derivation
+ * here (rather than in the row renderer) does two things. It stays testable without a
+ * DOM, and it keeps the answer honest — nothing is invented when the information is not
+ * there, because a wrong owner is worse than an unflattering one.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client/ownerLabel
+ */
+/** What the caller knows about itself, as far as ownership is concerned. */
+export interface OwnerContext {
+    /** The caller's DataOps id, so `personal/<id>` can be recognised as one's own folder. */
+    callerId?: string;
+    /** The caller's own department code, for naming the department bucket. */
+    departmentCode?: string;
+    /** The caller's own department name; falls back to the code when absent. */
+    departmentName?: string;
+}
+/** One resolved owner cell. */
+export interface OwnerLabel {
+    /** Which rule produced the label, so the renderer can style it without re-parsing. */
+    kind: 'global' | 'department' | 'self' | 'person' | 'unknown';
+    /** The text to show. */
+    label: string;
+}
+/**
+ * Resolve the owner of one document.
+ *
+ * `labels` carries the three strings this module cannot know: what to call the shared
+ * bucket, what to call the caller's own folder, and what to show when a path is outside
+ * every bucket. Passing them in keeps the module free of locale plumbing.
+ */
+export declare function ownerLabelOf(relPath: string, context: OwnerContext, labels: {
+    global: string;
+    self: string;
+    unknown: string;
+}): OwnerLabel;

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

@@ -0,0 +1,94 @@
+/**
+ * The pure half of the permissions overview: how one grant table reads two ways.
+ *
+ * Kept apart from the rendering module for a real reason, not for tidiness: a
+ * component module imports the primitives package, which imports CSS, and a Node
+ * test runner cannot load a `.css` file. The grouping rules are the part worth
+ * testing without a DOM, so they live somewhere a plain import can reach.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client/permissionRows
+ */
+import type { GrantView, KnowledgeGrantSubjectType } from '../api.ts';
+/** One person's holdings, as the person view renders them. */
+export interface PersonHoldings {
+    /** Principal id the grants name. */
+    principalId: string;
+    /** Principal kind, so the type column can name it. */
+    principalType: KnowledgeGrantSubjectType;
+    /** Display name when a directory entry resolved one, else the id. */
+    label: string;
+    /** Distinct paths this person may touch. */
+    paths: string[];
+    /** Which actions the person holds, collapsed so a full house reads `all`. */
+    actions: string[];
+    /**
+     * Roles the person reaches through a `role` grant they belong to.
+     *
+     * Empty when the directory does not know the membership: a role grant names the
+     * ROLE, not the people in it, so this is only populated when a directory entry
+     * declared the membership.
+     */
+    roles: string[];
+    /** Most recent grant instant across this person's rows, ISO-8601. */
+    latestAt: string;
+    /** The grants this row covers, so a revoke can name exactly what it removes. */
+    grants: GrantView[];
+}
+/** One resource and everyone who may reach it. */
+export interface ResourceHoldings {
+    /** Path, relative to the mount point. */
+    relPath: string;
+    /** Whether it is a file or a directory. */
+    kind: 'file' | 'directory';
+    /** Everyone holding any action on it, grouped by principal kind. */
+    principals: Array<{
+        principalType: KnowledgeGrantSubjectType;
+        principalId: string;
+        label: string;
+        actions: string[];
+        latestAt: string;
+        grants: GrantView[];
+    }>;
+}
+/**
+ * Collapse a set of action strings into the shortest describing list.
+ *
+ * Mirrors the server's collapse rule without importing it: this file is bundled
+ * for the browser and must not pull the server module in. Keeping the rule in
+ * two places is a real cost, so it is stated once here and covered by the same
+ * expectations as the server's own test.
+ *
+ * @param actions - raw action strings from grants.
+ * @returns `['all']` when everything is held, else the concrete subset in order.
+ */
+export declare function summarizeActions(actions: readonly string[]): string[];
+/**
+ * Group grants by the principal they name.
+ *
+ * A principal appearing in several grants is one row: "what does 张三 have" is a
+ * question about a person, and splitting them across rows because they hold two
+ * paths would answer it wrong.
+ *
+ * @param grants - the grant table.
+ * @param labels - display names by `principalType:principalId`, optional.
+ * @returns one entry per principal, ordered by label then id.
+ */
+export declare function groupHoldingsByPrincipal(grants: readonly GrantView[], labels?: Readonly<Record<string, string>>): PersonHoldings[];
+/**
+ * Group grants by the resource they cover.
+ *
+ * @param grants - the grant table.
+ * @param labels - display names by `principalType:principalId`, optional.
+ * @returns one entry per path, ordered by path.
+ */
+export declare function groupHoldingsByResource(grants: readonly GrantView[], labels?: Readonly<Record<string, string>>): ResourceHoldings[];
+/**
+ * Format a grant instant the way the reference table does.
+ *
+ * DataOps' permission preview prints `YYYY/MM/DD HH:mm` and a dash for a missing
+ * value, so a reader comparing the two surfaces sees the same date. The raw
+ * ISO-8601 string the API returns is not that.
+ * @param value - ISO-8601 instant, or an empty string when the backend sent none.
+ * @returns The formatted instant, or a dash when there is nothing to show.
+ */
+export declare function formatGrantInstant(value: string): string;