@kernhq/module-inventory 0.2.0 → 0.4.0

package/README.md

@@ -13,47 +13,128 @@ deleting the package removes the feature completely. Enable it per workspace in
 An **asset** carries an asset tag the server assigns (`INV-0042`), a name and description, a serial
 number, a purchase date and vendor, a price, a warranty expiry, a location, a photo and a status.
 
+A price is written the way the reader's own language writes one — `1.234,56` in German, `۱٬۲۳۴٫۵۶`
+in Persian — and is stored in the currency's own minor units. How many decimal places that is comes
+from the currency, so a yen amount takes none and a dinar takes three; anything the field cannot
+read, including more decimal places than the currency has, is refused rather than rounded.
+
 The status column holds one of `in_stock`, `assigned`, `reserved`, `under_repair`, `lost` and
-`retired`, and the screen can filter by any of them — but until custody and repairs ship, nothing
-sets it, so every asset is `in_stock` and the other five filters correctly return nothing. The
-filter is not wrong; there is simply nothing else to find yet.
+`retired`. Three of them are derived from two facts and written in the same transaction as the fact
+that moved: an open repair makes an item `under_repair`, a custodian makes it `assigned`, and
+neither makes it `in_stock`. **A repair wins that column and does not touch custody** — a laptop at
+the workshop is still the person's it was handed to, so completing a repair returns it to `assigned`
+rather than to stock. `reserved`, `lost` and `retired` wait on the features that set them, so those
+three filters correctly return nothing yet.
 
 - The **Assets** screen lists them in a table, searches by name, tag or serial number, filters by
-  status, hides archived rows until the switch asks for them, and pages a workspace with more
-  assets than one screen holds. All four are one server query; nothing is filtered in the browser.
+  status and by category, hides archived rows until the switch asks for them, and pages a workspace
+  with more assets than one screen holds. All of it is one server query; nothing is filtered in the
+  browser.
 - Adding an asset opens a dialog, and editing one opens the same dialog seeded from the row. The tag
   is the server's job — people read tags off stickers rather than inventing them.
