@kernhq/module-inventory 0.2.0 → 0.4.0

package/dist/server/services/repairs.js

@@ -0,0 +1,476 @@
+import { KernError, uuidv7 } from '@kernhq/kernel';
+import { and, desc, eq, isNotNull, isNull, lt } from 'drizzle-orm';
+import { assets, repairs } from '../schema.js';
+import { decodeMark, encodeMark } from './cursor.js';
+import { violated } from './db-errors.js';
+import { awayForRepair, deriveStatus, lockAsset } from './status.js';
+/** The partial unique index `0003_repairs.sql` added. Two open repairs for one asset are it. */
+const ONE_OPEN = 'inventory_repairs_one_open_uq';
+/** The CHECK `0005_repair_dates.sql` added. A repair that came back before it was sent is it. */
+const IN_ORDER = 'inventory_repairs_returned_after_sent';
+/**
+ * The one ordering a repair list has, named rather than left as a literal.
+ *
+ * The cursor codec binds a bookmark to the sort it was issued under and refuses it under any other,
+ * so this list needs a name for its sort even while there is only one — and the day a second one
+ * exists, every cursor already in a browser tab is refused rather than misread.
+ */
+const REPAIR_SORT = 'recent';
+/** The wire shape: drizzle gives Date objects for timestamps, the contract promises ISO strings. */
+export function toRepair(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspaceId,
+        assetId: row.assetId,
+        summary: row.summary,
+        detail: row.detail,
+        vendor: row.vendor,
+        costMinor: row.costMinor,
+        currency: row.currency,
+        sentOn: row.sentOn,
+        returnedOn: row.returnedOn ?? null,
+        createdBy: row.createdBy,
+        createdAt: row.createdAt.toISOString(),
+        updatedAt: row.updatedAt.toISOString(),
+    };
+}
+/**
+ * What went away to be fixed, and what came back.
+ *
+ * Three things happen in one transaction on every change here, and the point of the class is that
+ * they cannot come apart: the repair row moves, `assets.status` is brought into step with it through
+ * `deriveStatus`, and an `asset_history` entry records it.
+ *
+ * **The database is the arbiter of "already away", not this file.** There is deliberately no
+ * `select … for update` on the asset *before* the repair row is written:
+ * `inventory_repairs_one_open_uq` — a unique index on `(asset_id) where returned_on is null` — is
+ * what makes two open repairs impossible, so two people pressing *Send for repair* on the same
+ * laptop in the same instant both read "it is here", both insert, and Postgres refuses exactly one
+ * of them. Checking first and inserting after is the race, not the fix. What this file owes the
+ * loser is a sentence they can act on rather than drizzle's "Failed query: insert into
+ * mod_inventory.repairs …".
+ *
+ * **`restamp` does lock it, afterwards, and that is a different job.** `assets.status` is derived
+ * from this module's repair rows *and* from custody, which another service writes, so the winner
+ * still has to compute an answer nobody can overwrite from a stale snapshot. See `lockAsset` in
+ * `status.ts`: the index decides the contest, the lock orders the bookkeeping that follows it.
+ *
+ * **Repairs do not touch custody.** An item at the repairer is still somebody's responsibility; see
+ * `status.ts`, where that rule is argued in full.
+ */
+export class RepairService {
+    notify;
+    constructor(notify) {
+        this.notify = notify;
+    }
+    /**
+     * Today, as this module means it: the UTC date.
+     *
+     * Not the browser's date, and not a workspace time zone — a repair is dated to the day, and the
+     * two hours a workspace in Istanbul is ahead of UTC would put an evening repair on tomorrow for
+     * one reader and today for another. One clock, the server's, the same reasoning that keeps asset
+     * tags server-side. A workspace that needs the exact day sends `sentOn` itself.
+     */
+    static today() {
+        return new Date().toISOString().slice(0, 10);
+    }
+    /** The one error a lost race produces, in every place a race can be lost. */
+    static alreadyAway() {
+        return KernError.conflict('This item is already away for repair. Log that one as returned first.', 'inventory.repair.already_open');
+    }
+    /**
+     * A repair cannot come back before it was sent — checked on every path that writes either date.
+     *
+     * `complete` has always refused a return date before the send date, and `update` did not: it took
+     * `sentOn` from the patch and wrote it whatever the row already said, so correcting the send date
+     * of a *finished* repair could move it past the day the item came back. What that stores is a
+     * repair that ended before it started — every "how long was it away" answer negative, the overdue
+     * sweep measuring from a date in the future, and nothing anywhere to say which of the two dates is
+     * the wrong one.
+     *
+     * Both are `date` columns, so they read back as `YYYY-MM-DD` and compare correctly as text.
+     *
+     * The database holds the same rule (`inventory_repairs_returned_after_sent`), because two
+     * transactions can each pass this check and still write a pair that fails it: one moving `sent_on`
+     * while the other logs the item back. This runs first so the ordinary case gets a sentence rather
+     * than a constraint violation; `outOfOrder` is what the loser of that race gets.
+     */
+    static requireInOrder(sentOn, returnedOn) {
+        if (returnedOn !== null && returnedOn < sentOn)
+            throw RepairService.outOfOrder();
+    }
+    static outOfOrder() {
+        return KernError.conflict('A repair cannot come back before it was sent.', 'inventory.repair.returned_before_sent');
+    }
+    /**
+     * One day past today, which is the whole tolerance a date typed by a person needs.
+     *
+     * `today()` is UTC — one clock, the server's, for the reason it documents — and a workspace in
+     * Auckland is up to fourteen hours ahead of it, so *their* today is UTC's tomorrow for a large
+     * part of their working day. Refusing at exactly UTC-today would refuse the ordinary case in half
+     * the world's offices. A day is enough for every real time zone and is nowhere near enough to be
+     * the defect below.
+     */
+    static FUTURE_GRACE_DAYS = 1;
+    /**
+     * A repair cannot be sent from the future — checked on every path that writes `sent_on`.
+     *
+     * `sentOn` is a date a person types, and nothing bounded it. A repair dated 2030 is one the
+     * overdue sweep can never find: it looks for `sent_on <= today - repairOverdueDays`, so a send
+     * date years ahead is permanently outside the window and the chase never fires. Not for a while —
+     * **ever**, for the life of that row, and silently, because a sweep that finds nothing looks
+     * exactly like a sweep with nothing to do. It also makes every "how long has it been away" answer
+     * negative and puts the item at the top of a list ordered by when it left.
+     *
+     * A typo is the likely cause and a deliberate one is the dangerous case: this is the one field
+     * that decides whether anybody is ever reminded that a vendor still has the company's laptop.
+     *
+     * Bounded on the *server*, not in the contract, and both halves of that are deliberate. The
+     * contract is shared with the browser, so a `refine` there would compare against the reader's own
+     * clock — and a client whose date is a day ahead would refuse a date the server accepts, or the
+     * other way round. And it is a sentence rather than a bare `invalid_string`, because "a repair
+     * cannot be sent in the future" is something a person can act on.
+     *
+     * **A `BAD_REQUEST` with no `reason`, like `checkPhoto`'s refusal and the category check in
+     * `AssetService`.** The date is malformed rather than contested — nothing raced, no state
+     * changed underneath anybody, the value simply cannot be true — and `CONFLICT` is this module's
+     * word for losing a race. The cost is that the sentence reaches a Persian or Turkish reader in
+     * English: a translated refusal needs a stable `reason` **and** its five bundles in
+     * `src/client/errors.ts`, and the two have to arrive together or `errors.test.ts` fails from
+     * whichever side is ahead.
+     */
+    static requireNotFuture(sentOn) {
+        const limit = new Date(`${RepairService.today()}T00:00:00Z`);
+        limit.setUTCDate(limit.getUTCDate() + RepairService.FUTURE_GRACE_DAYS);
+        if (sentOn > limit.toISOString().slice(0, 10))
+            throw KernError.badRequest('A repair cannot be sent in the future.');
+    }
+    async asset(tx, workspaceId, assetId) {
+        const [row] = await tx
+            .select()
+            .from(assets)
+            .where(and(eq(assets.workspaceId, workspaceId), eq(assets.id, assetId)));
+        if (!row)
+            throw KernError.notFound('Asset');
+        return row;
+    }
+    async get(tx, workspaceId, repairId) {
+        const [row] = await tx
+            .select()
+            .from(repairs)
+            .where(and(eq(repairs.workspaceId, workspaceId), eq(repairs.id, repairId)));
+        if (!row)
+            throw KernError.notFound('Repair');
+        return row;
+    }
+    /**
+     * One asset's repairs, or the whole workspace's — one query with one filter, because they are one
+     * question asked at two scopes and a second query answering it would be a second one to keep in
+     * step.
+     *
+     * **Paged by id, newest logged first.** An id is uuidv7, so it already carries the clock, and it
+     * is unique where `sent_on` is a date two repairs logged on the same day share — a page boundary
+     * between two rows that share a sort key repeats one and drops the other. The same reasoning
+     * `assets.list` gives for `sort: 'recent'` and `assets.history` gives for ordering on the row id.
+     */
+    async list(tx, workspaceId, input) {
+        const filters = [eq(repairs.workspaceId, workspaceId)];
+        if (input.assetId)
+            filters.push(eq(repairs.assetId, input.assetId));
+        if (input.open === true)
+            filters.push(isNull(repairs.returnedOn));
+        if (input.open === false)
+            filters.push(isNotNull(repairs.returnedOn));
+        if (input.cursor)
+            filters.push(lt(repairs.id, decodeMark(input.cursor, REPAIR_SORT).i));
+        /**
+         * Joined to the asset for its tag and name — inside one schema, which is the join a module is
+         * allowed to make. A workspace-wide list of what is away is unreadable without them, and
+         * copying them into `repairs` would be a label that goes stale the first time somebody renames
+         * an asset.
+         */
+        const rows = await tx
+            .select({ repair: repairs, code: assets.code, name: assets.name })
+            .from(repairs)
+            .innerJoin(assets, and(eq(assets.id, repairs.assetId), eq(assets.workspaceId, repairs.workspaceId)))
+            .where(and(...filters))
+            .orderBy(desc(repairs.id))
+            .limit(input.limit + 1);
+        const window = rows.slice(0, input.limit);
+        const last = window.at(-1);
+        const nextCursor = rows.length > input.limit && last ? encodeMark({ i: last.repair.id, s: REPAIR_SORT }) : null;
+        const items = window.map((row) => ({
+            ...toRepair(row.repair),
+            assetCode: row.code,
+            assetName: row.name,
+        }));
+        return { items, nextCursor };
+    }
+    /**
+     * The currency to store, given what the caller said and what is already there.
+     *
+     * A cost with no unit is not a cost, so an amount recorded with no currency inherits the asset's.
+     * **Inheritance fires in exactly one case** — an amount is being recorded and the repair has no
+     * currency at all — and getting that wrong is silent in both directions:
+     *
+     * - inheriting whenever a cost *exists* rather than whenever one *arrives* means an unrelated
+     *   edit (correcting a vendor) silently gives the asset's currency back to a repair whose
+     *   currency somebody deliberately cleared;
+     * - inheriting over a currency the repair already has means recording an amount in dollars on an
+     *   asset priced in euros quietly relabels it as euros.
+     *
+     * `undefined` means "not mentioned" and an explicit `null` means "no currency", which a workspace
+     * that records amounts and not currencies genuinely means. Collapsing the two is the mistake
+     * `assets.update` documents one file over.
+     */
+    static currencyFor(opts) {
+        if (opts.patch !== undefined)
+            return opts.patch ?? null;
+        if (opts.previous !== null)
+            return opts.previous;
+        return opts.cost === null || opts.cost === undefined ? null : (opts.asset.currency ?? null);
+    }
+    /** Send it away. Refuses when it is already at a repairer — that is what `complete` is for. */
+    async create(tx, workspaceId, actorId, assetId, input) {
+        const asset = await this.asset(tx, workspaceId, assetId);
+        // An archived asset is one the workspace has said it no longer tracks. Paying to fix something
+        // that is not in the register is a mistake worth naming rather than recording.
+        if (asset.archivedAt)
+            throw KernError.conflict('This item is archived. Restore it before sending it for repair.', 'inventory.repair.archived');
+        const sentOn = input.sentOn ?? RepairService.today();
+        // Vacuous today, and deliberately here rather than reasoned about: `RepairInput` carries no
+        // `returnedOn`, so a new repair is always still away. The day it carries one, this is already
+        // the check, instead of being the one write path somebody forgot.
+        RepairService.requireInOrder(sentOn, null);
+        RepairService.requireNotFuture(sentOn);
+        let row;
+        try {
+            const inserted = await tx
+                .insert(repairs)
+                .values({
+                id: uuidv7(),
+                workspaceId,
+                assetId,
+                summary: input.summary,
+                detail: input.detail ?? null,
+                vendor: input.vendor ?? null,
+                costMinor: input.costMinor ?? null,
+                currency: RepairService.currencyFor({
+                    patch: input.currency,
+                    cost: input.costMinor,
+                    previous: null,
+                    asset,
+                }),
+                sentOn,
+                createdBy: actorId,
+            })
+                .returning();
+            row = inserted[0];
+        }
+        catch (err) {
+            // The index bit: another transaction opened a repair for this asset between our read and our
+            // insert. Anything else is a real fault and must not be disguised as a lost race.
+            if (violated(err, ONE_OPEN))
+                throw RepairService.alreadyAway();
+            throw err;
+        }
+        const updated = await this.restamp(tx, workspaceId, assetId);
+        const activity = {
+            workspaceId,
+            assetId,
+            actorId,
+            action: 'repair_logged',
+            data: { repairId: row.id, summary: row.summary, ...(row.vendor ? { vendor: row.vendor } : {}) },
+        };
+        await this.notify.history(tx, activity);
+        return { repair: row, asset: updated, activity };
+    }
+    /**
+     * Correct what was recorded — a vendor, or a cost that arrived with the invoice a week later.
+     *
+     * **`returnedOn` is deliberately not patchable.** That one column decides whether the asset reads
+     * as `under_repair`, so exactly one procedure moves it and the derived status has one door rather
+     * than two. Editing a finished repair is allowed all the same: the invoice usually arrives after
+     * the item does.
+     *
+     * **No `actorId`, because nothing here records one.** This writes no timeline entry — see the
+     * bottom of the method — and a parameter kept for symmetry with `create` and `complete` would be
+     * a parameter every caller has to supply and nothing reads.
+     */
+    async update(tx, workspaceId, repairId, patch) {
+        const previous = await this.get(tx, workspaceId, repairId);
+        const asset = await this.asset(tx, workspaceId, previous.assetId);
+        // `undefined` means "not mentioned"; `null` means "clear it". Collapsing the two is how an edit
+        // of one field quietly wipes the others. `cost` is the patch's own value and not the merged
+        // one, so correcting a vendor cannot give the asset's currency back to a repair whose currency
+        // somebody deliberately cleared.
+        const sentOn = patch.sentOn ?? previous.sentOn;
+        // `returnedOn` is not patchable, so the row's own value is the one this has to stay behind. An
+        // edit that moves the send date past the day the item came back is refused rather than stored.
+        RepairService.requireInOrder(sentOn, previous.returnedOn);
+        // And the same bound `create` applies, because this is the other door onto the same column —
+        // and the more dangerous one: moving `sent_on` forward also clears `overdue_notified_at`, so a
+        // correction into the future re-arms a chase that can then never fire.
+        RepairService.requireNotFuture(sentOn);
+        const values = {
+            summary: patch.summary ?? previous.summary,
+            detail: patch.detail !== undefined ? (patch.detail ?? null) : previous.detail,
+            vendor: patch.vendor !== undefined ? (patch.vendor ?? null) : previous.vendor,
+            costMinor: patch.costMinor !== undefined ? (patch.costMinor ?? null) : previous.costMinor,
+            currency: RepairService.currencyFor({
+                patch: patch.currency,
+                cost: patch.costMinor,
+                previous: previous.currency,
+                asset,
+            }),
+            sentOn,
+            /**
+             * Correcting the send date re-arms the overdue notice.
+             *
+             * `overdue_notified_at` marks that somebody has already been asked to chase this one, and the
+             * threshold is measured from `sent_on` — so a repair re-dated a month earlier is overdue for
+             * the first time and nobody would ever hear about it if the marker survived. Only when the
+             * date actually moved: correcting a vendor must not send the same chase again.
+             */
+            overdueNotifiedAt: sentOn === previous.sentOn ? previous.overdueNotifiedAt : null,
+            updatedAt: new Date(),
+        };
+        let row;
+        try {
+            const written = await tx
+                .update(repairs)
+                .set(values)
+                .where(and(eq(repairs.workspaceId, workspaceId), eq(repairs.id, repairId)))
+                .returning();
+            row = written[0];
+        }
+        catch (err) {
+            // The CHECK bit: another transaction logged the item back between the check above and this
+            // statement, so the pair being written is out of order after all. A sentence, not a driver
+            // dump — the same debt every other constraint in this module is paid.
+            if (violated(err, IN_ORDER))
+                throw RepairService.outOfOrder();
+            throw err;
+        }
+        /**
+         * **No timeline entry, and that is a decision.**
+         *
+         * The asset's timeline records what happened *to the asset*: it went away, and it came back.
+         * Correcting a vendor or filling in an invoice a week later did not happen to the asset, and a
+         * timeline that reported every such edit would bury the two entries that matter under the
+         * paperwork around them. The repair row's own `updated_at` is where "this was edited" lives,
+         * and the row is on screen beside it.
+         */
+        return { repair: row, asset, activity: null };
+    }
+    /**
+     * It came back.
+     *
+     * `and returned_on is null` in the predicate is the optimistic guard, exactly as
+     * `CustodyService.close` uses: under READ COMMITTED a concurrent complete blocks this statement,
+     * and when it resumes the row no longer matches, so zero rows come back rather than a second
+     * completion silently overwriting the first one's date.
+     */
+    async complete(tx, workspaceId, actorId, repairId, input) {
+        const previous = await this.get(tx, workspaceId, repairId);
+        if (previous.returnedOn)
+            throw KernError.conflict('This repair is already logged as finished.', 'inventory.repair.already_complete');
+        const asset = await this.asset(tx, workspaceId, previous.assetId);
+        const returnedOn = input.returnedOn ?? RepairService.today();
+        // A date is a fact somebody typed, and a person deserves a sentence about it rather than a
+        // constraint violation — the database refuses this pair too, and this is what stops it having
+        // to.
+        RepairService.requireInOrder(previous.sentOn, returnedOn);
+        let row;
+        try {
+            const written = await tx
+                .update(repairs)
+                .set({
+                returnedOn,
+                costMinor: input.costMinor !== undefined ? (input.costMinor ?? null) : previous.costMinor,
+                // The invoice usually arrives with the item, so this is where a cost is most often first
+                // recorded — and therefore where the currency is most often inherited.
+                currency: RepairService.currencyFor({
+                    patch: input.currency,
+                    cost: input.costMinor,
+                    previous: previous.currency,
+                    asset,
+                }),
+                updatedAt: new Date(),
+            })
+                .where(and(eq(repairs.workspaceId, workspaceId), eq(repairs.id, repairId), isNull(repairs.returnedOn)))
+                .returning();
+            row = written[0];
+        }
+        catch (err) {
+            // Another transaction moved `sent_on` past this return date between the check above and this
+            // statement. See `update`, which has the same guard for the same race seen from the other end.
+            if (violated(err, IN_ORDER))
+                throw RepairService.outOfOrder();
+            throw err;
+        }
+        if (!row)
+            throw KernError.conflict('Somebody logged this repair as finished a moment before you did. Reload to see where it is now.', 'inventory.repair.already_complete');
+        const updated = await this.restamp(tx, workspaceId, previous.assetId);
+        const activity = {
+            workspaceId,
+            assetId: previous.assetId,
+            actorId,
+            action: 'repair_completed',
+            data: {
+                repairId: row.id,
+                summary: row.summary,
+                ...(row.costMinor !== null ? { costMinor: row.costMinor, currency: row.currency } : {}),
+            },
+        };
+        await this.notify.history(tx, activity);
+        return { repair: row, asset: updated, activity };
+    }
+    /**
+     * Bring `assets.status` back into step with the facts, inside the same transaction.
+     *
+     * Both facts are **read** rather than assumed — the open repair as it now stands, and the
+     * custodian as the asset row carries it — and `deriveStatus` decides. Assuming `under_repair`
+     * after an insert and `in_stock` after a completion is the version of this that silently released
+     * whoever was still holding the item.
+     *
+     * **The asset is locked and re-read here, rather than passed in.** It used to take the row the
+     * caller had already fetched, which is a snapshot from before the repair was written and before
+     * anything else that touched the asset in between: a handover committing in that window was
+     * invisible, so this derived a status from a custodian that had stopped being current and wrote it
+     * over the handover's answer. Taking the row under the lock is what makes "read both facts, then
+     * derive" true rather than merely intended. `lockAsset` argues it in full.
+     */
+    async restamp(tx, workspaceId, assetId) {
+        const asset = await lockAsset(tx, workspaceId, assetId);
+        // `true` rather than a parameter: every caller of this file is behind `requiresCapability
+        // ('repairs')`, so a workspace reaching here is a workspace that records repairs by
+        // construction. The two paths that are *not* behind it — custody and archive — take the switch
+        // as an argument, and `deriveStatus` says why.
+        const away = await awayForRepair(tx, workspaceId, assetId, true);
+        /**
+         * An archived item cannot be away for repair, and this is the other half of the refusal that
+         * says so.
+         *
+         * `assets.archive` reads "nothing open against it" under this same lock, so an archive racing a
+         * *new* repair is ordered against it — and whichever arrives second has to lose, or the register
+         * ends up holding exactly the state the refusal claims is impossible. Only while the repair is
+         * open: logging one back on a row somebody archived anyway has to stay possible, or the item is
+         * trapped away for ever.
+         */
+        if (away && asset.archivedAt)
+            throw KernError.conflict('This item is archived. Restore it before sending it for repair.', 'inventory.repair.archived');
+        const status = deriveStatus({ custodianUserId: asset.custodianUserId, awayForRepair: away });
+        if (status === asset.status)
+            return asset;
+        const [row] = await tx
+            .update(assets)
+            .set({ status, updatedAt: new Date() })
+            .where(and(eq(assets.workspaceId, workspaceId), eq(assets.id, assetId)))
+            .returning();
+        if (!row)
+            throw KernError.notFound('Asset');
+        return row;
+    }
+}
+//# sourceMappingURL=repairs.js.map

