@jwilleke/ngdpbase-types 5.34.0 → 5.36.0

package/lib/src/ice/ledger.d.ts

@@ -1,5 +1,13 @@
 import type { IceLedger, LedgerFileEntry } from './types.js';
+/**
+ * The ledger file form (#2013). A scope is bound to its receiver and user
+ * (`boundScope`); a file without this form was written before that binding,
+ * under a scope any caller could name, so it belongs to nobody: it is read
+ * as empty, never as anyone's history, and its files are imported once more.
+ */
+export declare const LEDGER_FORM = 2;
 interface ScopeFile {
+    form?: number;
     scope: string;
     files: LedgerFileEntry[];
     items: string[];

package/lib/src/ice/runImport.d.ts

@@ -21,8 +21,24 @@ export interface IceRunDeps {
 }
 /** The id of the receiver that keeps an original when the chosen receiver does not keep its own (D11). */
 export declare const FILES_RECEIVER = "core.files";
-/** The scope a run's fingerprints are checked in, unless the caller names one. */
-export declare function defaultScope(receiverId: string, ctx: ActorContext): string;
+/**
+ * The engine's key for an item of a file it stored, so a retry of that file
+ * skips it (#2010): the file's fingerprint, the chain, and a hash of the
+ * item's content (kind, text, data, bytes). Never its position: a shim that
+ * changes or orders its output differently cannot make a retry skip the
+ * wrong item. `seen` is how many identical items came before it in this file.
+ */
+export declare function itemKeyOf(sha256: string, chain: string[], item: IceItem, seen: number): string;
+/** The form of a bound scope (#2013). Scopes written before it never match one. */
+export declare const SCOPE_FORM = "ice2";
+/**
+ * The scope a run's fingerprints, per-file status and item keys live in
+ * (#2013): bound to the receiver and to the user the run is for, by their
+ * identity `@id` (else their username, #2041). The engine works it out from
+ * the caller's context; a request cannot name another user's. A caller's own
+ * `sub` (phr's source id) narrows it within that user's scope, never outside.
+ */
+export declare function boundScope(receiverId: string, owner: string, sub?: string): string;
 export interface ChainLeaf {
     item: IceItem;
     chain: string[];

package/lib/src/ice/types.d.ts

@@ -201,7 +201,13 @@ export interface IceReceiver {
     label?: string;
     /** The kinds it takes, e.g. `['ncm']`, `['file']`, `['phr.health-record']`. */
     accepts: IceKind[];
-    /** May this context use this receiver? Its existing permission — the import screen shows only these (D5). */
+    /**
+     * May this context use this receiver? Its existing permission (D5). The
+     * import screen shows only these, and the engine asks it before any work
+     * of a run (#2012): a no refuses every file before anything is unpacked,
+     * read by a shim, kept or fetched. Answer no whenever `receive` would
+     * refuse this context outright; `receive` still checks each item.
+     */
     mayUse(ctx: ActorContext): Promise<boolean>;
     /** Hand one item to the receiver's own door. */
     receive(item: IceItem, ctx: ActorContext, info: ReceiveInfo): Promise<ReceiveOutcome>;
@@ -252,10 +258,13 @@ export interface IceRunRequest {
     /** D11. Default `ngdpbase.import.engine.default-original`. */
     original?: OriginalChoice;
     /**
-     * Whose fingerprints and item keys this run is checked against. Default
-     * `<receiver>/<username>`: the same file imported again by the same person
-     * into the same receiver is skipped. A caller with its own notion of a
-     * source (phr's source id) passes it.
+     * A narrower ledger scope within the caller's own (#2013). The engine binds
+     * every run's scope to the receiver and to the user it runs as (their
+     * identity `@id`, else their username): the same file imported again by
+     * the same user into the same receiver is skipped. A caller with its own
+     * notion of a source (phr's source id) passes it to keep those apart; it
+     * can never reach another user's or another receiver's scope. Never pass a
+     * value a client sent.
      */
     scope?: string;
 }

package/lib/src/managers/AddonsManager.d.ts

@@ -12,6 +12,7 @@
  */
 import { type ActorContext } from '../context/ActorContext.js';
 import type { BackupFolder } from './BaseManager.js';
+import { type UpdateCheck, type UpdateOutcome } from '../utils/addonInstaller.js';
 import BaseManager from './BaseManager.js';
 import type { BackupData } from './BaseManager.js';
 import type { WikiEngine } from '../types/WikiEngine.js';
@@ -302,6 +303,9 @@ export interface AddonDashboardCard {
     /** URL of the add-on's admin page */
     adminUrl: string;
 }
+/** #2100: the PDP refused an administrator's add-on Update or Check. */
+export declare class AddonUpdateForbiddenError extends Error {
+}
 /**
  * Status information returned by getStatus()
  */
@@ -344,6 +348,10 @@ declare class AddonsManager extends BaseManager {
     private installedDir;
     /** #1830: the installed add-ons verified this boot — the only ones loaded from `installedDir`. */
     private verifiedInstalled;
+    /** #2100: installed add-ons this start switched to an Update's release; settled after the load pass. */
+    private updatedThisStart;
+    /** #2100: Updates run one at a time, so two never write the lock file at once. */
+    private updateQueue;
     /** Stylesheets registered by add-ons via registerStylesheet() */
     private registeredStylesheets;
     /** Dashboard cards registered by add-ons via registerDashboardCard() */
@@ -374,6 +382,14 @@ declare class AddonsManager extends BaseManager {
      * this boot, not the next.
      */
     private installConfiguredAddons;
+    /**
+     * The installer's options for this site (#1830, #2100): the registry and the
+     * limits from configuration, and every request — registry, attestations, the
+     * Sigstore TUF repository — through the guarded client and the egress policy
+     * (#1139). `timeoutKey` is the `…install.<key>` that bounds each request: the
+     * boot install's, or the shorter one an admin page waits on.
+     */
+    private installerOptions;
     /**
      * `addon-install` (#1830): written after every check passed and before
      * anything is written to disk. on-failure: refuse — code does not join the
@@ -381,6 +397,47 @@ declare class AddonsManager extends BaseManager {
      * (recordSystemAction throws, and the installer writes nothing).
      */
     private recordAddonInstall;
+    /**
+     * #2100: after the load pass, settle each add-on this start switched to an
+     * Update's release. Loaded (or switched off, so there was nothing to try):
+     * the previous release's folder and tarball go. Not loaded: the previous
+     * release is restored on disk and in the lock, so the next start runs it.
+     * Core cannot unload an add-on that failed half-way (its modules, routes and
+     * jobs stay), so the restored release is not loaded in this process.
+     */
+    private settleUpdatedAddons;
+    /**
+     * `addon-update` (#2100) for a fall-back: core moved an installed add-on back
+     * from `from` to `to` because `from` did not load. on-failure: continue for
+     * this record — the fall-back has already happened on disk, and a lost
+     * record must not undo it.
+     */
+    private recordFallback;
+    /** #2100: the door for the admin's add-on questions. Throws when the PDP refuses. */
+    private requireAddonPermission;
+    /**
+     * #2100: for each add-on in `ngdpbase.addons.install`, the pinned release,
+     * the configured range, and the newest release in it that is newer — asked
+     * of the registry now. Called when an administrator opens the add-ons page
+     * or presses Check; never at start. Registry unreachable is an answer
+     * (`registryUnreachable`), not an error.
+     */
+    checkInstalledUpdates(ctx: ActorContext): Promise<UpdateCheck[]>;
+    /**
+     * #2100: an administrator's Update. Downloads `version` of the installed
+     * add-on `slug`, checks it exactly as a first install is checked (sha512,
+     * provenance, contents, `ngdpbase.minVersion`) and stages it: it runs from
+     * the next start. Asks the PDP for `config-manage`. Recorded as
+     * `addon-update` (who, the add-on, from and to) before anything is written;
+     * a record that cannot be written stops the Update.
+     */
+    updateInstalledAddon(ctx: ActorContext, slug: string, version: string): Promise<UpdateOutcome>;
+    /**
+     * `addon-update` (#2100): an administrator's Update, written after every
+     * check passed and before anything is written to disk. on-failure: refuse —
+     * a record that cannot be written stops the Update.
+     */
+    private recordAddonUpdate;
     /**
      * `addon-verify-failed` (#1830): an integrity, provenance, tarball, manifest,
      * lock or folder check refused (or, for a repaired folder, found it changed).

package/lib/src/managers/AttachmentManager.d.ts

@@ -320,6 +320,33 @@ declare class AttachmentManager extends BaseManager implements CatalogSource {
      * with no person behind it are refused. A refusal reads 'Permission denied'
      * so the route answers it as one (401 for an anonymous caller).
      */
+    /**
+     * Once, at start-up (#2097): the shared pool's uploaders and editors become
+     * identity @ids (`IdentityManager.convertRecordedUser`: an orphan for a
+     * name with no account, `orphan:unknown` for the pool's `Unknown`), written
+     * once through the provider, under the system context. A second start
+     * writes nothing. Counts only in the log; orphans on the dashboard. When the
+     * identity store cannot answer, nothing is written and the next start tries
+     * again. A vault's files convert when the vault is opened
+     * ({@link convertVaultUploaders}).
+     */
+    convertUploadersAtBoot(): Promise<void>;
+    /**
+     * The uploaders in the vaults of the context's own user that it can open
+     * (#2097), when they are opened: at sign-in and unlock. Each vault's files
+     * index, through its own I/O. Nothing is written when the identity store
+     * cannot answer; the next opening tries again.
+     */
+    convertVaultUploaders(ctx: ActorContext): Promise<number>;
+    /** Counts only, never a name (#2097). */
+    private reportUploaderConversion;
+    /** The identity store could not answer: nothing is converted this start, and the next start tries again (#2097). */
+    private postponeUploaderConversion;
+    /**
+     * What a file record stores for the user `username` (#2097): their identity
+     * @id, or the username when there is none or the identity store cannot answer.
+     */
+    private userReference;
     private static uploaderOf;
     /** A file is added to a private page only by someone who may edit it: the page's own decision (#1398). */
     private assertMayEditPage;

package/lib/src/managers/IdentityManager.d.ts

@@ -309,6 +309,83 @@ declare class IdentityManager extends BaseManager {
      * postpones the whole pass when it is false.
      */
     canAnswer(): boolean;
+    /**
+     * {@link convertReference} for records that may hold a value meaning "no
+     * user was recorded" (#2097): `migrated`, `unknown`, `import`
+     * ({@link NO_RECORDED_USER}) become `orphan:<value>` without a lookup,
+     * outcome `no-user`, so an account that later takes one of those names
+     * gains nothing, and the caller does not count them as needing attention.
+     * Everything else is `convertReference`'s, and throws as it does.
+     */
+    convertRecordedUser(ctx: ActorContext, stored: string): Promise<{
+        value: string;
+        outcome: 'kept' | 'orphan' | 'converted' | 'orphaned' | 'no-user';
+    }>;
+    /**
+     * What a new record stores for the user `username` (#2097): their identity
+     * `@id`; a "no user recorded" value (`migrated`, `unknown`, `import`) as
+     * its orphan form, so no account ever gains it; a principal (`anonymous`,
+     * the system principal), an `@id` or an orphan as it is; a name with no
+     * account, or any name when the store cannot answer ({@link identityIdOf}),
+     * as given. The one rule for page authors and editors, tombstones and file
+     * uploaders.
+     */
+    storedReferenceOf(ctx: ActorContext, username: string): Promise<string>;
+    /**
+     * One start-up conversion pass over stored references (#2097): `convert`
+     * is {@link convertRecordedUser}'s value, and `counts` tallies its outcomes
+     * (values converted to an @id, orphans found or made, "no user recorded"
+     * values) for the caller's counts-only report. When the store cannot
+     * answer it throws `IdentityStoreUnavailableError`, so the caller postpones
+     * its pass rather than skip a record.
+     */
+    conversionPass(ctx: ActorContext): {
+        convert: (stored: string) => Promise<string>;
+        counts: {
+            converted: number;
+            orphans: number;
+            noUser: number;
+        };
+    };
+    /**
+     * Whether a stored reference names the user `username` (#2097): it is their
+     * identity `@id`, or, on a record not yet converted, their username. An
+     * orphan (`orphan:<name>`) and a "no user recorded" value never match
+     * anyone, so a later account with the same name inherits nothing. The `@id`
+     * is looked up with {@link identityIdOf}: false when the store cannot answer.
+     */
+    refersTo(ctx: ActorContext, stored: unknown, username: string | null | undefined): Promise<boolean>;
+    /**
+     * The stored values that name the user `username` (#2097): their identity
+     * `@id` and, for records not yet converted, their username — the batch form
+     * of {@link refersTo}, for a list filter that compares many records (the
+     * page index, the search index). A "no user recorded" name is left out, and
+     * no orphan is ever in it. Only the username when the store cannot answer.
+     */
+    referencesOf(ctx: ActorContext, username: string | null | undefined): Promise<string[]>;
+    /**
+     * The username a stored reference names (#2097), for code that needs the
+     * sign-in name (a vault path, a preference): an `@id` gives its account's
+     * username, an orphan gives null, anything else (a username not yet
+     * converted, `anonymous`, the system principal) is returned as it is. Null
+     * for an `@id` with no account (deleted, or a contact's) and when the store
+     * cannot answer, logged without the value; a refusal still throws.
+     */
+    usernameOf(ctx: ActorContext, stored: unknown): Promise<string | null>;
+    /**
+     * How a stored reference to a user is shown to people (#2097, operator
+     * 2026-10-26): the username followed by the id, `jim (urn:uuid:3f6c…)`. An
+     * orphan shows as `jim (no account)`, an `@id` whose account is gone as
+     * `urn:uuid:… (no account)`; anything else (a username not yet converted,
+     * `anonymous`, the system principal) as it is. Resolved when shown, never
+     * stored. Never throws for a store that is down.
+     *
+     * `ctx` is whoever the name is shown to. Showing who wrote a page needs no
+     * `identity-read`: only the username and the id are shown, as a page always
+     * showed its author's username, so the record is read as core's own lookup
+     * (the system context, naming the caller in its reason).
+     */
+    describeReference(ctx: ActorContext, stored: unknown): Promise<string>;
     private requireProvider;
     private getMetrics;
     private normalizeProviderName;

package/lib/src/managers/ImportManager.d.ts

@@ -382,6 +382,18 @@ declare class ImportManager extends BaseManager {
     importRunsFor(ctx: ActorContext): IceRunReport[];
     /** Use this ledger instead of the file one: a test's, or a database table's. */
     setImportLedger(ledger: IceLedger): void;
+    /**
+     * The ledger scope a run uses (#2013): bound to the receiver and to the user
+     * `ctx` names, by their identity `@id`; their username only when the
+     * identity store answers that there is no record for them (#2041). Never a
+     * scope the caller names: a request's `scope` only narrows within this
+     * user's own.
+     *
+     * @throws IdentityStoreUnavailableError when the identity store cannot
+     *   answer: the run does not start, and nothing is recorded, rather than
+     *   land in a scope the user's other runs do not use
+     */
+    private importScope;
     private newRunReport;
     private executeRun;
     /** What a run, or keeping at upload, works with. */

package/lib/src/managers/PageManager.d.ts

@@ -258,6 +258,31 @@ export declare const CAPTURE_VAULT_MIGRATION = "capture-vault";
 export declare const CATEGORY_VAULT_MIGRATION = "category-vaults";
 /** Private slugs from `private--…` to `vaults--…` (#1507). */
 export declare const VAULT_SLUG_MIGRATION = "vault-slugs";
+/** Page authorship stored as identity @ids (#2097): every page and its history visited once; recorded per site and per vault. */
+export declare const AUTHORSHIP_ID_MIGRATION = "authorship-identity-ids";
+/** What one authorship conversion pass did (#2097), counts only. */
+export interface AuthorshipConversion {
+    /** `done`, or `postponed` when the identity store could not answer. */
+    status: 'done' | 'postponed';
+    /** Every page visited (`full`), or only those whose index entry still names a username. */
+    full: boolean;
+    pagesVisited: number;
+    pagesChanged: number;
+    /** Pages whose frontmatter could not be rewritten line by line, left as they are. */
+    pagesRefused: number;
+    versionsChanged: number;
+    tombstonesChanged: number;
+    converted: number;
+    orphans: number;
+    /** Orphans on shipped (documentation, system) and add-on pages: their author is upstream's, not a site user; not needing attention. */
+    shippedOrphans: number;
+    noUser: number;
+    /** Pages and tombstones skipped for their own reason (a file that cannot be read or written, a full disk, a vault that cannot be opened). */
+    pagesSkipped: number;
+    /** The error class of each skip (`EACCES`, `ENOSPC`, ...), never a message, name or path. */
+    skipErrors: string[];
+    ms: number;
+}
 /**
  * Minimal WikiContext interface for type safety
  * TODO: Convert WikiContext.js to TypeScript and import proper type
@@ -377,6 +402,15 @@ declare class PageManager extends BaseManager implements CatalogSource {
      * #754 backfill (v3.33.0).
      */
     readonly types: readonly SchemaType[];
+    /** One write at a time per page, by uuid (#2097), when the provider keeps no such lock itself. */
+    private readonly pageWrites;
+    /**
+     * Run `task` as the only write on page `key` (#2097): saves, deletes, the
+     * authorship conversion, and the provider's own restores and purges. The
+     * lock is the provider's (`withPageWrite`), so its trash work takes the same
+     * one; a provider without it gets this manager's.
+     */
+    private pageWrite;
     /**
      * On-disk schema version for the page-frontmatter shape (Decision 6).
      * Bump when the persisted Article-relevant fields on a page change. v1 is
@@ -867,6 +901,12 @@ declare class PageManager extends BaseManager implements CatalogSource {
      * @throws PageContentValidationError when a filter reports severity 'error'
      */
     private assertContentPasses;
+    /**
+     * What a page stores for the user `name` (#2097): `IdentityManager.storedReferenceOf`.
+     */
+    private referenceTo;
+    /** `audience` and each `access[action]` of a save, user entries as {@link referenceTo} stores them (#2097). */
+    private convertAccessListsForSave;
     /**
      * The frontmatter a save writes, from the frontmatter it was given (#1462).
      *
@@ -1415,6 +1455,12 @@ declare class PageManager extends BaseManager implements CatalogSource {
      * feed. New code should prefer this over enumerating getAllPages().
      */
     getRecentChanges(ctx: ActorContext, options?: RecentChangesOptions): Promise<RecentChangeEntry[]>;
+    /**
+     * A principal list (roles and the username) with the user's identity @id
+     * added (#2097), so a listing matches an access-list entry stored as the
+     * @id as the page view does (`PolicyInformationPoint` principals).
+     */
+    private principalsWithIdentityId;
     /**
      * Every indexed page carrying an `addon` provenance stamp.
      * Used by addon orphan detection; reads the in-memory index, no disk I/O.
@@ -1440,15 +1486,25 @@ declare class PageManager extends BaseManager implements CatalogSource {
      * `creator` only.
      */
     getPagesByCreator(username: string, ctx: ActorContext, options?: GetPagesByCreatorOptions): Promise<RecentChangeEntry[]>;
+    /**
+     * The stored values that name `username` (#2097): their identity @id and, for
+     * pages not yet converted, the username (`IdentityManager.referencesOf`), so
+     * "my pages" lists converted and unconverted pages alike and an orphan never.
+     */
+    private referencesOf;
     /**
      * Pages most recently edited by a user (#640 Phase 2).
      */
     getPagesByEditor(username: string, ctx: ActorContext, options?: PagesScanOptions): Promise<RecentChangeEntry[]>;
     /**
      * Pages whose frontmatter audience matches any of the caller's principals,
-     * excluding pages the caller already owns (#640 Phase 2).
+     * excluding pages the caller already owns (#640 Phase 2). `options.username`
+     * names the caller, so a page whose author is their identity @id counts as
+     * theirs (#2097).
      */
-    getPagesSharedWith(principals: string[], options?: PagesScanOptions): Promise<RecentChangeEntry[]>;
+    getPagesSharedWith(principals: string[], options?: PagesScanOptions & {
+        username?: string;
+    }): Promise<RecentChangeEntry[]>;
     /**
      * The private-container decision for a page (docs/private-stores.md,
      * Access). PolicyInformationPoint's Tier 0 asks this, so every `canAccess` on a page —
@@ -1538,6 +1594,74 @@ declare class PageManager extends BaseManager implements CatalogSource {
     migrateVaultUrlsInPublicPages(ctx: ActorContext): Promise<number>;
     /** Every vault on disk, as `owner/store` — encrypted ones included, since only their folder names are read. */
     private listVaults;
+    /**
+     * The page-authorship conversion at start-up (#2097), on the public pages:
+     * best-effort, never throws, and runs while the site serves (WikiEngine does
+     * not wait for it). See {@link convertAuthorship}.
+     */
+    convertAuthorshipAtBoot(): Promise<AuthorshipConversion | null>;
+    /**
+     * Convert the public pages' authorship to identity @ids (#2097, operator
+     * 2026-10-26), through this door's own write path, one page at a time
+     * with the saves ({@link pageWrite}):
+     *
+     * - each page's frontmatter `author` and `editor`, written without
+     *   touching its body, its other fields or its `lastModified`, and without
+     *   a new version; its page index entry follows;
+     * - its version history's editors (`manifest.json`), in place;
+     * - the tombstones' `author`, `editor` and `deletedBy`;
+     * - then the search index, rebuilt from the pages once if anything changed.
+     *
+     * Each value gets `IdentityManager.convertRecordedUser`'s answer: a
+     * username with an account becomes its @id; one with none `orphan:<name>`
+     * (counted, and on the dashboard: only an administrator acts on those
+     * pages); `migrated`, `unknown` and `import` `orphan:<value>` without a
+     * lookup (counted apart, not needing attention); @ids, orphans and
+     * principals are kept, so a second run writes nothing.
+     *
+     * The first complete pass visits every page and its history, and is then
+     * recorded in the site's migrations record; later passes visit only pages
+     * whose index entry still holds a value to convert. Pages are taken in
+     * batches of `ngdpbase.page.authorship-conversion.batch-size`, yielding
+     * between batches. When the identity store cannot answer (`canAnswer()`
+     * false, or a lookup fails mid-pass) the pass stops, says so on the
+     * dashboard, and the next start tries again. Logs counts only. Vault pages
+     * convert when their vault is opened ({@link convertVaultAuthorship}).
+     */
+    convertAuthorship(ctx: ActorContext): Promise<AuthorshipConversion | null>;
+    /**
+     * The authorship conversion for the vaults of `owner` this context can open
+     * (#2097), when they are opened: at sign-in and unlock, where the owner's
+     * keys are live. Each vault's pages (frontmatter, its own page index entry,
+     * history, access lists) and the owner's vault trash; each vault is
+     * recorded as done in its own migrations record and skipped from then on.
+     * Postponed, and tried at the next opening, when the identity store cannot
+     * answer; a page or tombstone that fails for its own reason is skipped and
+     * counted, and keeps its vault from being recorded as done.
+     */
+    convertVaultAuthorship(ctx: ActorContext, owner: string): Promise<AuthorshipConversion | null>;
+    /**
+     * How a frontmatter `audience` or `access[action]` entry converts (#2097):
+     * an entry naming a user becomes their identity @id with the pass's own rule
+     * (`orphan:<name>` for a name with no account, counted); every other kind is
+     * kept as written: a role (declared in `ngdpbase.roles.definitions` or held
+     * as a role record), the pseudo-roles `All`, `Authenticated`, `Anonymous`
+     * and `Asserted`, an `addon:`/`job:` or any other `kind:` entry, an @id or
+     * an orphan. A name that is both a role and a username stays the role.
+     */
+    private accessListConverter;
+    /** Every role name a principal list may hold, lower-cased (#2097): declared roles, role records, and the pseudo-roles. */
+    private roleNames;
+    /** Whether an index entry still holds an author or editor the conversion would change (#2097). No lookup is written. */
+    private authorshipNeedsConversion;
+    /** The system-categories whose pages are shipped with the code (source `shipped`), lower-cased (#2097). */
+    private shippedCategories;
+    /** `ngdpbase.page.authorship-conversion.batch-size`: pages converted between yields (#2097). */
+    private authorshipBatchSize;
+    /** Counts only, never a name (#2097): the log, and the dashboard for orphans and refused pages. */
+    private reportAuthorshipConversion;
+    /** The identity store could not answer: nothing more is converted this start, and the next start tries again (#2097). */
+    private postponeAuthorshipConversion;
     /**
      * Rewrite `[Title]` to `[store/Title]` in the private pages that mean it.
      *

package/lib/src/managers/SearchManager.d.ts

@@ -45,6 +45,10 @@ interface AdvancedSearchOptions {
     };
     /** #774: which date field `dateRange` filters on. Default `'modified'`. */
     dateField?: 'modified' | 'created';
+    /** A username, or several: pages whose author is that user (#2097: their identity @id or, not yet converted, the username). */
+    author?: string | string[];
+    /** As `author`, for the last editor. */
+    editor?: string | string[];
     [key: string]: unknown;
 }
 /**
@@ -240,6 +244,12 @@ declare class SearchManager extends BaseManager {
      * });
      */
     advancedSearchWithContext(wikiContext: WikiContext, options?: AdvancedSearchOptions): Promise<SearchResult[]>;
+    /**
+     * The stored values a search for `who` matches (#2097): for each username,
+     * that user's identity @id and the username (`IdentityManager.referencesOf`).
+     * Without IdentityManager, the values as given.
+     */
+    private referencesOf;
     /**
      * Search for pages matching the query
      *

package/lib/src/parsers/MarkupParser.d.ts

@@ -414,6 +414,15 @@ declare class MarkupParser extends BaseManager {
      * claiming a page is missing.
      */
     private resolvePrivateLinkTitles;
+    /**
+     * The username a PUBLIC page's author names, for a `[store/Title]` link on
+     * it (#1457, #2097): the author is stored as an identity @id, and a vault is
+     * named by its owner's username, so the @id is resolved once per parse
+     * through IdentityManager. Null when a caller already said who the owner
+     * is, on a private page (its name carries the owner), on a page with no
+     * such link, and for an author that names no account.
+     */
+    private resolveAuthorOwner;
     generateCacheKey(content: string, context: ParseContextData): string;
     /**
      * Extract style blocks using state-stack parsing for proper nesting support

package/lib/src/parsers/context/ParseContext.d.ts

@@ -186,6 +186,12 @@ declare class ParseContext {
      * Resolved once per parse by MarkupParser, never per link.
      */
     privateLinkTitles: Map<string, Set<string>> | null;
+    /**
+     * The username of a public page's author, when the author is stored as an
+     * identity @id (#2097): what a `[store/Title]` link on it resolves in.
+     * Resolved once per parse by MarkupParser; null when not needed.
+     */
+    pageOwner: string | null;
     /**
      * Hand finished HTML from a syntax handler to MarkupParser; write the
      * returned placeholder into the content instead (#1623). The HTML is merged

package/lib/src/providers/BaseSearchProvider.d.ts

@@ -101,10 +101,14 @@ export interface SearchCriteria {
     statuses?: string[];
     /** Fields to search in (title, content, category, keywords, or all) */
     searchIn?: string[];
-    /** Author to filter by (page creator — matches metadata.author) */
-    author?: string;
-    /** Editor to filter by (last modifier — matches metadata.editor) */
-    editor?: string;
+    /**
+     * Author to filter by (page creator — matches metadata.author). A list
+     * matches any of its values: SearchManager turns a username into the
+     * values that name that user, their identity @id and the username (#2097).
+     */
+    author?: string | string[];
+    /** Editor to filter by (last modifier — matches metadata.editor); a list as for `author`. */
+    editor?: string | string[];
     /** Date range */
     dateRange?: {
         from?: string;

package/lib/src/providers/BasicAttachmentProvider.d.ts

@@ -203,6 +203,20 @@ declare class BasicAttachmentProvider extends BaseAttachmentProvider implements
      * @private
      */
     private saveMetadata;
+    /**
+     * The shared pool's uploaders and editors (#2097): each record's
+     * `author.name` and `editor.name` become what `convert` answers (the
+     * identity @id), and the metadata file is written once when anything
+     * changed. `convert` may throw (the identity store cannot answer); then
+     * nothing is written. Returns how many values changed.
+     */
+    convertPoolReferences(convert: (stored: string) => Promise<string>): Promise<number>;
+    /**
+     * One vault's uploaders (#2097): each entry's `author` in the vault's own
+     * files index, through the vault's I/O. Written once when anything
+     * changed; nothing when `convert` throws. Returns how many values changed.
+     */
+    convertStoreReferences(location: StoreFileLocation, convert: (stored: string) => Promise<string>): Promise<number>;
     /**
      * Generate unique attachment ID using SHA-256 hash of content
      * @param buffer - File data

package/lib/src/security/PolicyInformationPoint.d.ts

@@ -188,6 +188,13 @@ declare class PolicyInformationPoint extends BaseManager {
      * a role its user holds left the job out.
      */
     private matchableNow;
+    /**
+     * The subject as matched, carrying its identity @id (#2097): page access
+     * lists name users by @id. Matching only: the subject is never changed for
+     * any other use. No lookup for nobody or a reserved name; null when the
+     * identity store cannot answer, and then only entries not yet converted match.
+     */
+    private withIdentityId;
     /**
      * Who is making this request: the subject the session middleware resolved,
      * else the session's account resolved now, else the anonymous visitor.
@@ -357,6 +364,14 @@ declare class PolicyInformationPoint extends BaseManager {
      *   audience terms by the NCM funnel (#1446).
      */
     private walkPageTiers;
+    /**
+     * Whether `username` is the page's author (#2097): `IdentityManager.refersTo`,
+     * so an author stored as an identity @id matches only its own account, one
+     * not yet converted matches its username, and an orphan matches nobody.
+     */
+    private isPageAuthor;
+    /** The username a page's stored author names (#2097), for the private-container fallback. */
+    private authorUsername;
     /**
      * The private-container decision for something that is not a page — a file
      * in a store (docs/private-stores.md, Access). The same rule a

package/lib/src/types/Provider.d.ts

@@ -107,6 +107,12 @@ export interface GetPagesByCreatorOptions {
      * failure mode). Frontmatter is the source of truth and needs no back-fill.
      */
     systemKeywords?: string[];
+    /**
+     * The stored values that name the user (#2097): their identity @id and,
+     * for pages not yet converted, their username (`IdentityManager.referencesOf`).
+     * Set by PageManager; a provider compares `author` against these. Default `[username]`.
+     */
+    references?: string[];
 }
 /**
  * Options for {@link PageProvider.getPagesByEditor} / {@link PageProvider.getPagesSharedWith} (#640 Phase 2).
@@ -116,6 +122,12 @@ export interface PagesScanOptions {
     limit?: number;
     /** Sort order. Default `lastModified-desc`. */
     sortBy?: 'lastModified-desc' | 'title-asc';
+    /**
+     * The stored values that name the user (#2097), as {@link GetPagesByCreatorOptions.references}:
+     * `getPagesByEditor` compares `editor` against them, `getPagesSharedWith` leaves out pages
+     * whose `author` is one of them. Set by PageManager.
+     */
+    references?: string[];
 }
 /**
  * Single entry returned by {@link PageProvider.getRecentChanges}.
@@ -362,8 +374,8 @@ export interface PageProvider extends BaseProvider {
     /**
      * Return pages owned by the given user (#640).
      *
-     * "Owned" matches by `author` or `creator` field — pageIndex keeps these in
-     * lockstep on save. The visibility filter is intentionally NOT applied here
+     * "Owned" matches by `author` (any of `options.references`, #2097) or, on a
+     * private page, by `creator`, its container owner's username. The visibility filter is intentionally NOT applied here
      * because by definition a user can see their own pages: the route handler
      * verifies that `username === currentUser.username` before calling this.
      *

package/lib/src/utils/addonInstaller.d.ts

@@ -85,6 +85,12 @@ export type InstallStatus =
  | 'verified'
 /** Already installed; the folder differed from its verified tarball and was rewritten. */
  | 'repaired'
+/**
+ * #2100: switched to the release an administrator's Update staged; the
+ * previous release is kept until AddonsManager confirms this one loaded
+ * ({@link confirmUpdate}) or falls back to it ({@link rollBackUpdate}).
+ */
+ | 'updated'
 /** Not installed (and not loaded); `reason` says why. */
  | 'skipped';
 /** Which verification refused, for `addon-verify-failed`. */
@@ -99,6 +105,20 @@ export interface InstallOutcome {
     registryUnreachable?: boolean;
     /** Set when a verification refused, or (for `repaired`) found the folder changed. */
     failedCheck?: FailedCheck;
+    /** For `updated`: the release it replaced. */
+    previousVersion?: string;
+    /**
+     * #2100: a switch an earlier start made and never confirmed (the new release
+     * did not load, or the process stopped before it could) was undone at this
+     * start, before anything loaded: `from` is the release given up, `to` the
+     * one restored.
+     */
+    rolledBack?: {
+        from: string;
+        to: string;
+    };
+    /** #2100: something admins should hear about a staged Update, such as one discarded. */
+    notice?: string;
 }
 /** `sha512-<base64>` of `data`. */
 export declare function sha512Integrity(data: Buffer): string;
@@ -107,3 +127,73 @@ export declare function sha512Integrity(data: Buffer): string;
  * Never throws for one add-on's problem: each outcome says what happened.
  */
 export declare function installConfiguredAddons(specs: Record<string, unknown>, opts: InstallerOptions): Promise<InstallOutcome[]>;
+/**
+ * The switched-to release loaded (or the add-on is off, so there is nothing to
+ * try): the previous release's folder and tarball go. No-op when nothing waits.
+ */
+export declare function confirmUpdate(addonsDir: string, slug: string): Promise<void>;
+/**
+ * The switched-to release did not load: restore the previous release on disk
+ * and in the lock, so the next start runs it. The new folder is set aside
+ * (`.rejected-…`) for inspection. Undefined when there is nothing to undo.
+ */
+export declare function rollBackUpdate(addonsDir: string, slug: string, now?: Date): Promise<{
+    from: string;
+    to: string;
+} | undefined>;
+/** Why an Update is refused while the last one is not settled (`previous` still in the lock). */
+export declare const FINISH_LAST_UPDATE = "finish the last update first: restart the site";
+/** What the admin page shows for one add-on in `ngdpbase.addons.install`. */
+export interface UpdateCheck {
+    slug: string;
+    package?: string;
+    /** The configured range (`version` in the entry). */
+    range?: string;
+    /** The release the lock pins: what runs. Absent when not installed. */
+    pinned?: string;
+    /** A release an Update downloaded, used from the next start. */
+    pending?: string;
+    /** The newest release in the range, whether or not this core can run it. */
+    newest?: string;
+    /** The newest release in the range, newer than what is pinned or staged, that this core can run: what Update installs. */
+    available?: string;
+    /** The newest release in the range, newer than what is pinned or staged, when it needs a newer ngdpbase. */
+    needsCore?: {
+        version: string;
+        minVersion: string;
+    };
+    registryUnreachable?: boolean;
+    /** Why there is nothing to compare: not installed, or a configuration problem. */
+    problem?: string;
+    /** The last update is not settled (the lock still names the release it replaced): no Update until a restart. */
+    blocked?: string;
+}
+/**
+ * Ask the registry, for every installed add-on, which releases in its range
+ * are newer than the one pinned. Reads the packument only; writes nothing.
+ * Called only when an administrator opens the add-ons page or presses Check,
+ * never at start.
+ */
+export declare function checkForUpdates(specs: Record<string, unknown>, opts: InstallerOptions): Promise<UpdateCheck[]>;
+/** What an Update did. */
+export interface UpdateOutcome {
+    slug: string;
+    /** `staged`: verified and downloaded; it runs from the next start. `refused`: nothing changed; `reason` says why. */
+    status: 'staged' | 'refused';
+    package?: string;
+    version?: string;
+    /** The release that runs until the next start. */
+    previousVersion?: string;
+    reason?: string;
+    registryUnreachable?: boolean;
+    failedCheck?: FailedCheck;
+}
+/**
+ * Download `version` of an installed add-on and stage it for the next start
+ * (#2100). It must be a release in the configured range, newer than the
+ * pinned one, that this core can run, and it passes the same checks as a
+ * first install ({@link fetchVerified}): sha512, provenance, contents,
+ * package.json. `beforeInstall` (the audit record) runs after the checks and
+ * before anything is written. The running add-on's folder is not touched.
+ */
+export declare function stageUpdate(slug: string, rawSpec: unknown, version: string, opts: InstallerOptions): Promise<UpdateOutcome>;

package/lib/src/utils/addonLock.d.ts

@@ -7,9 +7,8 @@
  * folders in `<data>/addons` are installed add-ons at all: a folder the lock
  * does not name is never an add-on, whatever it contains.
  */
-/** What the lock records for one installed add-on. */
-export interface LockEntry {
-    package: string;
+/** One verified release of an add-on: what it is and what it was accepted on. */
+export interface PinnedVersion {
     version: string;
     integrity: string;
     installedAt: string;
@@ -19,6 +18,23 @@ export interface LockEntry {
         verifiedAt: string;
     };
 }
+/** What the lock records for one installed add-on. */
+export interface LockEntry extends PinnedVersion {
+    package: string;
+    /**
+     * #2100: a newer release an administrator's Update downloaded and verified.
+     * Its tarball waits in `.packages/`; the next start switches to it. Nothing
+     * else reads it, so until then the site runs `version`.
+     */
+    pending?: PinnedVersion;
+    /**
+     * #2100: the release this one replaced at the start that switched to it,
+     * kept (its folder as `.previous-<slug>`, its tarball in `.packages/`) until
+     * this one has loaded. Present at a later start only when that start never
+     * confirmed the switch, so the installer falls back to it.
+     */
+    previous?: PinnedVersion;
+}
 export interface LockFile {
     lockfileVersion: 1;
     addons: Record<string, LockEntry>;
@@ -26,6 +42,8 @@ export interface LockFile {
 export declare const LOCK_FILE_NAME = "addons-lock.json";
 /** Verified tarballs, kept so a restart needs no registry. Dot-named: discovery skips it. */
 export declare const PACKAGES_DIR_NAME = ".packages";
+/** #2100: the folder a switched-from release waits in until the new one has loaded. Dot-named: discovery skips it. */
+export declare const PREVIOUS_DIR_PREFIX = ".previous-";
 export declare function lockFilePath(addonsDir: string): string;
 /** The lock file, or an empty one when there is none. Throws when it exists and is not JSON. */
 export declare function readLockSync(addonsDir: string): LockFile;

package/lib/src/utils/addonLock.js

@@ -12,6 +12,8 @@ import path from 'path';
 export const LOCK_FILE_NAME = 'addons-lock.json';
 /** Verified tarballs, kept so a restart needs no registry. Dot-named: discovery skips it. */
 export const PACKAGES_DIR_NAME = '.packages';
+/** #2100: the folder a switched-from release waits in until the new one has loaded. Dot-named: discovery skips it. */
+export const PREVIOUS_DIR_PREFIX = '.previous-';
 export function lockFilePath(addonsDir) {
     return path.join(addonsDir, LOCK_FILE_NAME);
 }

package/lib/src/utils/auditEventNames.generated.d.ts

@@ -4,7 +4,7 @@ export declare const AUDIT_EVENT_NAME_PATTERN: RegExp;
 export declare const AUDIT_EVENT: {
     /** An add-on named in ngdpbase.addons.install installed into the data folder: package, version, sha512 and the repository its provenance names; recorded before it is written, which cannot proceed without it (#1830) */
     readonly ADDON_INSTALL: "addon-install";
-    /** An installed add-on moved to another version by an administrator's Update: who, and from which version to which (#1830; the Update action is not built yet) */
+    /** The release an installed add-on runs changed: an administrator's Update (who, the add-on, from and to version), recorded before the release is written, which cannot proceed without it; or core falling back to the previous release because the new one did not load (#2100) */
     readonly ADDON_UPDATE: "addon-update";
     /** An add-on refused or set aside by a check: its sha512, provenance, tarball contents, package.json, the lock file, or a changed installed folder (#1830) */
     readonly ADDON_VERIFY_FAILED: "addon-verify-failed";

package/lib/src/utils/auditEventNames.generated.js

@@ -11,7 +11,7 @@ export const AUDIT_EVENT_NAME_PATTERN = /^[a-z]+(-[a-z]+)+$/;
 export const AUDIT_EVENT = {
     /** An add-on named in ngdpbase.addons.install installed into the data folder: package, version, sha512 and the repository its provenance names; recorded before it is written, which cannot proceed without it (#1830) */
     ADDON_INSTALL: 'addon-install',
-    /** An installed add-on moved to another version by an administrator's Update: who, and from which version to which (#1830; the Update action is not built yet) */
+    /** The release an installed add-on runs changed: an administrator's Update (who, the add-on, from and to version), recorded before the release is written, which cannot proceed without it; or core falling back to the previous release because the new one did not load (#2100) */
     ADDON_UPDATE: 'addon-update',
     /** An add-on refused or set aside by a check: its sha512, provenance, tarball contents, package.json, the lock file, or a changed installed folder (#1830) */
     ADDON_VERIFY_FAILED: 'addon-verify-failed',

package/lib/src/utils/identityStoreUnavailable.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The identity store could not answer a conversion's lookup (#2097).
+ *
+ * A start-up conversion tells this apart from every other failure: this one
+ * postpones the whole pass (no username is orphaned because it could not be
+ * looked up), while a page that fails for its own reason (a file it cannot
+ * read or write, a full disk, a vault it cannot open) is skipped, counted and
+ * the pass goes on. `IdentityManager.conversionPass` throws it; the providers
+ * and managers running a pass rethrow it and catch anything else per record.
+ */
+export declare class IdentityStoreUnavailableError extends Error {
+    constructor(cause: unknown);
+}
+/**
+ * How a failure is named in a counts-only report: its error code (`EACCES`,
+ * `ENOSPC`) or class name, never its message (which may hold a path or a
+ * name).
+ */
+export declare function errorClassOf(error: unknown): string;

package/lib/src/utils/username.d.ts

@@ -70,5 +70,21 @@ export declare const IDENTITY_ID_PREFIX = "urn:";
  * start with it.
  */
 export declare const ORPHAN_PREFIX = "orphan:";
-/** True when the name belongs to a principal rather than a user, or has the contact, `@id` or orphan prefix. */
+/**
+ * Values older records hold where no user was recorded (#2096, #2097): the
+ * footnote migration's `migrated`, the editor fallback `unknown` (and the
+ * attachment pool's `Unknown`), the JSPWiki import's `import`. Never a
+ * username: a start-up conversion never looks them up (an account that later
+ * takes one of these names must not gain the records), stores them as
+ * `orphan:<value>` and does not count them as needing attention.
+ */
+export declare const NO_RECORDED_USER: readonly string[];
+/** True when `value` is one of {@link NO_RECORDED_USER}, bare or as its orphan form. */
+export declare function isNoRecordedUser(value: unknown): boolean;
+/**
+ * True when the name belongs to a principal rather than a user, is a "no user
+ * recorded" value ({@link NO_RECORDED_USER}, #2097: an account by that name
+ * would take over the records that hold it), or has the contact, `@id` or
+ * orphan prefix.
+ */
 export declare function isReservedUsername(username: unknown): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilleke/ngdpbase-types",
-  "version": "5.34.0",
+  "version": "5.36.0",
   "description": "TypeScript types for ngdpbase add-ons, and a test kit of core's own values. A dev dependency, versioned with ngdpbase.",
   "license": "Apache-2.0",
   "author": "Jim Willeke",