-- Each row carries a menu: edit, archive, restore. Archiving asks first and names what it is about
-  to archive; restoring does not, because it takes nothing away.
-- A **dashboard card** shows the most recently added assets.
+- Each row carries a menu: open, edit, archive, restore. Archiving asks first and names what it is
+  about to archive; restoring does not, because it takes nothing away.
+- The line above the table says how many assets the workspace has — the real number, from
+  `stats.summary`, rather than how many rows happen to be loaded.
+- Opening an asset puts `?asset=<id>` on the URL and slides a **detail panel** over the list, so the
+  list keeps its filters and its place and the panel can be linked to and reloaded. It has up to five
+  sections: **Details**, **Custody**, **Repairs**, **Files** and **History** — Repairs and Files are
+  capabilities, so a workspace that switches one off sees three.
+- **Custody** answers who is holding an item and who held it before. Hand it over, hand it on to
+  somebody else, or take it back — each is one transaction that closes the open period, opens the
+  next, moves the custodian, the date and the status together, and writes a line of history. Two
+  people handing the same item over at the same instant is settled by a database exclusion
+  constraint, and the one who loses is told to reload rather than shown a driver error. The person
+  receiving an item is notified; the person doing the handing is not.
+- **Repairs** record what went away to be fixed, to whom, what it cost and when it came back. One
+  repair can be open per item — a partial unique index decides that, not the service, so two people
+  sending the same laptop away at the same instant end with one repair and a sentence rather than
+  two. Sending an item away puts it in `under_repair` and leaves whoever holds it holding it;
+  logging it back returns it to them, or to stock if nobody has it. An item that is away cannot be
+  archived, for the same reason one somebody is holding cannot be.
+- **Files** are receipts, warranty cards and manuals, kept against the asset or against one of its
+  repairs — a repair's invoice sits inside that repair rather than in with everything else. This
+  module records that an asset has a file and never holds a byte: the browser uploads to core, this
+  stores the id it is handed, and removing one detaches it rather than deleting core's copy. The
+  asset's **photo** is set on the Details tab and is a field of the asset rather than one of these,
+  so a workspace with Files switched off still has one.
+- **History** is the asset's own timeline, read newest first and paged. It renders as sentences —
+  "Ada handed it to Bruno", "Warranty until changed from Mar 14, 2027 to Mar 14, 2028" — not as a
+  JSON diff, and somebody who has since left the workspace reads as a former member rather than as a
+  uuid. "It", not the tag: the timeline is inside that asset's own panel, whose header is already
+  showing `INV-0042`, so repeating it on every line would be the one word in the sentence a reader
+  does not need.
+- **Categories** group what a workspace owns. They are managed in **Settings → Inventory →
+  Categories**, chosen on the asset form, shown as a chip on the row, and are the list's category
+  filter. The order they appear in everywhere else is set by **dragging them into it** — or, without
+  a pointer, with the move-up and move-down buttons on each row, which do exactly the same thing and
+  say where the row landed. A new category joins the end. They archive rather than delete:
+  `assets.category_id` carries no foreign key, so deleting one would leave every asset filed under
+  it pointing at nothing, and an archived category still names itself on the rows that carry it.
+- Two **dashboard cards**: the most recently added assets, above a strip saying how many there are,
+  how many nobody is holding and how many are away; and — for a workspace that records repairs — what
+  is out for repair right now, with the tag and name of each item.
+- Assets are in the **workspace-wide search index**, so a tag read off a sticker finds the item from
+  the command palette. Name, tag, serial number, location, description and category name are all
+  searched. Archiving an item takes it out of the index; restoring puts it back.
+- `inventory:asset:<id>` **resolves anywhere in the product** — a chat message, a tracker issue, a
+  notification — into the tag, the name and a link to the item. Somebody without
+  `inventory.asset.view` gets plain text rather than a title they were not entitled to read, and an
+  archived item still resolves and says it is archived rather than turning into a dead link.
+- Two **nightly notices**, each sent once per item and never again: a **warranty about to run out**,
+  to whoever is holding it or to whoever may replace it when nobody is; and a **repair that has been
+  away too long**, to the person who logged it and to whoever is still holding the item. Both windows
+  are settings.
+- When somebody **leaves**, the workspace gets a **return list** of what is still recorded as theirs.
+  It is raised by core's own "member removed" event, and by the People module's status change if that
+  module is installed — Inventory works without it and declares no dependency on it. Nothing is moved:
+  custody changes because a person did something, and a hook that quietly returned an item would write
+  a handover nobody performed into the one record a company later argues from.
+- Switching the module on for a workspace **seeds five categories** — Laptops, Phones, Monitors,
+  Furniture, Vehicles — so the asset form's picker is not empty on day one. All five are renamable and
+  archivable, and switching the module off and on again never seeds a second time or re-creates one
+  somebody renamed.
 - **Settings → Inventory → General** sets the shape of an asset tag — the prefix and how many digits
   it is padded to, so a workspace that already labels its laptops `LT-` keeps doing that. The number
   itself is a counter in the database rather than a setting: a number an administrator can edit is a
-  number that produces a duplicate tag.
-- Two permissions gate it: `inventory.asset.view` and `inventory.asset.manage`.
+  number that produces a duplicate tag. The same page sets the two notice windows: how far ahead of a
+  warranty expiring somebody is told, and how long an item may be at a repairer before somebody is
+  asked to chase it.
+- Five permissions gate it: `inventory.asset.view`, `inventory.asset.manage`,
+  `inventory.custody.manage`, `inventory.repair.manage` and `inventory.category.manage`. Reading who
+  holds what and what has been repaired rides `asset.view` rather than a key of its own — "who has
+  the projector" and "where is it" are the questions an asset register exists to answer, and the
+  custodian is already a field of every row the list returns.
+- Three **capabilities** decide how much of it a workspace has: `core` is required and always on,
+  and `repairs` and `attachments` are switches an administrator can turn off. A capability that is
+  off answers **404, not 403** — a workspace that does not record repairs has no such surface, so
+  the API says the same thing the hidden tab does. Switching one off destroys nothing: the rows stay
+  exactly where they were and come back when it is switched on again.
 - Its strings ship in the five languages the platform speaks — English, Arabic, German, Persian,
   Turkish.
 