package/dist/server/services/repairs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repairs.js","sourceRoot":"","sources":["../../../src/server/services/repairs.ts"],"names":[],"mappings":"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"}

package/dist/server/services/search.d.ts

@@ -0,0 +1,85 @@
+import type { core } from '@kernhq/contracts';
+import type { Kernel } from '@kernhq/kernel';
+import { assets } from '../schema.js';
+import type { NotifyService } from './notify.js';
+/**
+ * How an asset is referred to from outside this module.
+ *
+ * One function, because a search hit and a resolved `inventory:asset:<id>` reference have to be the
+ * same thing — somebody who finds a laptop in the command palette and somebody who follows a link to
+ * it from a chat message are looking at the same row and must see the same words for it.
+ */
+export declare const assetUrl: (assetId: string) => string;
+export declare const ASSET_ICON = "briefcase";
+/** The columns a document is built from, and the one join it needs. */
+export interface IndexableAsset {
+    asset: typeof assets.$inferSelect;
+    /** The category's name, resolved at read time — never copied into `assets`, so a rename lands. */
+    categoryName: string | null;
+}
+/**
+ * What a person types into the command palette, and what an asset has to answer it with.
+ *
+ * An asset tag read off a sticker is the first of these — `INV-0042` is what somebody has in their
+ * hand — so it leads the title, exactly as tracker leads with an issue key. The rest is everything
+ * printed on or near the thing: its name, its serial number, where it is kept, and what the
+ * workspace files it under.
+ *
+ * **The category is indexed by name, not by id.** "chair" finds every chair filed under Furniture
+ * only if the word Furniture is in the document; an id in `attributes` is a filter, not a search
+ * term. The cost is that renaming a category leaves its assets' documents naming the old word until
+ * each one is next written, which is a staleness worth stating and not worth a workspace-wide
+ * rewrite on every rename — `core.search.reindex` is the thing that fixes it, and it exists.
+ *
+ * `acl` is null: an asset is visible to anybody with `inventory.asset.view`, which is a workspace
+ * permission and not a per-row one, so there is no narrower audience to name.
+ */
+export declare function assetSearchDocument(workspaceId: string, row: IndexableAsset): core.SearchDocument;
+/**
+ * Putting assets into the workspace-wide search index, and taking them out again.
+ *
+ * `NotifyService` has carried `index`/`unindex` since the module was written and nothing called
+ * either, because `objectTypes` had been taken off the manifest — a declared type with no indexer
+ * and no resolver renders a link to nothing, which reads to a person as a broken product rather
+ * than as a feature that has not shipped. Both halves arrive together here.
+ *
+ * Every method is best-effort by way of `NotifyService`: an asset must not fail to save because the
+ * core search service is briefly away. The register's own row is authoritative and a later
+ * `core.search.reindex` repairs whatever was missed, which is exactly what that job is for.
+ */
+export declare class SearchService {
+    private readonly kernel;
+    private readonly notify;
+    constructor(kernel: Kernel, notify: NotifyService);
+    /**
+     * One asset as a document, or `null` for one the index should not hold.
+     *
+     * `null` for a row that is gone **and** for one that is archived, because the indexer treats null
+     * as "remove this": an archived asset is one the workspace has said it no longer tracks, so
+     * finding it in the command palette would offer a door to something deliberately put away.
+     * Restoring it writes the row again, which reindexes it.
+     */
+    load(workspaceId: string, assetId: string): Promise<core.SearchDocument | null>;
+    /**
+     * Every live asset of a workspace, in pages, for a full reindex.
+     *
+     * Keyset by id rather than `offset`: a scan of a big workspace runs for a while, and an offset
+     * walk over a table somebody is writing to repeats and drops rows. Ids are uuidv7 and unique, so
+     * one column is a page boundary two rows cannot share — the same reasoning `assets.list` gives.
+     *
+     * One transaction per page rather than one for the whole scan: holding a pooled connection open
+     * across a reindex of ten thousand rows is how a service runs out of connections doing
+     * maintenance.
+     */
+    scan(workspaceId: string): AsyncIterable<core.SearchDocument>;
+    /**
+     * Bring the index into step with one asset, whichever direction that means.
+     *
+     * Called after the transaction has committed, never inside it — the index is another service's
+     * table, and telling it about a row a rollback then took away cannot be retracted. It is the
+     * reason `router.ts` announces from outside the transaction and this is announced beside the
+     * event and the realtime change.
+     */
+    reindex(workspaceId: string, assetId: string): Promise<void>;
+}
+//# sourceMappingURL=search.d.ts.map

package/dist/server/services/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/server/services/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAM,MAAM,gBAAgB,CAAA;AAGhD,OAAO,EAAE,MAAM,EAAc,MAAM,cAAc,CAAA;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAKhD;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,SAAS,MAAM,WAAkC,CAAA;AAC1E,eAAO,MAAM,UAAU,cAAc,CAAA;AAErC,uEAAuE;AACvE,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,OAAO,MAAM,CAAC,YAAY,CAAA;IACjC,kGAAkG;IAClG,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;CAC5B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,GAAG,IAAI,CAAC,cAAc,CAqBjG;AAYD;;;;;;;;;;;GAWG;AACH,qBAAa,aAAa;IAEtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,aAAa;IAGxC;;;;;;;OAOG;IACG,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;IAUrF;;;;;;;;;;OAUG;IACI,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,cAAc,CAAC;IAqBpE;;;;;;;OAOG;IACG,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAYnE"}