@jini-ai/cms 0.3.11 → 0.4.1

package/dist/taxonomy/write-service.js

@@ -1,3 +1,4 @@
+import { nowIso as kernelNowIso } from "@jini-ai/core/primitives";
 import { ForbiddenError } from "../core/commands/command.js";
 import { validateContentJoin, validateHierarchyAssignment, wouldCreateCycle } from "./validation-chain.js";
 /** The hardcoded post/page taxonomy allow-list (permanent, see
@@ -7,24 +8,28 @@ import { validateContentJoin, validateHierarchyAssignment, wouldCreateCycle } fr
  * an intentionally parallel (not layered) per-content-type policy carried by a host's own
  * `content_types` registry. */
 export const TAXONOMY_ALLOWED_CONTENT_TYPES = new Set(["post", "page"]);
-export function isContentTypeOnAllowList(contentType) {
+export function isContentTypeOnAllowList(requiredArgs, optionalArgs = {}) {
+    const { contentType } = requiredArgs;
     return TAXONOMY_ALLOWED_CONTENT_TYPES.has(contentType);
 }
 export class TaxonomyRecordNotFoundError extends Error {
-    constructor(message) {
+    constructor(requiredArgs, optionalArgs = {}) {
+        const { message } = requiredArgs;
         super(message);
         this.name = "TaxonomyRecordNotFoundError";
     }
 }
 export class TermRecordNotFoundError extends Error {
-    constructor(message) {
+    constructor(requiredArgs, optionalArgs = {}) {
+        const { message } = requiredArgs;
         super(message);
         this.name = "TermRecordNotFoundError";
     }
 }
 /** Finding 1 fix — the target of an `assignTerms` call does not resolve to any real content row. */
 export class ContentRecordNotFoundError extends Error {
-    constructor(message) {
+    constructor(requiredArgs, optionalArgs = {}) {
+        const { message } = requiredArgs;
         super(message);
         this.name = "ContentRecordNotFoundError";
     }
@@ -38,7 +43,8 @@ export class ContentRecordNotFoundError extends Error {
  * "catch the one it actually called into" rule.
  */
 export class TaxonomyVersionConflictError extends Error {
-    constructor(message) {
+    constructor(requiredArgs, optionalArgs = {}) {
+        const { message } = requiredArgs;
         super(message);
         this.name = "TaxonomyVersionConflictError";
     }
@@ -48,7 +54,11 @@ export class TaxonomyVersionConflictError extends Error {
 async function authorizeTaxonomyManage(deps, principalId) {
     const result = await deps.authorize({ principalId, permission: "admin.taxonomy.manage" });
     if (!result.allowed) {
-        throw new ForbiddenError(`principal '${principalId}' is not authorized for 'admin.taxonomy.manage' (${result.reason})`, "admin.taxonomy.manage", result.reason);
+        throw new ForbiddenError({
+            message: `principal '${principalId}' is not authorized for 'admin.taxonomy.manage' (${result.reason})`,
+            permission: "admin.taxonomy.manage",
+            reason: result.reason,
+        });
     }
 }
 /** Creates a taxonomy row (hierarchical=true -> "category"-shaped, false -> "tag"-shaped — same
@@ -56,7 +66,7 @@ async function authorizeTaxonomyManage(deps, principalId) {
 export async function createTaxonomy(required, _optional = {}) {
     const { deps, principalId, name, hierarchical } = required;
     await authorizeTaxonomyManage(deps, principalId);
-    const now = deps.clock.nowIso();
+    const now = kernelNowIso({ clock: deps.clock });
     const taxonomy = {
         id: deps.idGen.newId(),
         name,
@@ -73,25 +83,28 @@ export async function createTaxonomy(required, _optional = {}) {
         actorId: principalId,
         recordedAt: now,
     });
-    await deps.stampWatermark();
-    await deps.outbox.enqueue({ name: "taxonomy.created", taxonomyId: taxonomy.id, actorId: principalId, occurredAt: now });
+    await deps.stampWatermark({});
+    await deps.outbox.enqueue({ event: { name: "taxonomy.created", taxonomyId: taxonomy.id, actorId: principalId, occurredAt: now } });
     return taxonomy;
 }
-/** AC-03/AC-13/EC-04 — validates `parentId` via `validateHierarchyAssignment` before writing. A
+/** — validates `parentId` via `validateHierarchyAssignment` before writing. A
  * freshly-created term has no descendants yet, so it structurally cannot be a cycle source; the
- * cycle check is therefore always a no-op (`() => false`) here, unlike a reparent of an existing
- * term (not yet built — no certified test in this slice exercises it). */
-export async function createTerm(required, _optional = {}) {
-    const { deps, principalId, taxonomyId, name, parentId } = required;
+ * cycle check is therefore always a no-op (` => false`) here, unlike a reparent of an existing
+ * term (not yet built — no certified test in this slice exercises it).
+ * See docs/decisions/DR-005-ordered-taxonomy-validation.md.
+ */
+export async function createTerm(required, optional = {}) {
+    const { deps, principalId, taxonomyId, name } = required;
+    const { parentId } = optional;
     await authorizeTaxonomyManage(deps, principalId);
-    const taxonomy = await deps.taxonomies.findById(taxonomyId);
+    const taxonomy = await deps.taxonomies.findById({ id: taxonomyId });
     if (!taxonomy) {
-        throw new TaxonomyRecordNotFoundError(`taxonomy '${taxonomyId}' was not found`);
+        throw new TaxonomyRecordNotFoundError({ message: `taxonomy '${taxonomyId}' was not found` });
     }
     const candidateParentId = parentId ?? null;
     let resolvedParent = "not-applicable";
     if (candidateParentId !== null) {
-        const parentTerm = await deps.terms.findById(candidateParentId);
+        const parentTerm = await deps.terms.findById({ id: candidateParentId });
         resolvedParent = parentTerm ? { id: parentTerm.id, taxonomyId: parentTerm.taxonomyId } : null;
     }
     validateHierarchyAssignment({
@@ -102,7 +115,7 @@ export async function createTerm(required, _optional = {}) {
         wouldCreateCycle: () => false,
         termId: "__new__",
     });
-    const now = deps.clock.nowIso();
+    const now = kernelNowIso({ clock: deps.clock });
     const term = {
         id: deps.idGen.newId(),
         taxonomyId,
@@ -114,8 +127,8 @@ export async function createTerm(required, _optional = {}) {
     };
     await deps.terms.insert(term);
     await deps.revisions.insert({ taxonomyId, op: "create", previousState: null, actorId: principalId, recordedAt: now });
-    await deps.stampWatermark();
-    await deps.outbox.enqueue({ name: "taxonomy.term_created", termId: term.id, actorId: principalId, occurredAt: now });
+    await deps.stampWatermark({});
+    await deps.outbox.enqueue({ event: { name: "taxonomy.term_created", termId: term.id, actorId: principalId, occurredAt: now } });
     return term;
 }
 /**
@@ -131,21 +144,21 @@ export async function createTerm(required, _optional = {}) {
 export async function importTaxonomy(required, _optional = {}) {
     const { deps, principalId, id, name, hierarchical, expectedVersion } = required;
     await authorizeTaxonomyManage(deps, principalId);
-    const existing = await deps.taxonomies.findByIdFull(id);
+    const existing = await deps.taxonomies.findByIdFull({ id: id });
     if (expectedVersion === undefined) {
         if (existing) {
-            throw new TaxonomyVersionConflictError(`taxonomy '${id}' already exists, but no expectedVersion was supplied for import`);
+            throw new TaxonomyVersionConflictError({ message: `taxonomy '${id}' already exists, but no expectedVersion was supplied for import` });
         }
     }
     else {
         if (!existing) {
-            throw new TaxonomyVersionConflictError(`expected version ${expectedVersion} for taxonomy '${id}', but no such taxonomy exists`);
+            throw new TaxonomyVersionConflictError({ message: `expected version ${expectedVersion} for taxonomy '${id}', but no such taxonomy exists` });
         }
         if (existing.version !== expectedVersion) {
-            throw new TaxonomyVersionConflictError(`expected version ${expectedVersion} for taxonomy '${id}', found ${existing.version}`);
+            throw new TaxonomyVersionConflictError({ message: `expected version ${expectedVersion} for taxonomy '${id}', found ${existing.version}` });
         }
     }
-    const now = deps.clock.nowIso();
+    const now = kernelNowIso({ clock: deps.clock });
     const taxonomy = {
         id,
         name,
@@ -167,8 +180,8 @@ export async function importTaxonomy(required, _optional = {}) {
         actorId: principalId,
         recordedAt: now,
     });
-    await deps.stampWatermark();
-    await deps.outbox.enqueue({ name: "taxonomy.imported", taxonomyId: taxonomy.id, actorId: principalId, occurredAt: now });
+    await deps.stampWatermark({});
+    await deps.outbox.enqueue({ event: { name: "taxonomy.imported", taxonomyId: taxonomy.id, actorId: principalId, occurredAt: now } });
     return taxonomy;
 }
 /**
@@ -183,7 +196,7 @@ async function loadAncestorChain(terms, startId) {
     const chain = new Map();
     let current = startId;
     while (current !== null && !chain.has(current)) {
-        const parentId = (await terms.findByIdFull(current))?.parentId ?? null;
+        const parentId = (await terms.findByIdFull({ id: current }))?.parentId ?? null;
         chain.set(current, parentId);
         current = parentId;
     }
@@ -202,35 +215,36 @@ async function loadAncestorChain(terms, startId) {
  * @complexity O(d) — one taxonomy lookup, one id lookup, one optional parent lookup, `d` ancestor
  * lookups (the candidate parent's depth), one insert-or-update, one revision append.
  */
-export async function importTerm(required, _optional = {}) {
-    const { deps, principalId, id, taxonomyId, name, parentId, expectedVersion } = required;
+export async function importTerm(required, optional = {}) {
+    const { deps, principalId, id, taxonomyId, name, expectedVersion } = required;
+    const { parentId } = optional;
     await authorizeTaxonomyManage(deps, principalId);
-    const taxonomy = await deps.taxonomies.findById(taxonomyId);
+    const taxonomy = await deps.taxonomies.findById({ id: taxonomyId });
     if (!taxonomy) {
-        throw new TaxonomyRecordNotFoundError(`taxonomy '${taxonomyId}' was not found`);
+        throw new TaxonomyRecordNotFoundError({ message: `taxonomy '${taxonomyId}' was not found` });
     }
-    const existing = await deps.terms.findByIdFull(id);
+    const existing = await deps.terms.findByIdFull({ id: id });
     if (expectedVersion === undefined) {
         if (existing) {
-            throw new TaxonomyVersionConflictError(`term '${id}' already exists, but no expectedVersion was supplied for import`);
+            throw new TaxonomyVersionConflictError({ message: `term '${id}' already exists, but no expectedVersion was supplied for import` });
         }
     }
     else {
         if (!existing) {
-            throw new TaxonomyVersionConflictError(`expected version ${expectedVersion} for term '${id}', but no such term exists`);
+            throw new TaxonomyVersionConflictError({ message: `expected version ${expectedVersion} for term '${id}', but no such term exists` });
         }
         if (existing.version !== expectedVersion) {
-            throw new TaxonomyVersionConflictError(`expected version ${expectedVersion} for term '${id}', found ${existing.version}`);
+            throw new TaxonomyVersionConflictError({ message: `expected version ${expectedVersion} for term '${id}', found ${existing.version}` });
         }
         // A cross-taxonomy move would leave the term's children parented across taxonomies.
         if (existing.taxonomyId !== taxonomyId) {
-            throw new TaxonomyVersionConflictError(`term '${id}' belongs to taxonomy '${existing.taxonomyId}', not '${taxonomyId}'; an import cannot move a term between taxonomies`);
+            throw new TaxonomyVersionConflictError({ message: `term '${id}' belongs to taxonomy '${existing.taxonomyId}', not '${taxonomyId}'; an import cannot move a term between taxonomies` });
         }
     }
     const candidateParentId = parentId ?? null;
     let resolvedParent = "not-applicable";
     if (candidateParentId !== null) {
-        const parentTerm = await deps.terms.findById(candidateParentId);
+        const parentTerm = await deps.terms.findById({ id: candidateParentId });
         resolvedParent = parentTerm ? { id: parentTerm.id, taxonomyId: parentTerm.taxonomyId } : null;
     }
     const ancestors = candidateParentId === null ? new Map() : await loadAncestorChain(deps.terms, candidateParentId);
@@ -239,10 +253,10 @@ export async function importTerm(required, _optional = {}) {
         taxonomyIsHierarchical: taxonomy.hierarchical,
         candidateParentId,
         resolvedParent,
-        wouldCreateCycle: (parent) => wouldCreateCycle({ termId: id, candidateParentId: parent, tree: { getParentId: (termId) => ancestors.get(termId) ?? null } }),
+        wouldCreateCycle: ({ candidateParentId }) => wouldCreateCycle({ termId: id, candidateParentId, tree: { getParentId: ({ termId }) => ancestors.get(termId) ?? null } }),
         termId: existing ? id : "__new__",
     });
-    const now = deps.clock.nowIso();
+    const now = kernelNowIso({ clock: deps.clock });
     const term = {
         id,
         taxonomyId,
@@ -265,44 +279,53 @@ export async function importTerm(required, _optional = {}) {
         actorId: principalId,
         recordedAt: now,
     });
-    await deps.stampWatermark();
-    await deps.outbox.enqueue({ name: "taxonomy.term_imported", termId: term.id, actorId: principalId, occurredAt: now });
+    await deps.stampWatermark({});
+    await deps.outbox.enqueue({ event: { name: "taxonomy.term_imported", termId: term.id, actorId: principalId, occurredAt: now } });
     return term;
 }
-/** AC-15/AC-19/AC-25/REQ-12/REQ-17 — same-tx rename + revision (carrying the pre-rename state) +
- * watermark + outbox. `authorize()` runs before the term lookup, so a denied caller produces zero
- * side effects of any kind. */
+/** — same-tx rename + revision (carrying the pre-rename state) +
+ * watermark + outbox. `authorize` runs before the term lookup, so a denied caller produces zero
+ * side effects of any kind. A missing transaction capability fails closed before any lookup
+ * or write; a caller must supply a real shared transaction for durable atomicity.
+ * See docs/decisions/DR-005-ordered-taxonomy-validation.md.
+ */
 export async function renameTerm(required, _optional = {}) {
     const { deps, principalId, termId, newName } = required;
     await authorizeTaxonomyManage(deps, principalId);
-    const current = await deps.terms.findById(termId);
-    if (!current) {
-        throw new TermRecordNotFoundError(`term '${termId}' was not found`);
-    }
-    const now = deps.clock.nowIso();
-    const updated = {
-        id: current.id,
-        taxonomyId: current.taxonomyId,
-        parentId: current.parentId ?? null,
-        name: newName,
-        status: current.status ?? "active",
-        updatedAt: now,
-        version: (current.version ?? 1) + 1,
-    };
-    await deps.terms.update(updated);
-    await deps.revisions.insert({
-        taxonomyId: current.taxonomyId,
-        op: "rename",
-        previousState: { name: current.name },
-        actorId: principalId,
-        recordedAt: now,
-    });
-    await deps.stampWatermark();
-    await deps.outbox.enqueue({ name: "taxonomy.term_renamed", termId, actorId: principalId, occurredAt: now });
-    return updated;
+    // The narrow taxonomy repo stays independent; the host binds the shared transaction explicitly.
+    const transaction = deps.transaction;
+    if (!transaction)
+        throw new Error("term rename requires a transaction port");
+    return transaction({ fn: async () => {
+            const current = await deps.terms.findById({ id: termId });
+            if (!current) {
+                throw new TermRecordNotFoundError({ message: `term '${termId}' was not found` });
+            }
+            const now = kernelNowIso({ clock: deps.clock });
+            const updated = {
+                id: current.id,
+                taxonomyId: current.taxonomyId,
+                parentId: current.parentId ?? null,
+                name: newName,
+                status: current.status ?? "active",
+                updatedAt: now,
+                version: (current.version ?? 1) + 1,
+            };
+            await deps.terms.update(updated);
+            await deps.revisions.insert({
+                taxonomyId: current.taxonomyId,
+                op: "rename",
+                previousState: { name: current.name },
+                actorId: principalId,
+                recordedAt: now,
+            });
+            await deps.stampWatermark({});
+            await deps.outbox.enqueue({ event: { name: "taxonomy.term_renamed", termId, actorId: principalId, occurredAt: now } });
+            return updated;
+        } });
 }
-/** AC-17/AC-20/INV-05/REQ-13/REQ-14 — upserts every `entry_terms` row (idempotent on-conflict per
- * `entry_terms_unique`, EC-09), then stamps the watermark and enqueues the outbox event exactly
+/** — upserts every `entry_terms` row (idempotent on-conflict per
+ * `entry_terms_unique`), then stamps the watermark and enqueues the outbox event exactly
  * ONCE per call regardless of `termIds.length` — never once per term. Never produces a
  * `taxonomy_revisions` row (see this file's header for the disclosed narrowing this implements).
  *
@@ -313,6 +336,7 @@ export async function renameTerm(required, _optional = {}) {
  * Validation runs for ALL termIds before ANY write, so a failure partway through never leaves a
  * partial assignment. Content is resolved once per call (not once per term) since every term in
  * one call shares the same `(contentType, contentId)` target.
+ * See docs/decisions/DR-005-ordered-taxonomy-validation.md.
  */
 /**
  * A1 (taxonomy plan) — shared by `assignTerms` and `unassignTerms`: resolves whether
@@ -322,14 +346,15 @@ export async function renameTerm(required, _optional = {}) {
  * re-derived copy that could drift.
  *
  * `post`/`page` keep today's behavior exactly: `isPostOrPage` short-circuits before
- * `contentTypeTaxonomyPolicy` is ever consulted (AC-08). A non-post/page `contentType` is
+ * `contentTypeTaxonomyPolicy` is ever consulted. A non-post/page `contentType` is
  * resolvable only when a policy is wired AND that policy doesn't return `null` (not applicable) —
  * an unknown `contentType` (no policy, or a policy returning `null`) stays unresolvable, so it
  * still fails at `validateContentJoin`'s allow-list check (`TaxonomyNotApplicableError`), not a
  * `ContentRecordNotFoundError` — this is what keeps `"product"` a 400, not a 404.
+ * See docs/decisions/DR-005-ordered-taxonomy-validation.md.
  */
 async function validateAssignmentTarget(deps, contentType, contentId, termIds) {
-    const isPostOrPage = isContentTypeOnAllowList(contentType);
+    const isPostOrPage = isContentTypeOnAllowList({ contentType: contentType });
     const policy = isPostOrPage
         ? null
         : deps.contentTypeTaxonomyPolicy
@@ -338,12 +363,12 @@ async function validateAssignmentTarget(deps, contentType, contentId, termIds) {
     const isResolvable = isPostOrPage || policy !== null;
     const content = isResolvable ? await deps.contentLookup.resolve({ contentType, contentId }) : null;
     if (isResolvable && !content) {
-        throw new ContentRecordNotFoundError(`content '${contentType}:${contentId}' was not found`);
+        throw new ContentRecordNotFoundError({ message: `content '${contentType}:${contentId}' was not found` });
     }
     for (const termId of termIds) {
-        const term = await deps.terms.findById(termId);
+        const term = await deps.terms.findById({ id: termId });
         if (!term) {
-            throw new TermRecordNotFoundError(`term '${termId}' was not found`);
+            throw new TermRecordNotFoundError({ message: `term '${termId}' was not found` });
         }
         const isOnAllowList = isPostOrPage || policy === "all" || (policy instanceof Set && policy.has(term.taxonomyId));
         validateContentJoin({
@@ -364,28 +389,30 @@ export async function assignTerms(required, _optional = {}) {
     const { deps, principalId, contentType, contentId, termIds } = required;
     await authorizeTaxonomyManage(deps, principalId);
     await validateAssignmentTarget(deps, contentType, contentId, termIds);
-    const now = deps.clock.nowIso();
+    const now = kernelNowIso({ clock: deps.clock });
     for (const termId of termIds) {
         await deps.entryTerms.upsert({ contentType, contentId, termId, addedAt: now });
     }
-    await deps.stampWatermark();
-    await deps.outbox.enqueue({
-        name: "taxonomy.terms_assigned",
-        contentType,
-        contentId,
-        termIds,
-        actorId: principalId,
-        occurredAt: now,
-    });
+    await deps.stampWatermark({});
+    await deps.outbox.enqueue({ event: {
+            name: "taxonomy.terms_assigned",
+            contentType,
+            contentId,
+            termIds,
+            actorId: principalId,
+            occurredAt: now,
+        } });
 }
-/** SPEC-018 REQ-07/REQ-13/REQ-14/REQ-17/REQ-22 — spec debt this codebase never built (the spec
+/** — spec debt this codebase never built (the spec
  * always named "assign/unassign tools"; only `assignTerms` shipped). Same
  * authorize -> validateAssignmentTarget -> write -> stamp -> outbox chokepoint as `assignTerms`,
- * and — like `assignTerms` — never produces a `taxonomy_revisions` row (REQ-13/INV-05's disclosed
+ * and — like `assignTerms` — never produces a `taxonomy_revisions` row ( disclosed
  * narrowing applies equally to removal). Idempotent: unassigning a row that isn't there is a no-op,
- * not an error (`remove()`'s 0-vs-1 return is intentionally not surfaced to the caller). Chosen over
+ * not an error (`remove`'s 0-vs-1 return is intentionally not surfaced to the caller). Chosen over
  * a "set terms" replace call — see the taxonomy plan's "What the docs settle" #3 for why replace
- * risks silently erasing a concurrent assignment. */
+ * risks silently erasing a concurrent assignment.
+ * See docs/decisions/DR-005-ordered-taxonomy-validation.md.
+ */
 export async function unassignTerms(required, _optional = {}) {
     const { deps, principalId, contentType, contentId, termIds } = required;
     await authorizeTaxonomyManage(deps, principalId);
@@ -393,36 +420,49 @@ export async function unassignTerms(required, _optional = {}) {
     for (const termId of termIds) {
         await deps.entryTerms.remove({ contentType, contentId, termId });
     }
-    const now = deps.clock.nowIso();
-    await deps.stampWatermark();
-    await deps.outbox.enqueue({
-        name: "taxonomy.terms_unassigned",
-        contentType,
-        contentId,
-        termIds,
-        actorId: principalId,
-        occurredAt: now,
-    });
+    const now = kernelNowIso({ clock: deps.clock });
+    await deps.stampWatermark({});
+    await deps.outbox.enqueue({ event: {
+            name: "taxonomy.terms_unassigned",
+            contentType,
+            contentId,
+            termIds,
+            actorId: principalId,
+            occurredAt: now,
+        } });
 }
 /** Content-deletion event subscriber. Best-effort (a missed event leaves an orphaned
  * `entry_terms` row that is inert on read; a periodic/boot reconciliation sweep — modeled by
  * re-invoking this same function for the orphan — is the backstop, never a hard failure). A
  * no-op for content with no
- * assigned terms, never an error. */
-export async function onContentDeleted(required, _optional = {}) {
+ * assigned terms, never an error. Repository failures are warnings through the optional
+ * logger port; logger failure also cannot turn cleanup into a hard failure. Hosts should
+ * wire the logger for diagnostics; legacy callers without it remain silent. */
+export async function onContentDeleted(required, optional = {}) {
     const { event, entryTerms } = required;
-    await entryTerms.deleteByContent({
-        workspaceId: event.workspaceId,
-        contentType: event.contentType,
-        contentId: event.contentId,
-    });
+    try {
+        await entryTerms.deleteByContent({
+            workspaceId: event.workspaceId,
+            contentType: event.contentType,
+            contentId: event.contentId,
+        });
+    }
+    catch (error) {
+        try {
+            await optional.logger?.warn({ message: "content-deletion taxonomy cleanup failed", error, event });
+        }
+        catch {
+            // Cleanup is best effort even when its diagnostic sink is unavailable.
+        }
+    }
 }
 /** `deleteTerm`/`deleteTaxonomy` refuse rather than silently orphan when content is still
  * assigned. Carries `assignedCount` so a caller (route/UI) can render "N items are still
  * assigned" instead of a generic failure. */
 export class TermHasAssignedContentError extends Error {
     assignedCount;
-    constructor(message, assignedCount) {
+    constructor(requiredArgs, _optionalArgs = {}) {
+        const { message, assignedCount } = requiredArgs;
         super(message);
         this.assignedCount = assignedCount;
         this.name = "TermHasAssignedContentError";
@@ -432,7 +472,8 @@ export class TermHasAssignedContentError extends Error {
  * `childCount` for the same reason `TermHasAssignedContentError` carries `assignedCount`. */
 export class TermHasChildTermsError extends Error {
     childCount;
-    constructor(message, childCount) {
+    constructor(requiredArgs, _optionalArgs = {}) {
+        const { message, childCount } = requiredArgs;
         super(message);
         this.childCount = childCount;
         this.name = "TermHasChildTermsError";
@@ -442,7 +483,8 @@ export class TermHasChildTermsError extends Error {
  * term, not a single term's count. */
 export class TaxonomyHasAssignedContentError extends Error {
     assignedCount;
-    constructor(message, assignedCount) {
+    constructor(requiredArgs, _optionalArgs = {}) {
+        const { message, assignedCount } = requiredArgs;
         super(message);
         this.assignedCount = assignedCount;
         this.name = "TaxonomyHasAssignedContentError";
@@ -472,38 +514,38 @@ export class TaxonomyHasAssignedContentError extends Error {
 export async function deleteTerm(required, _optional = {}) {
     const { deps, principalId, termId } = required;
     await authorizeTaxonomyManage(deps, principalId);
-    return deps.transaction(async () => {
-        const current = await deps.terms.findById(termId);
-        if (!current) {
-            throw new TermRecordNotFoundError(`term '${termId}' was not found`);
-        }
-        const childCount = await deps.terms.countChildren({ parentId: termId });
-        if (childCount > 0) {
-            throw new TermHasChildTermsError(`term '${termId}' has ${childCount} child term(s) and cannot be deleted`, childCount);
-        }
-        const assignedCount = await deps.entryTerms.countByTerm({ termId });
-        if (assignedCount > 0) {
-            throw new TermHasAssignedContentError(`term '${termId}' is assigned to ${assignedCount} content item(s) and cannot be deleted`, assignedCount);
-        }
-        await deps.terms.delete(termId);
-        const now = deps.clock.nowIso();
-        await deps.revisions.insert({
-            taxonomyId: current.taxonomyId,
-            op: "delete",
-            previousState: { termId, name: current.name ?? null },
-            actorId: principalId,
-            recordedAt: now,
-        });
-        await deps.stampWatermark();
-        await deps.outbox.enqueue({
-            name: "taxonomy.term_deleted",
-            termId,
-            taxonomyId: current.taxonomyId,
-            actorId: principalId,
-            occurredAt: now,
-        });
-        return { deletedTermId: termId };
-    });
+    return deps.transaction({ fn: async () => {
+            const current = await deps.terms.findById({ id: termId });
+            if (!current) {
+                throw new TermRecordNotFoundError({ message: `term '${termId}' was not found` });
+            }
+            const childCount = await deps.terms.countChildren({ parentId: termId });
+            if (childCount > 0) {
+                throw new TermHasChildTermsError({ message: `term '${termId}' has ${childCount} child term(s) and cannot be deleted`, childCount: childCount });
+            }
+            const assignedCount = await deps.entryTerms.countByTerm({ termId });
+            if (assignedCount > 0) {
+                throw new TermHasAssignedContentError({ message: `term '${termId}' is assigned to ${assignedCount} content item(s) and cannot be deleted`, assignedCount: assignedCount });
+            }
+            await deps.terms.delete({ id: termId });
+            const now = kernelNowIso({ clock: deps.clock });
+            await deps.revisions.insert({
+                taxonomyId: current.taxonomyId,
+                op: "delete",
+                previousState: { termId, name: current.name ?? null },
+                actorId: principalId,
+                recordedAt: now,
+            });
+            await deps.stampWatermark({});
+            await deps.outbox.enqueue({ event: {
+                    name: "taxonomy.term_deleted",
+                    termId,
+                    taxonomyId: current.taxonomyId,
+                    actorId: principalId,
+                    occurredAt: now,
+                } });
+            return { deletedTermId: termId };
+        } });
 }
 /**
  * Deletes a taxonomy together with its member terms, refusing when ANY member term is still
@@ -527,41 +569,41 @@ export async function deleteTerm(required, _optional = {}) {
 export async function deleteTaxonomy(required, _optional = {}) {
     const { deps, principalId, taxonomyId } = required;
     await authorizeTaxonomyManage(deps, principalId);
-    return deps.transaction(async () => {
-        const taxonomy = await deps.taxonomies.findById(taxonomyId);
-        if (!taxonomy) {
-            throw new TaxonomyRecordNotFoundError(`taxonomy '${taxonomyId}' was not found`);
-        }
-        const memberTerms = await deps.terms.listByTaxonomy({ taxonomyId });
-        let totalAssigned = 0;
-        for (const term of memberTerms) {
-            totalAssigned += await deps.entryTerms.countByTerm({ termId: term.id });
-        }
-        if (totalAssigned > 0) {
-            throw new TaxonomyHasAssignedContentError(`taxonomy '${taxonomyId}' has ${totalAssigned} content assignment(s) across its terms and cannot be deleted`, totalAssigned);
-        }
-        for (const term of memberTerms) {
-            await deps.terms.delete(term.id);
-        }
-        await deps.taxonomies.delete(taxonomyId);
-        const now = deps.clock.nowIso();
-        const deletedTermIds = memberTerms.map((term) => term.id);
-        await deps.revisions.insert({
-            taxonomyId,
-            op: "delete",
-            previousState: { deletedTermIds },
-            actorId: principalId,
-            recordedAt: now,
-        });
-        await deps.stampWatermark();
-        await deps.outbox.enqueue({
-            name: "taxonomy.deleted",
-            taxonomyId,
-            deletedTermIds,
-            actorId: principalId,
-            occurredAt: now,
-        });
-        return { deletedTaxonomyId: taxonomyId, deletedTermIds };
-    });
+    return deps.transaction({ fn: async () => {
+            const taxonomy = await deps.taxonomies.findById({ id: taxonomyId });
+            if (!taxonomy) {
+                throw new TaxonomyRecordNotFoundError({ message: `taxonomy '${taxonomyId}' was not found` });
+            }
+            const memberTerms = await deps.terms.listByTaxonomy({ taxonomyId });
+            let totalAssigned = 0;
+            for (const term of memberTerms) {
+                totalAssigned += await deps.entryTerms.countByTerm({ termId: term.id });
+            }
+            if (totalAssigned > 0) {
+                throw new TaxonomyHasAssignedContentError({ message: `taxonomy '${taxonomyId}' has ${totalAssigned} content assignment(s) across its terms and cannot be deleted`, assignedCount: totalAssigned });
+            }
+            for (const term of memberTerms) {
+                await deps.terms.delete({ id: term.id });
+            }
+            await deps.taxonomies.delete({ id: taxonomyId });
+            const now = kernelNowIso({ clock: deps.clock });
+            const deletedTermIds = memberTerms.map((term) => term.id);
+            await deps.revisions.insert({
+                taxonomyId,
+                op: "delete",
+                previousState: { deletedTermIds },
+                actorId: principalId,
+                recordedAt: now,
+            });
+            await deps.stampWatermark({});
+            await deps.outbox.enqueue({ event: {
+                    name: "taxonomy.deleted",
+                    taxonomyId,
+                    deletedTermIds,
+                    actorId: principalId,
+                    occurredAt: now,
+                } });
+            return { deletedTaxonomyId: taxonomyId, deletedTermIds };
+        } });
 }
 //# sourceMappingURL=write-service.js.map