-The whole API is five procedures under `/api/inventory`: list, get, create, update and archive an
-asset. An asset's photo is settable through `create` and `update` and by nothing on the screen yet;
-its custom values are settable by neither, and wait on custom fields below.
+The API is twenty-four procedures under `/api/inventory`:
+`assets.{list,get,create,update,archive,history}`,
+`custody.{assign,transfer,return,history,byUser}`,
+`categories.{list,create,update,archive,reorder}`,
+`repairs.{list,create,update,complete}`,
+`attachments.{list,add,remove}` and
+`stats.summary`.
+An asset's custom values are settable by nothing, and wait on custom fields below.
+
+Two more answers are reachable only from another service, over `kernel.call` —
+`inventory.asset.byId` and `inventory.assets.byCustodian`. They run with elevated access and are
+refused to anybody who is not a service, so that a module holding an id never has to learn the shape
+of `mod_inventory`.
 
 ## Not built yet
 
-Nothing here has a screen. Most of it is a table in `mod_inventory` and nothing more; each bullet
-says how far it actually got. A register is worth designing whole, and a migration that adds a
-column later is cheaper than one that reshapes a table. A table is not a feature, and this section
-stays until each one ships.
-
-- **Custody** — who is holding an item now, who held it before, and handing it on.
-- **History** — an append-only timeline of every change to an asset. The writes exist: create,
-  update, archive and restore each append an `asset_history` row, and the integration suite holds
-  them to it. Nothing reads them back — there is no procedure and no screen.
-- **Repairs** — what went away for repair, to whom, what it cost and when it came back.
-- **Categories** — the column and the list filter exist; nothing can create a category.
+Nothing here has a screen. It is a table in `mod_inventory` and nothing more. A register is worth
+designing whole, and a migration that adds a column later is cheaper than one that reshapes a table.
+A table is not a feature, and this section stays until each one ships.
+
 - **Custom fields** — a workspace's own fields on an asset. `assets.custom` holds the values;
   nothing defines a field, so `create` and `update` refuse to write into it at all.
-- **Attachments** — receipts, warranties and manuals against an asset or a repair.
 
 Further off, and with nothing in the schema yet: locations and stock control (bins, counts, reorder
 points), purchasing, depreciation, and reservations.

package/dist/contract/capabilities.d.ts

@@ -20,10 +20,10 @@
  *   the rows stay exactly where they are. Anything that would need data thrown away to reverse is
  *   not a capability, however much it looks like one.
  *
