@robbeverhelst/do 1.391.0 → 1.393.0

package/dist/do.js

@@ -14420,7 +14420,7 @@ var configError = (message) => new CliError("config", message, EXIT.CONFIG);
 
 // src/meta.ts
 var CLI_NAME = "do";
-var VERSION = "1.391.0";
+var VERSION = "1.393.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -20801,6 +20801,49 @@ var animalHandoverNotes = pgTable("animal_handover_notes", {
   photoFileId: text("photo_file_id").references(() => files.id, { onDelete: "set null" }),
   createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
 }, (t) => [index("animal_handover_notes_period_idx").on(t.tenantId, t.periodId)]);
+var animalMedicineEveryUnit = pgEnum("animal_medicine_every_unit", [
+  "day",
+  "week",
+  "month"
+]);
+var animalMedicines = pgTable("animal_medicines", {
+  id: text("id").primaryKey(),
+  tenantId: text("tenant_id").notNull().references(() => tenants.id),
+  title: text("title").notNull(),
+  dose: text("dose"),
+  everyCount: integer2("every_count").notNull().default(1),
+  everyUnit: animalMedicineEveryUnit("every_unit").notNull().default("day"),
+  timeOfDay: text("time_of_day"),
+  startsOn: date5("starts_on", { mode: "string" }),
+  endsOn: date5("ends_on", { mode: "string" }),
+  nextOn: date5("next_on", { mode: "string" }),
+  stock: doublePrecision("stock"),
+  unit: text("unit"),
+  perDose: doublePrecision("per_dose").notNull().default(1),
+  lowAt: doublePrecision("low_at"),
+  note: text("note"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (t) => [index("animal_medicines_tenant_idx").on(t.tenantId)]);
+var animalMedicineAnimals = pgTable("animal_medicine_animals", {
+  tenantId: text("tenant_id").notNull().references(() => tenants.id),
+  medicineId: text("medicine_id").notNull().references(() => animalMedicines.id, { onDelete: "cascade" }),
+  animalId: text("animal_id").notNull().references(() => animals.id, { onDelete: "cascade" })
+}, (t) => [
+  primaryKey({ columns: [t.medicineId, t.animalId] }),
+  index("animal_medicine_animals_animal_idx").on(t.tenantId, t.animalId)
+]);
+var animalMedicineDoses = pgTable("animal_medicine_doses", {
+  id: text("id").primaryKey(),
+  tenantId: text("tenant_id").notNull().references(() => tenants.id),
+  medicineId: text("medicine_id").notNull().references(() => animalMedicines.id, { onDelete: "cascade" }),
+  day: date5("day", { mode: "string" }).notNull(),
+  givenAt: timestamp("given_at", { withTimezone: true }).notNull().defaultNow(),
+  givenByUserId: text("given_by_user_id").references(() => users.id, { onDelete: "set null" }),
+  took: doublePrecision("took").notNull().default(0),
+  nextWas: date5("next_was", { mode: "string" }),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (t) => [unique("animal_medicine_doses_day_uniq").on(t.medicineId, t.day)]);
 
 // ../../packages/schema/src/db/documents.ts
 var documentKind = pgEnum("document_kind", [
@@ -21712,6 +21755,61 @@ var animalArrivedInputSchema = object({
   on: keyDateDaySchema.optional(),
   quarantineMonths: number2().int().min(0).max(12).optional()
 }).strict();
+var animalMedicineEveryUnitSchema = _enum2(animalMedicineEveryUnit.enumValues);
+var animalMedicineViewSchema = object({
+  id: ulidSchema,
+  title: string2(),
+  dose: string2().nullable(),
+  everyCount: number2().int(),
+  everyUnit: animalMedicineEveryUnitSchema,
+  timeOfDay: string2().nullable(),
+  startsOn: string2().nullable(),
+  endsOn: string2().nullable(),
+  nextOn: string2().nullable(),
+  stock: number2().nullable(),
+  unit: string2().nullable(),
+  perDose: number2(),
+  lowAt: number2().nullable(),
+  note: string2().nullable(),
+  animals: array(nodeRefSchema),
+  daily: boolean2(),
+  low: boolean2(),
+  ended: boolean2(),
+  course: object({ day: number2().int(), of: number2().int() }).nullable(),
+  dueToday: boolean2(),
+  doneToday: boolean2(),
+  lastGivenOn: string2().nullable(),
+  createdAt: exports_coerce.date(),
+  updatedAt: exports_coerce.date()
+});
+var medicineText = (max) => string2().trim().min(1).max(max);
+var animalMedicineFields = object({
+  id: ulidSchema,
+  title: medicineText(120),
+  animalIds: array(ulidSchema).min(1).max(20),
+  dose: medicineText(120).nullish(),
+  everyCount: number2().int().min(1).max(366).optional(),
+  everyUnit: animalMedicineEveryUnitSchema.optional(),
+  timeOfDay: string2().regex(/^(morning|midday|afternoon|evening|night|([01][0-9]|2[0-3]):[0-5][0-9])$/).nullish(),
+  startsOn: keyDateDaySchema.nullish(),
+  endsOn: keyDateDaySchema.nullish(),
+  nextOn: keyDateDaySchema.nullish(),
+  stock: number2().min(0).max(1e5).nullish(),
+  unit: medicineText(30).nullish(),
+  perDose: number2().positive().max(1e4).optional(),
+  lowAt: number2().min(0).max(1e5).nullish(),
+  note: medicineText(300).nullish()
+}).strict();
+var endsAfterStart2 = (v) => !v.startsOn || !v.endsOn || v.endsOn >= v.startsOn;
+var endsMessage = { message: "endsOn is before startsOn", path: ["endsOn"] };
+var createAnimalMedicineInputSchema = animalMedicineFields.refine(endsAfterStart2, endsMessage);
+var updateAnimalMedicineInputSchema = animalMedicineFields.omit({ id: true }).partial().strict().refine(endsAfterStart2, endsMessage);
+var animalMedicinesQuerySchema = object({
+  animalId: ulidSchema.optional(),
+  day: keyDateDaySchema.optional(),
+  includeEnded: _enum2(["true", "false"]).transform((v) => v === "true").optional()
+});
+var animalMedicineDoseInputSchema = object({ day: keyDateDaySchema.optional() }).strict();
 
 // ../../packages/schema/src/operations/crud.ts
 var DELETE_REASON_QUERY = [
@@ -21795,6 +21893,7 @@ function crudOperations(r) {
 var READ = ["animals:read"];
 var WRITE = ["animals:write"];
 var visit = { visitId: "The vet visit's ULID." };
+var medicine = { medicineId: "The medicine's ULID." };
 var animalOperations = defineOperations({
   ...crudOperations({
     segment: "animals",
@@ -21883,6 +21982,96 @@ var animalOperations = defineOperations({
     response: { description: "The species profile." },
     errors: { 400: true }
   },
+  listMedicines: {
+    method: "get",
+    path: "/animals/medicines",
+    scopes: READ,
+    tag: "Animals",
+    summary: "List the animals' medicines",
+    description: "By title: each medicine with the `animals` it's for, its `dose`, how often (`everyCount` `everyUnit`; `daily` when every 1 day), `timeOfDay`, a course's `startsOn`/`endsOn` and its `course` day N of M, the `nextOn` day of one that isn't daily, the counted `stock` (`unit`, `perDose`, `low` at `lowAt`), the `note`, and on `day` (UTC today by default) whether it's `dueToday` and `doneToday`, with `lastGivenOn`. Ended courses only with `includeEnded`.",
+    query: [
+      { name: "animalId", description: "Only this animal's (an animal's ULID)." },
+      { name: "day", description: "The reader's day, `YYYY-MM-DD`; UTC today when left out." },
+      { name: "includeEnded", description: "`true`: ended courses too." }
+    ],
+    querySchema: animalMedicinesQuerySchema,
+    status: 200,
+    response: { description: "The medicines." }
+  },
+  createMedicine: {
+    method: "post",
+    path: "/animals/medicines",
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Add a medicine for one animal or a few",
+    description: "A daily one (the default, every 1 day), a course (`startsOn` to `endsOn`) or one that comes round (`everyCount` `everyUnit`, with its `nextOn`). Count the `stock` to have each dose take `perDose` (default 1) from it and say low at `lowAt`. Every animal must be one in this Space (400).",
+    body: createAnimalMedicineInputSchema,
+    status: 201,
+    response: { description: "The medicine." },
+    errors: { 400: true }
+  },
+  getMedicine: {
+    method: "get",
+    path: "/animals/medicines/{medicineId}",
+    pathParams: medicine,
+    scopes: READ,
+    tag: "Animals",
+    summary: "A medicine, as it stands today",
+    description: "The same shape as a row of the list, on UTC today.",
+    status: 200,
+    response: { description: "The medicine." },
+    errors: { 404: true }
+  },
+  updateMedicine: {
+    method: "patch",
+    path: "/animals/medicines/{medicineId}",
+    pathParams: medicine,
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Change a medicine",
+    description: "A field left out stays; `null` clears it; `animalIds` replaces who it's for. Set `stock` when a new box comes in.",
+    body: updateAnimalMedicineInputSchema,
+    status: 200,
+    response: { description: "The medicine." },
+    errors: { 400: true, 404: true }
+  },
+  removeMedicine: {
+    method: "delete",
+    path: "/animals/medicines/{medicineId}",
+    pathParams: medicine,
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Remove a medicine",
+    description: "With the doses given; to stop a course and keep it, set its `endsOn` instead.",
+    status: 204,
+    response: { description: "Removed." },
+    errors: { 404: true }
+  },
+  giveMedicineDose: {
+    method: "post",
+    path: "/animals/medicines/{medicineId}/doses",
+    pathParams: medicine,
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Give a medicine's dose",
+    description: "The dose for `day` (UTC today by default): it takes `perDose` from a counted stock (never below 0) and moves the next day of one that isn't daily on from that day. Again that day changes nothing.",
+    body: animalMedicineDoseInputSchema,
+    status: 200,
+    response: { description: "The medicine, on that day." },
+    errors: { 400: true, 404: true }
+  },
+  undoMedicineDose: {
+    method: "delete",
+    path: "/animals/medicines/{medicineId}/doses/{day}",
+    pathParams: { ...medicine, day: "The day it was given for, `YYYY-MM-DD`." },
+    scopes: WRITE,
+    tag: "Animals",
+    summary: "Take a medicine's dose back",
+    description: "The stock and the next day go back to before it; 404 when none was given that day.",
+    status: 200,
+    response: { description: "The medicine, on that day." },
+    errors: { 400: "`day` isn't a `YYYY-MM-DD` day.", 404: true }
+  },
   vetVisit: {
     method: "get",
     path: "/animals/vet-visits/{visitId}",
@@ -23933,6 +24122,24 @@ var collectionSavedViews = pgTable("collection_saved_views", {
 }, (t) => [
   index("collection_saved_views_tenant_idx").on(t.tenantId)
 ]);
+var collectionKinds = pgTable("collection_kinds", {
+  id: text("id").primaryKey(),
+  tenantId: text("tenant_id").notNull().references(() => tenants.id),
+  key: text("key").notNull(),
+  name: text("name").notNull(),
+  one: text("one").notNull(),
+  many: text("many").notNull(),
+  icon: text("icon").notNull().default("tag"),
+  preset: text("preset"),
+  fields: jsonb("fields").$type().notNull().default([]),
+  statusWords: jsonb("status_words").$type().notNull(),
+  view: text("view").notNull().default("grid"),
+  createdByUserId: text("created_by_user_id").references(() => users.id, {
+    onDelete: "set null"
+  }),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (t) => [unique("collection_kinds_tenant_key_uniq").on(t.tenantId, t.key)]);
 
 // ../../packages/schema/src/contracts/collection-values.ts
 var collectionStatusValues = ["want", "have", "doing", "done", "dropped", "gone"];
@@ -26139,6 +26346,162 @@ var circleOperations = defineOperations({
   })
 });
 
+// ../../packages/schema/src/contracts/collection-kinds.ts
+var collectionKindFieldTypeValues = [
+  "text",
+  "number",
+  "choice",
+  "year",
+  "date",
+  "yesno"
+];
+var collectionKindFieldTypeSchema = _enum2(collectionKindFieldTypeValues);
+var collectionKindIconValues = [
+  "disc",
+  "dice",
+  "brick",
+  "book",
+  "pad",
+  "sprout",
+  "paw",
+  "tag"
+];
+var collectionKindIconSchema = _enum2(collectionKindIconValues);
+var collectionKindPresetValues = ["lego", "vinyl", "board", "custom"];
+var collectionKindPresetSchema = _enum2(collectionKindPresetValues);
+var slug = string2().min(1).max(40).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "lowercase letters and digits, dashes between");
+var collectionKindKeySchema = slug.refine((k) => !collectionTypeValues.includes(k), "that's a built-in kind");
+var collectionKindFieldSchema = object({
+  key: slug,
+  label: string2().trim().min(1).max(40),
+  type: collectionKindFieldTypeSchema,
+  choices: array(string2().trim().min(1).max(40)).max(30).optional()
+}).strict().refine((f) => f.type === "choice" || f.choices === undefined, {
+  message: "only a choice field has choices",
+  path: ["choices"]
+});
+var collectionKindFieldsSchema = array(collectionKindFieldSchema).max(12).refine((fs) => new Set(fs.map((f) => f.key)).size === fs.length, "each field key once");
+var word = string2().trim().min(1).max(30);
+var collectionKindStatusWordsSchema = object({ want: word, have: word, doing: word, done: word, dropped: word }).strict();
+var collectionKindSchema = object({
+  id: ulidSchema,
+  key: string2(),
+  name: string2(),
+  one: string2(),
+  many: string2(),
+  icon: string2(),
+  preset: string2().nullable(),
+  fields: array(object({
+    key: string2(),
+    label: string2(),
+    type: string2(),
+    choices: array(string2()).optional()
+  })),
+  statusWords: collectionKindStatusWordsSchema,
+  view: string2(),
+  itemCount: number2().int(),
+  createdAt: exports_coerce.date(),
+  updatedAt: exports_coerce.date()
+});
+var name2 = string2().trim().min(1).max(40);
+var createCollectionKindInputSchema = object({
+  id: ulidSchema,
+  name: name2,
+  key: collectionKindKeySchema.optional(),
+  one: name2.optional(),
+  many: name2.optional(),
+  icon: collectionKindIconSchema.optional(),
+  preset: collectionKindPresetSchema.optional(),
+  fields: collectionKindFieldsSchema.optional(),
+  statusWords: collectionKindStatusWordsSchema.optional()
+}).strict();
+var updateCollectionKindInputSchema = object({
+  name: name2.optional(),
+  one: name2.optional(),
+  many: name2.optional(),
+  icon: collectionKindIconSchema.optional(),
+  fields: collectionKindFieldsSchema.optional(),
+  statusWords: collectionKindStatusWordsSchema.optional()
+}).strict();
+var f = (label, type) => ({
+  key: kindSlug(label),
+  label,
+  type
+});
+var COLLECTION_KIND_PRESETS = {
+  lego: {
+    name: "LEGO",
+    one: "set",
+    icon: "brick",
+    fields: [
+      f("Set number", "text"),
+      f("Pieces", "number"),
+      f("Theme", "choice"),
+      f("Bags", "number"),
+      f("Minifigures", "number"),
+      f("Released", "year")
+    ],
+    statusWords: {
+      want: "Want",
+      have: "In the box",
+      doing: "Building",
+      done: "Built",
+      dropped: "Parted out"
+    }
+  },
+  vinyl: {
+    name: "Vinyl",
+    one: "record",
+    icon: "disc",
+    fields: [
+      f("Artist", "text"),
+      f("Label", "choice"),
+      f("Pressing", "text"),
+      f("Speed", "number"),
+      f("Condition", "choice"),
+      f("Released", "year")
+    ],
+    statusWords: {
+      want: "Want",
+      have: "Have",
+      doing: "On rotation",
+      done: "Played out",
+      dropped: "Sold"
+    }
+  },
+  board: {
+    name: "Board games",
+    one: "board game",
+    icon: "dice",
+    fields: [
+      f("Players", "number"),
+      f("Play time", "text"),
+      f("Designer", "text"),
+      f("Expansions", "text"),
+      f("Plays", "number"),
+      f("Released", "year")
+    ],
+    statusWords: {
+      want: "Want",
+      have: "Have",
+      doing: "Learning",
+      done: "Played",
+      dropped: "Gave away"
+    }
+  },
+  custom: {
+    name: "",
+    one: "",
+    icon: "tag",
+    fields: [f("Maker", "text"), f("Year", "year"), f("Condition", "choice")],
+    statusWords: { want: "Want", have: "Have", doing: "Using", done: "Done", dropped: "Gone" }
+  }
+};
+function kindSlug(name) {
+  const s = name.toLowerCase().normalize("NFKD").replace(/[\u0300-\u036F]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/, "");
+  return s || "kind";
+}
+
 // ../../packages/schema/src/contracts/pagination.ts
 var paginationQuerySchema = object({
   limit: exports_coerce.number().int().positive().optional(),
@@ -26149,6 +26512,7 @@ var paginationQuerySchema = object({
 var READ2 = ["collections:read"];
 var WRITE2 = ["collections:write"];
 var entryParams = { entryId: "The entry's ULID." };
+var kindParams = { kindId: "The kind's ULID." };
 var collectionOperations = defineOperations({
   ...crudOperations({
     segment: "collection",
@@ -26204,6 +26568,65 @@ var collectionOperations = defineOperations({
     status: 200,
     response: { description: "The Type registry." }
   },
+  listKinds: {
+    method: "get",
+    path: "/collection/kinds",
+    scopes: READ2,
+    tag: "Collection",
+    summary: "List the Space's own kinds",
+    description: "The kinds the Space added (vinyl, board games, \u2026) beside the built-in Types, by name: each with its `key` (what an Item of it carries as its `type`), `name`, `one`/`many`, `icon`, the `preset` it started from, its `fields` (key, label, type: `text`, `number`, `choice`, `year`, `date` or `yesno`, and a choice field's `choices`; the first three show on its tile), its `statusWords` for want, have, doing, done and dropped, its `view` (`grid`) and `itemCount`.",
+    status: 200,
+    response: { description: "The kinds." }
+  },
+  createKind: {
+    method: "post",
+    path: "/collection/kinds",
+    scopes: WRITE2,
+    tag: "Collection",
+    summary: "Add a kind",
+    description: "Start from a `preset` (`lego`, `vinyl`, `board` or `custom`, \"Something else\") and a `name`; what's left out comes from the preset (the icon, the fields, the status words), the `key` is the name's slug (never a built-in Type; 409 when the Space has it) and `one`/`many` come from the name. It starts on the clean grid.",
+    body: createCollectionKindInputSchema,
+    status: 201,
+    response: { description: "The kind." },
+    errors: { 400: true, 409: "The Space already has a kind with this key." }
+  },
+  getKind: {
+    method: "get",
+    path: "/collection/kinds/{kindId}",
+    pathParams: kindParams,
+    scopes: READ2,
+    tag: "Collection",
+    summary: "A kind of the Space's own",
+    description: "The same shape as a row of the list.",
+    status: 200,
+    response: { description: "The kind." },
+    errors: { 404: true }
+  },
+  updateKind: {
+    method: "patch",
+    path: "/collection/kinds/{kindId}",
+    pathParams: kindParams,
+    scopes: WRITE2,
+    tag: "Collection",
+    summary: "Change a kind",
+    description: "Its name, one/many, icon, `fields` (replaces the list) or `statusWords`; a field left out stays. The key never changes.",
+    body: updateCollectionKindInputSchema,
+    status: 200,
+    response: { description: "The kind." },
+    errors: { 400: true, 404: true }
+  },
+  removeKind: {
+    method: "delete",
+    path: "/collection/kinds/{kindId}",
+    pathParams: kindParams,
+    scopes: WRITE2,
+    tag: "Collection",
+    summary: "Remove a kind",
+    description: "Only a kind with no Items (409 otherwise: move or remove them first).",
+    status: 204,
+    response: { description: "Removed." },
+    errors: { 404: true, 409: "The kind still has Items." }
+  },
   backfillCovers: {
     method: "post",
     path: "/collection/covers",
@@ -31309,9 +31732,9 @@ var eventFields = {
   note: eventTextSchema(1000).nullish(),
   sort: number2().int().min(0).max(1e4).optional()
 };
-var endsAfterStart2 = (e) => !e.startsAt || !e.endsAt || e.endsAt >= e.startsAt;
-var createGuestListEventInputSchema = object({ id: ulidSchema, guestListId: ulidSchema, key: guestEventKeySchema, ...eventFields }).strict().refine(endsAfterStart2, { message: "endsAt is before startsAt", path: ["endsAt"] });
-var updateGuestListEventInputSchema = object(eventFields).partial().strict().refine(endsAfterStart2, { message: "endsAt is before startsAt", path: ["endsAt"] });
+var endsAfterStart3 = (e) => !e.startsAt || !e.endsAt || e.endsAt >= e.startsAt;
+var createGuestListEventInputSchema = object({ id: ulidSchema, guestListId: ulidSchema, key: guestEventKeySchema, ...eventFields }).strict().refine(endsAfterStart3, { message: "endsAt is before startsAt", path: ["endsAt"] });
+var updateGuestListEventInputSchema = object(eventFields).partial().strict().refine(endsAfterStart3, { message: "endsAt is before startsAt", path: ["endsAt"] });
 var guestListEventsQuerySchema = object({ guestListId: ulidSchema });
 var guestTableSchema = createSelectSchema(guestTables, {
   createdAt: exports_coerce.date(),
@@ -40340,18 +40763,18 @@ var runPlayStatusValues = [
   "dropped"
 ];
 var runPlayStatusSchema = _enum2(runPlayStatusValues);
-var name2 = string2().trim().min(1).max(200);
+var name3 = string2().trim().min(1).max(200);
 var text5 = string2().trim().max(2000);
 var shortText2 = string2().trim().max(300);
 var isoDate = string2().regex(/^\d{4}-\d{2}-\d{2}$/, "must be an ISO date (YYYY-MM-DD)");
 var ref = string2().trim().min(1).max(200);
 var runCharacterSchema = object({
-  name: name2,
+  name: name3,
   pronoun: _enum2(["he", "she", "they"]).nullish(),
   subtitle: shortText2.nullish(),
   level: number2().int().min(0).max(1e4).nullish(),
   build: shortText2.nullish(),
-  stats: array(object({ k: name2, v: union([number2(), shortText2]) }).strict()).max(40).optional(),
+  stats: array(object({ k: name3, v: union([number2(), shortText2]) }).strict()).max(40).optional(),
   traits: array(shortText2).max(20).optional(),
   backstory: text5.nullish(),
   rules: array(shortText2).max(30).optional(),
@@ -40360,12 +40783,12 @@ var runCharacterSchema = object({
 var runArcSchema = object({
   title: shortText2.nullish(),
   chapters: array(object({
-    key: name2,
-    name: name2,
+    key: name3,
+    name: name3,
     range: shortText2.nullish(),
     moral: text5.nullish()
   }).strict()).max(40),
-  current: name2.nullish()
+  current: name3.nullish()
 }).strict();
 var runStepStatusValues = ["done", "now", "todo", "skipped"];
 var runStepStatusSchema = _enum2(runStepStatusValues);
@@ -40378,7 +40801,7 @@ var runQuestStatusValues = ["active", "paused", "planned", "done", "failed"];
 var runQuestStatusSchema = _enum2(runQuestStatusValues);
 var runQuestSchema = object({
   ref: ref.nullish(),
-  name: name2,
+  name: name3,
   line: shortText2.nullish(),
   status: runQuestStatusSchema.default("active"),
   objective: text5.nullish(),
@@ -40393,7 +40816,7 @@ var runQuestSchema = object({
   }).strict()).max(40).optional(),
   pausedAt: shortText2.nullish(),
   why: text5.nullish(),
-  revisitAt: name2.nullish()
+  revisitAt: name3.nullish()
 }).strict();
 var runNextStepsSchema = object({
   items: array(shortText2.pipe(string2().min(1))).max(3),
@@ -40402,50 +40825,50 @@ var runNextStepsSchema = object({
 }).strict();
 var runChoiceSchema = object({
   ref: ref.nullish(),
-  title: name2,
+  title: name3,
   place: shortText2.nullish(),
   status: _enum2(["made", "planned"]).default("made"),
   options: array(shortText2).max(6).optional(),
   why: text5.nullish(),
   consequence: text5.nullish(),
-  revisitAt: name2.nullish(),
-  chapter: name2.nullish(),
+  revisitAt: name3.nullish(),
+  chapter: name3.nullish(),
   tone: _enum2(["good", "grey", "dark"]).nullish(),
   on: isoDate.nullish()
 }).strict();
 var runHomeSchema = object({
   ref: ref.nullish(),
-  name: name2,
+  name: name3,
   role: _enum2(["home", "collector", "storage", "planned", "later"]).default("home"),
   place: shortText2.nullish(),
-  upgrades: array(object({ name: name2, done: boolean2().default(false) }).strict()).max(40).optional(),
+  upgrades: array(object({ name: name3, done: boolean2().default(false) }).strict()).max(40).optional(),
   steward: shortText2.nullish(),
   note: text5.nullish()
 }).strict();
 var runPersonSchema = object({
   ref: ref.nullish(),
-  name: name2,
+  name: name3,
   role: _enum2(["child", "spouse", "steward", "follower", "pet", "rival", "other"]),
   status: _enum2(["with", "planned", "lost"]).default("with"),
   home: shortText2.nullish(),
   note: text5.nullish()
 }).strict();
 var runMountSchema = object({
-  name: name2,
+  name: name3,
   status: _enum2(["with", "planned", "lost"]).default("with"),
   note: text5.nullish()
 }).strict();
 var runUniqueSchema = object({
   ref: ref.nullish(),
-  name: name2,
+  name: name3,
   status: _enum2(["have", "now", "want"]).default("have"),
   source: shortText2.nullish(),
   displayAt: shortText2.nullish(),
-  set: name2.nullish()
+  set: name3.nullish()
 }).strict();
 var runChecklistSchema = object({
   key: string2().trim().min(1).max(60).regex(/^[a-z0-9][a-z0-9_-]*$/, "must be a lowercase slug"),
-  label: name2,
+  label: name3,
   total: number2().int().min(0).max(5000).nullish(),
   items: array(object({ id: ref, label: shortText2.nullish() }).strict()).max(5000).optional(),
   done: array(ref).max(5000),
@@ -40454,7 +40877,7 @@ var runChecklistSchema = object({
   legend: shortText2.nullish()
 }).strict();
 var runTeamMemberSchema = object({
-  species: name2,
+  species: name3,
   nick: shortText2.nullish(),
   level: number2().int().min(1).max(100).nullish(),
   nature: shortText2.nullish(),
@@ -40468,8 +40891,8 @@ var runAchievementsSchema = object({
   source: _enum2(["steam", "xbox", "psn", "manual"]).default("manual"),
   total: number2().int().min(0).max(5000).nullish(),
   enabled: boolean2().default(true),
-  unlocked: array(object({ name: name2, on: isoDate.nullish(), hint: shortText2.nullish(), key: ref.nullish() }).strict()).max(5000),
-  locked: array(object({ name: name2, hint: shortText2.nullish(), key: ref.nullish() }).strict()).max(5000).optional(),
+  unlocked: array(object({ name: name3, on: isoDate.nullish(), hint: shortText2.nullish(), key: ref.nullish() }).strict()).max(5000),
+  locked: array(object({ name: name3, hint: shortText2.nullish(), key: ref.nullish() }).strict()).max(5000).optional(),
   syncedAt: string2().datetime({ offset: true }).nullish()
 }).strict();
 var runRareFindsSchema = object({
@@ -40479,7 +40902,7 @@ var runRareFindsSchema = object({
 }).strict();
 var runInstallSchema = object({
   edition: shortText2.nullish(),
-  mods: array(object({ name: name2, url: string2().url().max(2000).nullish() }).strict()).max(200).default([]),
+  mods: array(object({ name: name3, url: string2().url().max(2000).nullish() }).strict()).max(200).default([]),
   savePath: string2().trim().max(500).nullish(),
   lastBackup: isoDate.nullish(),
   notes: text5.nullish()
@@ -40489,7 +40912,7 @@ var runSaveFields = {
   game: _enum2(["skyrim"]).default("skyrim"),
   fileName: shortText2.nullish(),
   saveNumber: number2().int().min(0).max(1e9),
-  playerName: name2,
+  playerName: name3,
   level: number2().int().min(0).max(1e4),
   location: shortText2,
   race: shortText2.nullish(),
@@ -40535,7 +40958,7 @@ var runFacetSchema = object({
   install: runInstallSchema.nullish(),
   save: runSaveSchema.nullish(),
   money: object({ goal: shortText2.nullish(), purpose: shortText2.nullish() }).strict().nullish(),
-  links: array(object({ label: name2, url: string2().url().max(2000) }).strict()).max(50).optional()
+  links: array(object({ label: name3, url: string2().url().max(2000) }).strict()).max(50).optional()
 }).strict();
 var runListSectionValues = [
   "orderOfPlay",
@@ -40689,12 +41112,12 @@ var runSaveHeaderResultSchema = object({
 var createRunInputSchema = object({
   id: ulidSchema,
   gameId: ulidSchema,
-  title: name2,
+  title: name3,
   status: runPlayStatusSchema.optional(),
   facet: runFacetSchema.optional()
 }).strict();
 var updateRunInputSchema = object({
-  title: name2.optional(),
+  title: name3.optional(),
   status: runPlayStatusSchema.optional(),
   facet: runFacetSchema.optional()
 }).strict();
@@ -46064,6 +46487,172 @@ var commands2 = [
       return { data: { ok: true, animalId: id }, render: renderRecord };
     }
   },
+  {
+    spec: {
+      path: ["animals", "medicines"],
+      summary: "List the animals' medicines and where each stands today.",
+      args: [],
+      flags: [
+        { name: "animal", type: "string", description: "Only this animal's (ULID)." },
+        {
+          name: "day",
+          type: "string",
+          description: "The day to read for, YYYY-MM-DD (default UTC today)."
+        },
+        { name: "include-ended", type: "boolean", description: "Ended courses too." }
+      ],
+      scopes: [...animalOperations.listMedicines.scopes],
+      returns: "AnimalMedicineView[]",
+      notes: `${routeOf(animalOperations.listMedicines)}. Each with its animals, dose, how often, the course's day N of M, the next day, the stock (low or not), and dueToday / doneToday.`
+    },
+    run: async ({ flags, requireClient }) => {
+      const raw = {};
+      const animal = flagString(flags, "animal");
+      const day = flagString(flags, "day");
+      if (animal)
+        raw.animalId = animal;
+      if (day)
+        raw.day = day;
+      if (flagBool(flags, "include-ended"))
+        raw.includeEnded = "true";
+      parseInput(animalMedicinesQuerySchema, raw);
+      return {
+        data: await requireClient().getPage(pathOf(animalOperations.listMedicines), { query: raw }),
+        render: renderList
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["animals", "medicine"],
+      summary: "One medicine, as it stands today.",
+      args: [{ name: "id", required: true, description: "Medicine ULID." }],
+      flags: [],
+      scopes: [...animalOperations.getMedicine.scopes],
+      returns: "AnimalMedicineView",
+      notes: `${routeOf(animalOperations.getMedicine)}.`
+    },
+    run: readOperation(animalOperations.getMedicine, renderRecord, { medicineId: "medicine id" })
+  },
+  {
+    spec: {
+      path: ["animals", "medicine-add"],
+      summary: "Add a medicine for one animal or a few: daily, a course, or one that comes round.",
+      args: [],
+      flags: [
+        {
+          name: "data",
+          type: "string",
+          description: 'JSON: `{ "title": "Joint tablet", "animalIds": ["\u2026"], "dose": "1 tablet with breakfast", "timeOfDay": "morning", "stock": 22, "unit": "tablets", "lowAt": 5 }`; a course adds `startsOn`/`endsOn`, one that comes round `everyCount`/`everyUnit` (`day`, `week`, `month`) and `nextOn`. The id is minted.'
+        }
+      ],
+      scopes: [...animalOperations.createMedicine.scopes],
+      returns: "AnimalMedicineView",
+      notes: `${routeOf(animalOperations.createMedicine)}. Daily unless said; each dose takes \`perDose\` (default 1) from a counted stock.`
+    },
+    run: async ({ flags, requireClient }) => {
+      const body = parseInput(createAnimalMedicineInputSchema, {
+        id: ulid3(),
+        ...readDataFlag(flags)
+      });
+      return {
+        data: await requireClient().post(pathOf(animalOperations.createMedicine), body),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["animals", "medicine-update"],
+      summary: "Change a medicine (a new box: set its stock).",
+      args: [{ name: "id", required: true, description: "Medicine ULID." }],
+      flags: [
+        {
+          name: "data",
+          type: "string",
+          description: "UpdateAnimalMedicineInput JSON; null clears a field."
+        }
+      ],
+      scopes: [...animalOperations.updateMedicine.scopes],
+      returns: "AnimalMedicineView",
+      notes: `${routeOf(animalOperations.updateMedicine)}. \`animalIds\` replaces who it's for.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const medicineId = requireArg(args, 0, "medicine id");
+      const body = parseInput(updateAnimalMedicineInputSchema, readDataFlag(flags));
+      return {
+        data: await requireClient().patch(pathOf(animalOperations.updateMedicine, { medicineId }), body),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["animals", "medicine-remove"],
+      summary: "Remove a medicine, with the doses given.",
+      args: [{ name: "id", required: true, description: "Medicine ULID." }],
+      flags: [],
+      scopes: [...animalOperations.removeMedicine.scopes],
+      returns: "void",
+      notes: `${routeOf(animalOperations.removeMedicine)}. Destructive: the doses go too, so it needs --allow-destructive; to stop a course and keep it, set its endsOn.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const medicineId = requireArg(args, 0, "medicine id");
+      assertDestructiveAllowed(flags, `remove medicine ${medicineId} and its doses`);
+      await requireClient().delete(pathOf(animalOperations.removeMedicine, { medicineId }));
+      return { data: { ok: true, medicineId }, render: renderRecord };
+    }
+  },
+  {
+    spec: {
+      path: ["animals", "medicine-dose"],
+      summary: "Give a medicine's dose (today, or --day).",
+      args: [{ name: "id", required: true, description: "Medicine ULID." }],
+      flags: [
+        {
+          name: "day",
+          type: "string",
+          description: "The day it's for, YYYY-MM-DD (default UTC today)."
+        }
+      ],
+      scopes: [...animalOperations.giveMedicineDose.scopes],
+      returns: "AnimalMedicineView",
+      notes: `${routeOf(animalOperations.giveMedicineDose)}. Takes \`perDose\` from a counted stock and moves the next day on; again that day changes nothing.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const medicineId = requireArg(args, 0, "medicine id");
+      const day = flagString(flags, "day");
+      const body = parseInput(animalMedicineDoseInputSchema, day ? { day } : {});
+      return {
+        data: await requireClient().post(pathOf(animalOperations.giveMedicineDose, { medicineId }), body),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["animals", "medicine-undose"],
+      summary: "Take a medicine's dose back.",
+      args: [
+        { name: "id", required: true, description: "Medicine ULID." },
+        { name: "day", required: true, description: "The day it was given for, YYYY-MM-DD." }
+      ],
+      flags: [],
+      scopes: [...animalOperations.undoMedicineDose.scopes],
+      returns: "AnimalMedicineView",
+      notes: `${routeOf(animalOperations.undoMedicineDose)}. The stock and the next day go back to before it.`
+    },
+    run: async ({ args, requireClient }) => {
+      const medicineId = requireArg(args, 0, "medicine id");
+      const { day } = parseInput(animalMedicineDoseInputSchema, {
+        day: requireArg(args, 1, "day")
+      });
+      return {
+        data: await requireClient().delete(pathOf(animalOperations.undoMedicineDose, { medicineId, day })),
+        render: renderRecord
+      };
+    }
+  },
   {
     spec: {
       path: ["animals", "acquisition"],
@@ -47132,6 +47721,106 @@ var commands9 = [
       return { data: types, render: renderList };
     }
   },
+  {
+    spec: {
+      path: ["collection", "kinds"],
+      summary: "List the Space's own kinds (vinyl, board games, \u2026) with their fields and words.",
+      args: [],
+      flags: [],
+      scopes: [...collectionOperations.listKinds.scopes],
+      returns: "CollectionKind[]",
+      notes: `${routeOf(collectionOperations.listKinds)}. Each kind's \`key\` is what an Item of it carries as its \`type\`.`
+    },
+    run: async ({ requireClient }) => ({
+      data: await requireClient().getPage(pathOf(collectionOperations.listKinds)),
+      render: renderList
+    })
+  },
+  {
+    spec: {
+      path: ["collection", "kind"],
+      summary: "One of the Space's own kinds.",
+      args: [{ name: "id", required: true, description: "Kind ULID." }],
+      flags: [],
+      scopes: [...collectionOperations.getKind.scopes],
+      returns: "CollectionKind",
+      notes: `${routeOf(collectionOperations.getKind)}.`
+    },
+    run: readOperation(collectionOperations.getKind, renderRecord, { kindId: "kind id" })
+  },
+  {
+    spec: {
+      path: ["collection", "kind-add"],
+      summary: "Add a kind: from a preset (lego, vinyl, board, custom) or from scratch.",
+      args: [{ name: "name", required: true, description: 'Its name ("Vinyl").' }],
+      flags: [
+        {
+          name: "preset",
+          type: "string",
+          description: `Start from ${Object.keys(COLLECTION_KIND_PRESETS).join(", ")}; what's left out comes from it.`
+        },
+        {
+          name: "data",
+          type: "string",
+          description: 'More JSON: `{ "key": "\u2026", "one": "record", "many": "records", "icon": "disc", "fields": [{ "key": "artist", "label": "Artist", "type": "text" }], "statusWords": { \u2026 } }`. The id is minted.'
+        }
+      ],
+      scopes: [...collectionOperations.createKind.scopes],
+      returns: "CollectionKind",
+      notes: `${routeOf(collectionOperations.createKind)}. The key is the name's slug unless given; a key the Space has is a 409. \`do collection kind-add Vinyl --preset vinyl\`.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const name = requireArg(args, 0, "name");
+      const preset = flagString(flags, "preset");
+      if (preset)
+        parseInput(collectionKindPresetSchema, preset);
+      const body = parseInput(createCollectionKindInputSchema, {
+        id: ulid3(),
+        name,
+        ...preset ? { preset } : {},
+        ...readDataFlag(flags)
+      });
+      return {
+        data: await requireClient().post(pathOf(collectionOperations.createKind), body),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["collection", "kind-update"],
+      summary: "Change a kind: its name, one/many, icon, fields or status words (the key stays).",
+      args: [{ name: "id", required: true, description: "Kind ULID." }],
+      flags: [{ name: "data", type: "string", description: "UpdateCollectionKindInput JSON." }],
+      scopes: [...collectionOperations.updateKind.scopes],
+      returns: "CollectionKind",
+      notes: `${routeOf(collectionOperations.updateKind)}. \`fields\` replaces the list.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const kindId = requireArg(args, 0, "kind id");
+      const body = parseInput(updateCollectionKindInputSchema, readDataFlag(flags));
+      return {
+        data: await requireClient().patch(pathOf(collectionOperations.updateKind, { kindId }), body),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["collection", "kind-remove"],
+      summary: "Remove a kind that has no Items.",
+      args: [{ name: "id", required: true, description: "Kind ULID." }],
+      flags: [],
+      scopes: [...collectionOperations.removeKind.scopes],
+      returns: "void",
+      notes: `${routeOf(collectionOperations.removeKind)}. A 409 while it still has Items.`
+    },
+    run: async ({ args, requireClient }) => {
+      const kindId = requireArg(args, 0, "kind id");
+      await requireClient().delete(pathOf(collectionOperations.removeKind, { kindId }));
+      return { data: { ok: true, kindId }, render: renderRecord };
+    }
+  },
   {
     spec: {
       path: ["collection", "list"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robbeverhelst/do",
-  "version": "1.391.0",
+  "version": "1.393.0",
   "private": false,
   "description": "do — the agent-drivable CLI over the public /api/v1 surface",
   "homepage": "https://github.com/robbeverhelst/do/tree/main/apps/cli",