- * The rest arrive with the work that makes them mean something: `repairs`, `attachments` and
- * `labels` with the finished register; `custom_fields` and `locations` beside them; `stock` and
- * `procurement` with stock control; `depreciation` and `reservations` last. Adding one here before
- * its procedures exist is the mistake this comment is here to prevent.
+ * The rest arrive with the work that makes them mean something: `labels` with the finished register;
+ * `custom_fields` and `locations` beside them; `stock` and `procurement` with stock control;
+ * `depreciation` and `reservations` last. Adding one here before its procedures exist is the mistake
+ * this comment is here to prevent.
  */
 export declare const inventoryCapabilities: readonly {
     id: string;

package/dist/contract/capabilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../src/contract/capabilities.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;GAWhC,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAA;AAEhF;;;;;;;;;GASG;AACH,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAM,CAAA"}
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../src/contract/capabilities.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;GAiDhC,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAA;AAEhF;;;;;;;;;GASG;AACH,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAM3E,CAAA"}

package/dist/contract/capabilities.js

@@ -21,22 +21,58 @@ import { defineCapabilities } from '@kernhq/contracts';
  *   the rows stay exactly where they are. Anything that would need data thrown away to reverse is
  *   not a capability, however much it looks like one.
  *
- * The rest arrive with the work that makes them mean something: `repairs`, `attachments` and
- * `labels` with the finished register; `custom_fields` and `locations` beside them; `stock` and
- * `procurement` with stock control; `depreciation` and `reservations` last. Adding one here before
- * its procedures exist is the mistake this comment is here to prevent.
+ * The rest arrive with the work that makes them mean something: `labels` with the finished register;
+ * `custom_fields` and `locations` beside them; `stock` and `procurement` with stock control;
+ * `depreciation` and `reservations` last. Adding one here before its procedures exist is the mistake
+ * this comment is here to prevent.
  */
 export const inventoryCapabilities = defineCapabilities([
     {
         id: 'core',
         label: 'Assets',
-        // Says only what the module answers today. Custody and the change history are what the schema
-        // is shaped for and neither has a procedure yet, so naming them here promised a workspace two
-        // features it would then go looking for.
-        description: 'The asset register: what the company owns, item by item',
+        // Says only what the module answers today, which is the rule this line has been held to in both
+        // directions: custody and the change history were taken *out* of it while neither had a
+        // procedure, and put back in the change that gave them one.
+        description: 'The asset register: what the company owns item by item, who is holding each one, and how each one got there',
         required: true,
         level: 1,
     },
+    {
+        /**
+         * The first capability anyone can actually switch, and the reason it is one is the shape of the
+         * customers: an office that hands out laptops wants a register and never records a repair,
+         * while a company with a workshop wants little else. One answer for the whole workspace, not
+         * per person — so a capability rather than a permission — and switching it off writes a boolean
+         * into module settings and leaves every repair row exactly where it was.
+         *
+         * `dependsOn: ['core']` says the obvious out loud: a repair is a trip *an asset* made, so there
+         * is nothing to record without the register. It also means the closure prunes this
+         * automatically if `core` could ever be off, rather than each screen remembering to check two
+         * switches.
+         */
+        id: 'repairs',
+        label: 'Repairs',
+        description: 'What went away to be fixed, to whom, what it cost and when it came back — and the `under repair` status that follows an open one',
+        dependsOn: ['core'],
+        defaultEnabled: true,
+        level: 1,
+    },
+    {
+        /**
+         * Files against an asset or a repair — a purchase receipt, a warranty card, a repair invoice.
+         *
+         * Separate from `repairs` because plenty of workspaces want one without the other: an office
+         * that keeps receipts and never records a repair, and a workshop that records repairs and keeps
+         * no paperwork. Switching it off hides the Files tab and answers 404; the rows and the files in
+         * core's storage are untouched, which is what makes it a capability rather than a migration.
+         */
+        id: 'attachments',
+        label: 'Files',
+        description: 'Receipts, warranties and manuals kept against an asset or one of its repairs',
+        dependsOn: ['core'],
+        defaultEnabled: true,
+        level: 1,
+    },
 ]);
 /**
  * Which procedures sit behind which capability.
@@ -48,5 +84,11 @@ export const inventoryCapabilities = defineCapabilities([
  * A procedure absent from this map belongs to the module as a whole and is reachable whenever
  * Inventory is on — which for `core` is always, because it is `required`.
  */
-export const inventoryCapabilityProcedures = {};
+export const inventoryCapabilityProcedures = {
+    repairs: ['repairs.list', 'repairs.create', 'repairs.update', 'repairs.complete'],
+    attachments: ['attachments.list', 'attachments.add', 'attachments.remove'],
+    // `stats.summary` is deliberately absent. It counts assets, which is `core`, and it answers
+    // `outForRepair: null` rather than a number when the workspace has `repairs` off — a count line
+    // and a dashboard card must not disappear because a *different* feature is switched off.
+};
 //# sourceMappingURL=capabilities.js.map

package/dist/contract/capabilities.js.map

@@ -1 +1 @@
-{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../../src/contract/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;IACtD;QACE,EAAE,EAAE,MAAM;QACV,KAAK,EAAE,QAAQ;QACf,8FAA8F;QAC9F,8FAA8F;QAC9F,yCAAyC;QACzC,WAAW,EAAE,yDAAyD;QACtE,QAAQ,EAAE,IAAI;QACd,KAAK,EAAE,CAAC;KACT;CACF,CAAC,CAAA;AAIF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAsC,EAAE,CAAA"}
+{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../../src/contract/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;IACtD;QACE,EAAE,EAAE,MAAM;QACV,KAAK,EAAE,QAAQ;QACf,gGAAgG;QAChG,wFAAwF;QACxF,4DAA4D;QAC5D,WAAW,EACT,6GAA6G;QAC/G,QAAQ,EAAE,IAAI;QACd,KAAK,EAAE,CAAC;KACT;IACD;QACE;;;;;;;;;;;WAWG;QACH,EAAE,EAAE,SAAS;QACb,KAAK,EAAE,SAAS;QAChB,WAAW,EACT,kIAAkI;QACpI,SAAS,EAAE,CAAC,MAAM,CAAC;QACnB,cAAc,EAAE,IAAI;QACpB,KAAK,EAAE,CAAC;KACT;IACD;QACE;;;;;;;WAOG;QACH,EAAE,EAAE,aAAa;QACjB,KAAK,EAAE,OAAO;QACd,WAAW,EAAE,8EAA8E;QAC3F,SAAS,EAAE,CAAC,MAAM,CAAC;QACnB,cAAc,EAAE,IAAI;QACpB,KAAK,EAAE,CAAC;KACT;CACF,CAAC,CAAA;AAIF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAsC;IAC9E,OAAO,EAAE,CAAC,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,kBAAkB,CAAC;IACjF,WAAW,EAAE,CAAC,kBAAkB,EAAE,iBAAiB,EAAE,oBAAoB,CAAC;IAC1E,4FAA4F;IAC5F,gGAAgG;IAChG,yFAAyF;CAC1F,CAAA"}

package/dist/contract/events.d.ts

@@ -29,5 +29,48 @@ export declare const inventoryEvents: {
         assetId: z.ZodUUID;
         workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
     }, z.core.$strip>>;
+    /**
+     * One event for all three of assign, transfer and return, because a subscriber cares that the
+     * answer to "who has it" moved and not by which verb.
+     *
+     * `userId` is null when it came back to stock and `previousUserId` is null when it went out from
+     * stock, so the pair says which of the three happened without a fourth field claiming to. Both
+     * are ids, like everything else here: a subscriber that needs the person asks core with its own
+     * principal, so an event cannot become a way to read a name past a permission check.
+     *
+     * Nothing subscribes to it inside this module. It exists for what is outside — an offboarding
+     * automation that asks what somebody still holds, most obviously — which is the whole reason a
+     * module emits events rather than only writing its own history row.
+     */
+    custodyChanged: import("@kernhq/contracts").EventDef<"inventory.custody.changed", z.ZodObject<{
+        assetId: z.ZodUUID;
+        workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+        userId: z.ZodNullable<z.ZodUUID>;
+        previousUserId: z.ZodNullable<z.ZodUUID>;
+    }, z.core.$strip>>;
+    /**
+     * An item went to a repairer, and an item came back.
+     *
+     * Two events rather than one, where custody has one for three verbs — because a subscriber to
+     * custody cares only that "who has it" moved, while these two are opposite facts with opposite
+     * reactions: something outside this module wants to tell the holder their laptop has gone, and
+     * something else wants to tell them it is back. A single `repair.changed` would make every
+     * subscriber re-read the row to find out which happened.
+     *
+     * No `repair.updated`: correcting a vendor or filling in an invoice a week later is not a fact
+     * anything outside this module reacts to, and the screens that do care are refreshed by
+     * `kernel.realtime.change`, which needs no declaration. Declaring one so the set looks symmetrical
+     * is the same lie as a capability nothing checks.
+     */
+    repairOpened: import("@kernhq/contracts").EventDef<"inventory.repair.opened", z.ZodObject<{
+        assetId: z.ZodUUID;
+        repairId: z.ZodUUID;
+        workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+    }, z.core.$strip>>;
+    repairCompleted: import("@kernhq/contracts").EventDef<"inventory.repair.completed", z.ZodObject<{
+        assetId: z.ZodUUID;
+        repairId: z.ZodUUID;
+        workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+    }, z.core.$strip>>;
 };
 //# sourceMappingURL=events.d.ts.map

package/dist/contract/events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/contract/events.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;GAKG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;IAa1B;;;;;;OAMG;;;;;CAKJ,CAAA"}
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/contract/events.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;GAKG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;IAa1B;;;;;;OAMG;;;;;IAKH;;;;;;;;;;;;OAYG;;;;;;;IAUH;;;;;;;;;;;;;OAaG;;;;;;;;;;;CAcJ,CAAA"}

package/dist/contract/events.js

@@ -18,5 +18,45 @@ export const inventoryEvents = {
      * better, recording `retired` and `restored` separately.
      */
     assetRestored: defineEvent('inventory.asset.restored', z.object({ assetId: z.uuid(), workspaceId: WorkspaceId })),
+    /**
+     * One event for all three of assign, transfer and return, because a subscriber cares that the
+     * answer to "who has it" moved and not by which verb.
+     *
+     * `userId` is null when it came back to stock and `previousUserId` is null when it went out from
+     * stock, so the pair says which of the three happened without a fourth field claiming to. Both
+     * are ids, like everything else here: a subscriber that needs the person asks core with its own
+     * principal, so an event cannot become a way to read a name past a permission check.
+     *
+     * Nothing subscribes to it inside this module. It exists for what is outside — an offboarding
+     * automation that asks what somebody still holds, most obviously — which is the whole reason a
+     * module emits events rather than only writing its own history row.
+     */
+    custodyChanged: defineEvent('inventory.custody.changed', z.object({
+        assetId: z.uuid(),
+        workspaceId: WorkspaceId,
+        userId: z.uuid().nullable(),
+        previousUserId: z.uuid().nullable(),
+    })),
+    /**
+     * An item went to a repairer, and an item came back.
+     *
+     * Two events rather than one, where custody has one for three verbs — because a subscriber to
+     * custody cares only that "who has it" moved, while these two are opposite facts with opposite
+     * reactions: something outside this module wants to tell the holder their laptop has gone, and
+     * something else wants to tell them it is back. A single `repair.changed` would make every
+     * subscriber re-read the row to find out which happened.
+     *
+     * No `repair.updated`: correcting a vendor or filling in an invoice a week later is not a fact
+     * anything outside this module reacts to, and the screens that do care are refreshed by
+     * `kernel.realtime.change`, which needs no declaration. Declaring one so the set looks symmetrical
+     * is the same lie as a capability nothing checks.
+     */
+    repairOpened: defineEvent('inventory.repair.opened', z.object({ assetId: z.uuid(), repairId: z.uuid(), workspaceId: WorkspaceId })),
+    repairCompleted: defineEvent('inventory.repair.completed', z.object({ assetId: z.uuid(), repairId: z.uuid(), workspaceId: WorkspaceId })),
+    // No category and no attachment events, deliberately. An event is for something outside this
+    // module to react to, and nothing outside it has an opinion about a workspace renaming "Laptops"
+    // or filing a receipt; the screens that do care are refreshed by `kernel.realtime.change`, which
+    // needs no declaration. Declaring one here so the list looks complete is the same lie as a
+    // capability nothing checks.
 };
 //# sourceMappingURL=events.js.map

package/dist/contract/events.js.map

@@ -1 +1 @@
-{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/contract/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,YAAY,EAAE,WAAW,CACvB,yBAAyB,EACzB,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAC1D;IACD,YAAY,EAAE,WAAW,CACvB,yBAAyB,EACzB,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAC1D;IACD,aAAa,EAAE,WAAW,CACxB,0BAA0B,EAC1B,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAC1D;IACD;;;;;;OAMG;IACH,aAAa,EAAE,WAAW,CACxB,0BAA0B,EAC1B,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAC1D;CACF,CAAA"}
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/contract/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,YAAY,EAAE,WAAW,CACvB,yBAAyB,EACzB,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAC1D;IACD,YAAY,EAAE,WAAW,CACvB,yBAAyB,EACzB,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAC1D;IACD,aAAa,EAAE,WAAW,CACxB,0BAA0B,EAC1B,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAC1D;IACD;;;;;;OAMG;IACH,aAAa,EAAE,WAAW,CACxB,0BAA0B,EAC1B,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAC1D;IACD;;;;;;;;;;;;OAYG;IACH,cAAc,EAAE,WAAW,CACzB,2BAA2B,EAC3B,CAAC,CAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE;QACjB,WAAW,EAAE,WAAW;QACxB,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE;QAC3B,cAAc,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE;KACpC,CAAC,CACH;IACD;;;;;;;;;;;;;OAaG;IACH,YAAY,EAAE,WAAW,CACvB,yBAAyB,EACzB,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAC9E;IACD,eAAe,EAAE,WAAW,CAC1B,4BAA4B,EAC5B,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAC9E;IACD,6FAA6F;IAC7F,iGAAiG;IACjG,iGAAiG;IACjG,2FAA2F;IAC3F,6BAA6B;CAC9B,CAAA"}

package/dist/contract/index.d.ts

@@ -9,6 +9,7 @@
 export * from './capabilities.js';
 export * from './events.js';
 export * from './models.js';
+export * from './notifications.js';
 export * from './permissions.js';
 export * from './router.js';
 export * from './settings.js';

package/dist/contract/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA"}

package/dist/contract/index.js

@@ -9,6 +9,7 @@
 export * from './capabilities.js';
 export * from './events.js';
 export * from './models.js';
+export * from './notifications.js';
 export * from './permissions.js';
 export * from './router.js';
 export * from './settings.js';

package/dist/contract/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA"}