@jini-ai/cms 0.3.9 → 0.3.11

package/dist/content-types/write-service.d.ts

@@ -140,6 +140,15 @@ export interface UpdateContentTypeFieldsRequired {
         key: string;
         fields: ContentTypeFieldDef[];
         expectedVersion: number;
+        /**
+         * J1 (plan-publish-all-types-2026-09-25.md §0.2) — optional and additive. Before this, no
+         * write path could ever change `label` after `registerContentType`, so a publish that carried
+         * an imported `label` change hashed it (the planned publish factory's `transferred` field) but
+         * had nothing to call that would apply it — a permanent false "still changed" on every
+         * subsequent plan. Omitted, the current label is kept unchanged, exactly as before this field
+         * existed.
+         */
+        label?: string | undefined;
     };
 }
 /**

package/dist/content-types/write-service.js

@@ -201,7 +201,7 @@ export async function updateContentTypeFields(required) {
     const before = current.fields;
     const after = input.fields;
     const now = deps.clock.nowIso();
-    const updated = { ...current, fields: after, version: current.version + 1 };
+    const updated = { ...current, fields: after, label: input.label ?? current.label, version: current.version + 1 };
     await deps.repo.transaction(async () => {
         await deps.repo.save(updated);
         await deps.repo.appendRevision({

package/dist/entries/index.d.ts

@@ -28,8 +28,8 @@ export { validateFieldsAgainstSchema, selectVisibleEntryFields } from "./field-v
 export { ForbiddenError, EntryNotFoundError, ContentTypeNotFoundError, ContentTypeNotActiveError, EntrySlugConflictError, VersionConflictError, EntryFieldValidationError, } from "./errors.js";
 export type { EntryLifecycleOp, EntryLifecycleHandler } from "./lifecycle-dispatch.js";
 export { ENTRY_LIFECYCLE_OP_NAMES, ENTRY_LIFECYCLE_OPS, parseEntryLifecycleOp, } from "./lifecycle-dispatch.js";
-export type { AuthorizeFn, EntryRevisionInput, EntryRepoPort, ContentTypeLookupPort, OutboxPort, WatermarkPort, CreateEntryRequired, UpdateEntryRequired, PublishUnpublishEntryRequired, } from "./write-service.js";
-export { createEntry, updateEntry, publishEntry, unpublishEntry } from "./write-service.js";
+export type { AuthorizeFn, EntryRevisionInput, EntryRepoPort, ContentTypeLookupPort, OutboxPort, WatermarkPort, CreateEntryRequired, UpdateEntryRequired, PublishUnpublishEntryRequired, ImportEntryRequired, } from "./write-service.js";
+export { createEntry, updateEntry, publishEntry, unpublishEntry, importEntry } from "./write-service.js";
 /**
  * The in-memory repository. Exported for the same reason `navigation` exports its own: a host's
  * concrete adapter implements the port directly, and the in-memory implementation is the reference

package/dist/entries/index.js

@@ -12,7 +12,7 @@ export { validateFieldsAgainstSchema, selectVisibleEntryFields } from "./field-v
  */
 export { ForbiddenError, EntryNotFoundError, ContentTypeNotFoundError, ContentTypeNotActiveError, EntrySlugConflictError, VersionConflictError, EntryFieldValidationError, } from "./errors.js";
 export { ENTRY_LIFECYCLE_OP_NAMES, ENTRY_LIFECYCLE_OPS, parseEntryLifecycleOp, } from "./lifecycle-dispatch.js";
-export { createEntry, updateEntry, publishEntry, unpublishEntry } from "./write-service.js";
+export { createEntry, updateEntry, publishEntry, unpublishEntry, importEntry } from "./write-service.js";
 /**
  * The in-memory repository. Exported for the same reason `navigation` exports its own: a host's
  * concrete adapter implements the port directly, and the in-memory implementation is the reference

package/dist/entries/write-service.d.ts

@@ -1,5 +1,5 @@
 import type { ClockPort } from "../core/ports.js";
-import type { ActorIdentityInput, EntryRecord, OwningContentType, Result } from "./types.js";
+import type { ActorIdentityInput, EntryRecord, EntryStatus, OwningContentType, Result } from "./types.js";
 /**
  * @file The `entries` write chokepoint: `createEntry`,
  * `updateEntry`, `publishEntry`, `unpublishEntry`.
@@ -184,6 +184,63 @@ export interface UpdateEntryRequired {
 export declare function updateEntry(required: UpdateEntryRequired): Promise<Result<{
     entry: EntryRecord;
 }, Error>>;
+export interface ImportEntryRequired {
+    deps: {
+        entryRepo: EntryRepoPort;
+        contentTypeRepo: ContentTypeLookupPort;
+        clock: ClockPort;
+        authorize: AuthorizeFn;
+        outbox: OutboxPort;
+        watermark?: WatermarkPort;
+        onWritten?: (entry: EntryRecord) => Promise<void>;
+    };
+    input: ActorIdentityInput & {
+        workspaceId: string;
+        /** The source's own id, preserved verbatim — unlike `createEntry`, which always mints a fresh
+         * one. Anything referencing this entry by id (widgets, term assignments) needs it to survive
+         * a publish round trip unchanged (plan-publish-all-types-2026-09-25.md §0.3 "Identity"). */
+        id: string;
+        type: string;
+        slug: string;
+        title: string;
+        /** Caller-given, unlike `createEntry`'s forced `"draft"` — an import carries the source's real
+         * status across. */
+        status: EntryStatus;
+        fieldsJson: unknown;
+        bodyJson?: unknown;
+        /** Caller-given, unlike `createEntry`'s forced `null`. */
+        publishedAt: string | null;
+        /**
+         * The publish factory's three-way CAS contract: `undefined` means "no row with this id may
+         * already exist" (an import-as-create); a number means "a row with this id must exist and be
+         * at exactly this version" (an import-as-update). Both cases end in `VersionConflictError` on
+         * mismatch, never a silent create-over-existing or a silent no-op.
+         */
+        expectedVersion: number | undefined;
+        /** The `ext` sub-key `fieldsJson` is namespaced under. Defaults to `"site"` — see `field-validation.ts`'s `validateFieldsAgainstSchema`. */
+        owner?: string | undefined;
+    };
+}
+/**
+ * Slice J1 (plan-publish-all-types-2026-09-25.md) — the publish-content import chokepoint for
+ * `entries`. Combines `createEntry`'s owning-type/field-validation guards with `updateEntry`'s
+ * version-CAS discipline, but preserves the caller's own `id`/`status`/`publishedAt` instead of
+ * minting a fresh id and forcing `draft`/`null` — the two behaviors a straight `createEntry` call
+ * cannot produce, and the reason this is a new function rather than a wider `createEntry`.
+ *
+ * A tombstoned owning type refuses the import (mirrors `resolveExistingEntryForTransition`'s
+ * REQ-28 rule); unlike `createEntry`'s REQ-10, a `deprecated` owning type does NOT block an
+ * import — REQ-10 exists to stop new manual authoring against a type an operator is winding down,
+ * not to stop a publish run from keeping an already-existing entry's already-existing type in
+ * sync. Slug uniqueness is deliberately not checked here: the publish factory's own `address`
+ * precheck (config.address, F1) owns that refusal before `importEntry` is ever called.
+ *
+ * @complexity O(1) plus one content-type read, one field-validation pass, one id lookup, and one
+ * same-tx write pair.
+ */
+export declare function importEntry(required: ImportEntryRequired): Promise<Result<{
+    entry: EntryRecord;
+}, Error>>;
 export interface PublishUnpublishEntryRequired {
     deps: ExistingEntryTransitionDeps;
     input: ActorIdentityInput & {

package/dist/entries/write-service.js

@@ -150,6 +150,93 @@ export async function updateEntry(required) {
     await deps.outbox.enqueue({ name: "entry.updated", payload: { workspaceId: input.workspaceId, entryId: current.id } });
     return { ok: true, value: { entry: updated } };
 }
+/**
+ * Slice J1 (plan-publish-all-types-2026-09-25.md) — the publish-content import chokepoint for
+ * `entries`. Combines `createEntry`'s owning-type/field-validation guards with `updateEntry`'s
+ * version-CAS discipline, but preserves the caller's own `id`/`status`/`publishedAt` instead of
+ * minting a fresh id and forcing `draft`/`null` — the two behaviors a straight `createEntry` call
+ * cannot produce, and the reason this is a new function rather than a wider `createEntry`.
+ *
+ * A tombstoned owning type refuses the import (mirrors `resolveExistingEntryForTransition`'s
+ * REQ-28 rule); unlike `createEntry`'s REQ-10, a `deprecated` owning type does NOT block an
+ * import — REQ-10 exists to stop new manual authoring against a type an operator is winding down,
+ * not to stop a publish run from keeping an already-existing entry's already-existing type in
+ * sync. Slug uniqueness is deliberately not checked here: the publish factory's own `address`
+ * precheck (config.address, F1) owns that refusal before `importEntry` is ever called.
+ *
+ * @complexity O(1) plus one content-type read, one field-validation pass, one id lookup, and one
+ * same-tx write pair.
+ */
+export async function importEntry(required) {
+    const { deps, input } = required;
+    const authResult = await deps.authorize({ principalId: input.actorId, permission: "admin.collections.manage", workspaceId: input.workspaceId, entityType: "entry" });
+    if (!authResult.allowed) {
+        return { ok: false, error: new ForbiddenError(`principal '${input.actorId}' cannot import entry '${input.id}' (${authResult.reason})`) };
+    }
+    const contentType = await deps.contentTypeRepo.findByKey({ workspaceId: input.workspaceId, key: input.type });
+    if (!contentType || contentType.workspaceId !== input.workspaceId) {
+        return { ok: false, error: new ContentTypeNotFoundError(`content type '${input.type}' was not found in workspace '${input.workspaceId}'`) };
+    }
+    if (contentType.status === "tombstone") {
+        return { ok: false, error: new ContentTypeNotActiveError(`content type '${input.type}' is tombstoned; entries cannot be imported into it`) };
+    }
+    const validation = validateFieldsAgainstSchema({ schema: contentType.fields, fieldsJson: input.fieldsJson, owner: input.owner });
+    if (!validation.valid) {
+        return { ok: false, error: new EntryFieldValidationError(validation.fieldErrors) };
+    }
+    const existing = await deps.entryRepo.findById({ workspaceId: input.workspaceId, id: input.id });
+    if (input.expectedVersion === undefined) {
+        if (existing) {
+            return { ok: false, error: new VersionConflictError(`entry '${input.id}' already exists in workspace '${input.workspaceId}', but no expectedVersion was supplied for import`) };
+        }
+    }
+    else {
+        if (!existing) {
+            return { ok: false, error: new VersionConflictError(`expected version ${input.expectedVersion} for entry '${input.id}', but no such entry exists`) };
+        }
+        if (existing.version !== input.expectedVersion) {
+            return { ok: false, error: new VersionConflictError(`expected version ${input.expectedVersion} for entry '${input.id}', found ${existing.version}`) };
+        }
+        // Same id, different type means this is not the row the caller's plan was made against; a
+        // silent type move would also dodge the REQ-28 tombstone check on the entry's REAL type.
+        if (existing.type !== input.type) {
+            return { ok: false, error: new VersionConflictError(`entry '${input.id}' is of type '${existing.type}', not '${input.type}'; an import cannot change an entry's type`) };
+        }
+    }
+    const now = deps.clock.nowIso();
+    const entry = {
+        id: input.id,
+        workspaceId: input.workspaceId,
+        type: input.type,
+        slug: input.slug,
+        status: input.status,
+        title: input.title,
+        bodyJson: input.bodyJson ?? null,
+        fieldsJson: input.fieldsJson,
+        publishedAt: input.publishedAt,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+        version: existing ? existing.version + 1 : 1,
+    };
+    await deps.entryRepo.transaction(async () => {
+        await deps.entryRepo.save(entry);
+        await deps.entryRepo.appendRevision({
+            entryId: entry.id,
+            workspaceId: input.workspaceId,
+            op: existing ? "update" : "create",
+            stateJson: entry,
+            actorId: input.actorId,
+            ...delegationFields(input),
+            recordedAt: now,
+        });
+        if (deps.watermark)
+            await deps.watermark.stampWatermark({ workspaceId: input.workspaceId });
+        if (deps.onWritten)
+            await deps.onWritten(entry);
+    });
+    await deps.outbox.enqueue({ name: "entry.imported", payload: { workspaceId: input.workspaceId, entryId: entry.id, type: input.type, slug: input.slug } });
+    return { ok: true, value: { entry } };
+}
 async function transitionEntryStatus(required, target) {
     const { deps, input } = required;
     const resolved = await resolveExistingEntryForTransition(deps, input);

package/dist/taxonomy/index.d.ts

@@ -19,7 +19,7 @@
  * has no imports at all: the ceremony is a parameter, not a dependency.
  */
 export { TaxonomyNotApplicableError, WorkspaceMismatchError, ContentTypeMismatchError, TaxonomyNotHierarchicalError, ParentCrossTaxonomyError, TermNotFoundError, HierarchyCycleDetectedError, wouldCreateCycle, validateContentJoin, validateHierarchyAssignment, type TermTreeLookup, } from "./validation-chain.js";
-export { TAXONOMY_ALLOWED_CONTENT_TYPES, isContentTypeOnAllowList, TaxonomyRecordNotFoundError, TermRecordNotFoundError, ContentRecordNotFoundError, TermHasAssignedContentError, TermHasChildTermsError, TaxonomyHasAssignedContentError, createTaxonomy, createTerm, renameTerm, assignTerms, unassignTerms, deleteTerm, deleteTaxonomy, onContentDeleted, type AuthorizeFn, type Taxonomy, type Term, type TaxonomyRepoPort, type TermRepoPort, type EntryTermRepoPort, type ContentLookupPort, type ContentTypeTaxonomyPolicyPort, type UnassignableEntryTermRepoPort, type TaxonomyRevisionRow, type TaxonomyRevisionRepoPort, type ClockPort, type IdGeneratorPort, type WriteServiceDeps, type CreateTaxonomyRequired, type CreateTermRequired, type RenameTermRequired, type AssignTermsRequired, type UnassignTermsRequired, type DeleteTermRequired, type DeleteTaxonomyRequired, type DeletableTaxonomyRepoPort, type DeletableTermRepoPort, type AssignmentCountEntryTermRepoPort, type TransactionalRepoPort, type EntryTermsCleanupPort, type OnContentDeletedRequired, } from "./write-service.js";
+export { TAXONOMY_ALLOWED_CONTENT_TYPES, isContentTypeOnAllowList, TaxonomyRecordNotFoundError, TermRecordNotFoundError, ContentRecordNotFoundError, TermHasAssignedContentError, TermHasChildTermsError, TaxonomyHasAssignedContentError, TaxonomyVersionConflictError, createTaxonomy, createTerm, renameTerm, assignTerms, unassignTerms, deleteTerm, deleteTaxonomy, onContentDeleted, importTaxonomy, importTerm, type AuthorizeFn, type Taxonomy, type Term, type TaxonomyRepoPort, type TermRepoPort, type EntryTermRepoPort, type ContentLookupPort, type ContentTypeTaxonomyPolicyPort, type UnassignableEntryTermRepoPort, type TaxonomyRevisionRow, type TaxonomyRevisionRepoPort, type ClockPort, type IdGeneratorPort, type WriteServiceDeps, type CreateTaxonomyRequired, type CreateTermRequired, type RenameTermRequired, type AssignTermsRequired, type UnassignTermsRequired, type DeleteTermRequired, type DeleteTaxonomyRequired, type DeletableTaxonomyRepoPort, type DeletableTermRepoPort, type AssignmentCountEntryTermRepoPort, type TransactionalRepoPort, type EntryTermsCleanupPort, type OnContentDeletedRequired, type ImportableTaxonomyRepoPort, type ImportableTermRepoPort, type ImportTaxonomyRequired, type ImportTermRequired, } from "./write-service.js";
 export { listTaxonomiesWithTerms, type TaxonomyListPort, type TermListPort, type TaxonomyWithTerms, } from "./list.js";
 /**
  * The domain half of the `mergeTerm` ceremony — see this file's header for why the gateway itself

package/dist/taxonomy/index.js

@@ -19,7 +19,7 @@
  * has no imports at all: the ceremony is a parameter, not a dependency.
  */
 export { TaxonomyNotApplicableError, WorkspaceMismatchError, ContentTypeMismatchError, TaxonomyNotHierarchicalError, ParentCrossTaxonomyError, TermNotFoundError, HierarchyCycleDetectedError, wouldCreateCycle, validateContentJoin, validateHierarchyAssignment, } from "./validation-chain.js";
-export { TAXONOMY_ALLOWED_CONTENT_TYPES, isContentTypeOnAllowList, TaxonomyRecordNotFoundError, TermRecordNotFoundError, ContentRecordNotFoundError, TermHasAssignedContentError, TermHasChildTermsError, TaxonomyHasAssignedContentError, createTaxonomy, createTerm, renameTerm, assignTerms, unassignTerms, deleteTerm, deleteTaxonomy, onContentDeleted, } from "./write-service.js";
+export { TAXONOMY_ALLOWED_CONTENT_TYPES, isContentTypeOnAllowList, TaxonomyRecordNotFoundError, TermRecordNotFoundError, ContentRecordNotFoundError, TermHasAssignedContentError, TermHasChildTermsError, TaxonomyHasAssignedContentError, TaxonomyVersionConflictError, createTaxonomy, createTerm, renameTerm, assignTerms, unassignTerms, deleteTerm, deleteTaxonomy, onContentDeleted, importTaxonomy, importTerm, } from "./write-service.js";
 export { listTaxonomiesWithTerms, } from "./list.js";
 /**
  * The domain half of the `mergeTerm` ceremony — see this file's header for why the gateway itself

package/dist/taxonomy/repo.memory.d.ts

@@ -13,6 +13,11 @@ export declare class InMemoryTaxonomyRepo implements TaxonomyRepoPort, TaxonomyL
         hierarchical: boolean;
         allowList?: string[] | undefined;
     } | null>;
+    /** `ImportableTaxonomyRepoPort` — additive capability for `importTaxonomy`'s CAS check and
+     * update-in-place, see `write-service.ts`'s doc comment on that interface. */
+    findByIdFull(id: string): Promise<Taxonomy | null>;
+    /** `ImportableTaxonomyRepoPort` — writes an existing row back in place, preserving its id. */
+    update(row: Taxonomy): Promise<unknown>;
     list(): Promise<Taxonomy[]>;
     /** `DeletableTaxonomyRepoPort` — additive capability for `deleteTaxonomy`, see
      * `write-service.ts`'s doc comment on that interface. */
@@ -44,6 +49,9 @@ export declare class InMemoryTermRepo implements TermRepoPort, TermListPort {
         taxonomyId: string;
         name?: string | undefined;
     } | null>;
+    /** `ImportableTermRepoPort` — additive capability for `importTerm`'s CAS check, see
+     * `write-service.ts`'s doc comment on that interface. */
+    findByIdFull(id: string): Promise<Term | null>;
     listByTaxonomy(params: {
         taxonomyId: string;
     }): Promise<Term[]>;

package/dist/taxonomy/repo.memory.js

@@ -12,6 +12,17 @@ export class InMemoryTaxonomyRepo {
         const row = this.rows.get(id);
         return row ? { id: row.id, hierarchical: row.hierarchical } : null;
     }
+    /** `ImportableTaxonomyRepoPort` — additive capability for `importTaxonomy`'s CAS check and
+     * update-in-place, see `write-service.ts`'s doc comment on that interface. */
+    async findByIdFull(id) {
+        const row = this.rows.get(id);
+        return row ? { ...row } : null;
+    }
+    /** `ImportableTaxonomyRepoPort` — writes an existing row back in place, preserving its id. */
+    async update(row) {
+        this.rows.set(row.id, { ...row });
+        return row;
+    }
     async list() {
         return [...this.rows.values()].map((row) => ({ ...row }));
     }
@@ -54,6 +65,12 @@ export class InMemoryTermRepo {
         const row = this.rows.get(id);
         return row ? { id: row.id, taxonomyId: row.taxonomyId, name: row.name } : null;
     }
+    /** `ImportableTermRepoPort` — additive capability for `importTerm`'s CAS check, see
+     * `write-service.ts`'s doc comment on that interface. */
+    async findByIdFull(id) {
+        const row = this.rows.get(id);
+        return row ? { ...row } : null;
+    }
     async listByTaxonomy(params) {
         return [...this.rows.values()].filter((row) => row.taxonomyId === params.taxonomyId).map((row) => ({ ...row }));
     }

package/dist/taxonomy/write-service.d.ts

@@ -124,7 +124,7 @@ export interface TaxonomyRevisionRow {
      * `"deprecate"` (that ceremony's own header explains why widening this union was out of its
      * scope), a delete has no honest fit among the other four ops, so this widens the union rather
      * than overloading an existing member. */
-    op: "create" | "rename" | "reparent" | "deprecate" | "delete";
+    op: "create" | "rename" | "reparent" | "deprecate" | "delete" | "import";
     previousState: Record<string, unknown> | null;
     actorId: string;
     recordedAt: string;
@@ -146,8 +146,10 @@ export interface WriteServiceDeps {
     terms: TermRepoPort;
     entryTerms: EntryTermRepoPort;
     revisions: TaxonomyRevisionRepoPort;
-    /** `core/gated-mutations.stampWatermark`-shaped, injected — same-transaction stamp per mutation. */
-    stampWatermark: (tx?: unknown) => void;
+    /** `core/gated-mutations.stampWatermark`-shaped, injected — same-transaction stamp per mutation.
+     * May be sync (SQLite) or async (PGlite/Postgres); every call site awaits it, so an async stamp
+     * finishes, and its failure fails the write, before the mutation returns. */
+    stampWatermark: (tx?: unknown) => Promise<void> | void;
     outbox: {
         enqueue: (event: unknown) => Promise<void>;
     };
@@ -171,6 +173,17 @@ export declare class TermRecordNotFoundError extends Error {
 export declare class ContentRecordNotFoundError extends Error {
     constructor(message: string);
 }
+/**
+ * J1 (plan-publish-all-types-2026-09-25.md) — `importTaxonomy`/`importTerm`'s optimistic-concurrency
+ * rejection. Neither `Taxonomy` nor `Term` had a version-checked write before this slice
+ * (`createTaxonomy`/`createTerm` always insert a fresh row; `renameTerm` doesn't check a caller-
+ * supplied version either), so this is a new class rather than a reused one — `content-types`' and
+ * `entries`' own `VersionConflictError`s are each that package's own, per this file's header's
+ * "catch the one it actually called into" rule.
+ */
+export declare class TaxonomyVersionConflictError extends Error {
+    constructor(message: string);
+}
 export interface CreateTaxonomyRequired {
     deps: WriteServiceDeps;
     principalId: string;
@@ -192,6 +205,79 @@ export interface CreateTermRequired {
  * 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 declare function createTerm(required: CreateTermRequired, _optional?: Record<string, never>): Promise<Term>;
+/**
+ * Additive capability beyond the certified `TaxonomyRepoPort` — `findById`'s narrow return
+ * (`{id, hierarchical, allowList?}`) doesn't carry `version`/`name`/`status`/`updatedAt`, which
+ * `importTaxonomy`'s CAS check and update-in-place both need, and `insert`-only leaves no way to
+ * write an existing row back. Same beyond-the-certified-port precedent as `DeletableTaxonomyRepoPort`.
+ */
+export interface ImportableTaxonomyRepoPort {
+    findByIdFull(id: string): Promise<Taxonomy | null>;
+    update(row: Taxonomy): Promise<unknown>;
+}
+export interface ImportTaxonomyRequired {
+    deps: WriteServiceDeps & {
+        taxonomies: TaxonomyRepoPort & ImportableTaxonomyRepoPort;
+    };
+    principalId: string;
+    /** The source's own id, preserved verbatim — unlike `createTaxonomy`, which always mints a fresh
+     * one. Anything referencing this taxonomy by id (its member terms) needs it to survive a publish
+     * round trip unchanged. */
+    id: string;
+    name: string;
+    hierarchical: boolean;
+    /** Same three-way CAS contract as `importEntry`'s `expectedVersion`: `undefined` means "this id
+     * must not already exist" (import-as-create); a number means "a row at exactly this version must
+     * exist" (import-as-update). Either mismatch is a `TaxonomyVersionConflictError`, never a silent
+     * overwrite or a silent no-op. */
+    expectedVersion: number | undefined;
+}
+/**
+ * Slice J1 — the publish-content import chokepoint for `taxonomies`. Address (name) uniqueness is
+ * deliberately not checked here: the publish factory's own `address` precheck (F1's
+ * `config.address`) owns that refusal before this is ever called, mirroring `importEntry`'s
+ * identical split from slug-uniqueness.
+ *
+ * @complexity O(1) — one id lookup, one insert-or-update, one revision append, all outside a
+ * transaction (this package has no SQLite adapter to open one against yet — see `repo.memory.ts`'s
+ * header).
+ */
+export declare function importTaxonomy(required: ImportTaxonomyRequired, _optional?: Record<string, never>): Promise<Taxonomy>;
+/**
+ * Additive capability beyond the certified `TermRepoPort` — `findById`'s narrow return
+ * (`{id, taxonomyId, name?}`) doesn't carry `version`, which `importTerm`'s CAS check needs.
+ * `TermRepoPort` already has `update`, unlike taxonomies, so no additive `update` is needed here.
+ */
+export interface ImportableTermRepoPort {
+    findByIdFull(id: string): Promise<Term | null>;
+}
+export interface ImportTermRequired {
+    deps: WriteServiceDeps & {
+        terms: TermRepoPort & ImportableTermRepoPort;
+    };
+    principalId: string;
+    /** The source's own id, preserved verbatim — unlike `createTerm`, which always mints a fresh one. */
+    id: string;
+    taxonomyId: string;
+    name: string;
+    parentId?: string | null | undefined;
+    /** Same three-way CAS contract as `importTaxonomy.expectedVersion`. */
+    expectedVersion: number | undefined;
+}
+/**
+ * Slice J1 — the publish-content import chokepoint for `terms`. Address (name within
+ * `(taxonomyId, parentId)`) uniqueness is the publish factory's own precheck, not this function's
+ * job — same split as `importTaxonomy`/`importEntry`.
+ *
+ * Unlike `createTerm`, an import can MOVE an existing term (an import-as-update with a new
+ * `parentId`), so the destination's real ancestor chain is loaded first (`loadAncestorChain`) and
+ * handed to the certified `wouldCreateCycle` walk — a publish must never write a parent loop into
+ * live taxonomy, where every tree walk over it would spin forever.
+ *
+ * @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 declare function importTerm(required: ImportTermRequired, _optional?: Record<string, never>): Promise<Term>;
 export interface RenameTermRequired {
     deps: WriteServiceDeps;
     principalId: string;

package/dist/taxonomy/write-service.js

@@ -1,5 +1,5 @@
 import { ForbiddenError } from "../core/commands/command.js";
-import { validateContentJoin, validateHierarchyAssignment } from "./validation-chain.js";
+import { validateContentJoin, validateHierarchyAssignment, wouldCreateCycle } from "./validation-chain.js";
 /** The hardcoded post/page taxonomy allow-list (permanent, see
  * `docs/decisions/taxonomy-content-type-allow-list.md`) — every taxonomy is applicable to
  * `post`/`page` content. This set is never grown to admit a Collection's content-type key; a
@@ -29,6 +29,20 @@ export class ContentRecordNotFoundError extends Error {
         this.name = "ContentRecordNotFoundError";
     }
 }
+/**
+ * J1 (plan-publish-all-types-2026-09-25.md) — `importTaxonomy`/`importTerm`'s optimistic-concurrency
+ * rejection. Neither `Taxonomy` nor `Term` had a version-checked write before this slice
+ * (`createTaxonomy`/`createTerm` always insert a fresh row; `renameTerm` doesn't check a caller-
+ * supplied version either), so this is a new class rather than a reused one — `content-types`' and
+ * `entries`' own `VersionConflictError`s are each that package's own, per this file's header's
+ * "catch the one it actually called into" rule.
+ */
+export class TaxonomyVersionConflictError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TaxonomyVersionConflictError";
+    }
+}
 /** `admin.taxonomy.manage` (the flat-string permission convention) — must run before any other
  * side effect of every write-service export in this file. */
 async function authorizeTaxonomyManage(deps, principalId) {
@@ -59,7 +73,7 @@ export async function createTaxonomy(required, _optional = {}) {
         actorId: principalId,
         recordedAt: now,
     });
-    deps.stampWatermark();
+    await deps.stampWatermark();
     await deps.outbox.enqueue({ name: "taxonomy.created", taxonomyId: taxonomy.id, actorId: principalId, occurredAt: now });
     return taxonomy;
 }
@@ -100,10 +114,161 @@ export async function createTerm(required, _optional = {}) {
     };
     await deps.terms.insert(term);
     await deps.revisions.insert({ taxonomyId, op: "create", previousState: null, actorId: principalId, recordedAt: now });
-    deps.stampWatermark();
+    await deps.stampWatermark();
     await deps.outbox.enqueue({ name: "taxonomy.term_created", termId: term.id, actorId: principalId, occurredAt: now });
     return term;
 }
+/**
+ * Slice J1 — the publish-content import chokepoint for `taxonomies`. Address (name) uniqueness is
+ * deliberately not checked here: the publish factory's own `address` precheck (F1's
+ * `config.address`) owns that refusal before this is ever called, mirroring `importEntry`'s
+ * identical split from slug-uniqueness.
+ *
+ * @complexity O(1) — one id lookup, one insert-or-update, one revision append, all outside a
+ * transaction (this package has no SQLite adapter to open one against yet — see `repo.memory.ts`'s
+ * header).
+ */
+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);
+    if (expectedVersion === undefined) {
+        if (existing) {
+            throw new TaxonomyVersionConflictError(`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`);
+        }
+        if (existing.version !== expectedVersion) {
+            throw new TaxonomyVersionConflictError(`expected version ${expectedVersion} for taxonomy '${id}', found ${existing.version}`);
+        }
+    }
+    const now = deps.clock.nowIso();
+    const taxonomy = {
+        id,
+        name,
+        hierarchical,
+        status: "active",
+        updatedAt: now,
+        version: existing ? existing.version + 1 : 1,
+    };
+    if (existing) {
+        await deps.taxonomies.update(taxonomy);
+    }
+    else {
+        await deps.taxonomies.insert(taxonomy);
+    }
+    await deps.revisions.insert({
+        taxonomyId: taxonomy.id,
+        op: "import",
+        previousState: existing ? { name: existing.name, hierarchical: existing.hierarchical } : null,
+        actorId: principalId,
+        recordedAt: now,
+    });
+    await deps.stampWatermark();
+    await deps.outbox.enqueue({ name: "taxonomy.imported", taxonomyId: taxonomy.id, actorId: principalId, occurredAt: now });
+    return taxonomy;
+}
+/**
+ * Loads `startId`'s ancestor chain (`termId -> parentId`, `startId` included) so the synchronous,
+ * certified `wouldCreateCycle` walk can run over the destination's REAL tree. Stops at a root, a
+ * missing row, or an already-seen id — the last bounds the loop against pre-existing malformed
+ * parent data, mirroring `wouldCreateCycle`'s own `visited` guard.
+ *
+ * @complexity O(d) repo reads for a chain of depth `d`.
+ */
+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;
+        chain.set(current, parentId);
+        current = parentId;
+    }
+    return chain;
+}
+/**
+ * Slice J1 — the publish-content import chokepoint for `terms`. Address (name within
+ * `(taxonomyId, parentId)`) uniqueness is the publish factory's own precheck, not this function's
+ * job — same split as `importTaxonomy`/`importEntry`.
+ *
+ * Unlike `createTerm`, an import can MOVE an existing term (an import-as-update with a new
+ * `parentId`), so the destination's real ancestor chain is loaded first (`loadAncestorChain`) and
+ * handed to the certified `wouldCreateCycle` walk — a publish must never write a parent loop into
+ * live taxonomy, where every tree walk over it would spin forever.
+ *
+ * @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;
+    await authorizeTaxonomyManage(deps, principalId);
+    const taxonomy = await deps.taxonomies.findById(taxonomyId);
+    if (!taxonomy) {
+        throw new TaxonomyRecordNotFoundError(`taxonomy '${taxonomyId}' was not found`);
+    }
+    const existing = await deps.terms.findByIdFull(id);
+    if (expectedVersion === undefined) {
+        if (existing) {
+            throw new TaxonomyVersionConflictError(`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`);
+        }
+        if (existing.version !== expectedVersion) {
+            throw new TaxonomyVersionConflictError(`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`);
+        }
+    }
+    const candidateParentId = parentId ?? null;
+    let resolvedParent = "not-applicable";
+    if (candidateParentId !== null) {
+        const parentTerm = await deps.terms.findById(candidateParentId);
+        resolvedParent = parentTerm ? { id: parentTerm.id, taxonomyId: parentTerm.taxonomyId } : null;
+    }
+    const ancestors = candidateParentId === null ? new Map() : await loadAncestorChain(deps.terms, candidateParentId);
+    validateHierarchyAssignment({
+        childTaxonomyId: taxonomyId,
+        taxonomyIsHierarchical: taxonomy.hierarchical,
+        candidateParentId,
+        resolvedParent,
+        wouldCreateCycle: (parent) => wouldCreateCycle({ termId: id, candidateParentId: parent, tree: { getParentId: (termId) => ancestors.get(termId) ?? null } }),
+        termId: existing ? id : "__new__",
+    });
+    const now = deps.clock.nowIso();
+    const term = {
+        id,
+        taxonomyId,
+        parentId: candidateParentId,
+        name,
+        status: "active",
+        updatedAt: now,
+        version: existing ? existing.version + 1 : 1,
+    };
+    if (existing) {
+        await deps.terms.update(term);
+    }
+    else {
+        await deps.terms.insert(term);
+    }
+    await deps.revisions.insert({
+        taxonomyId,
+        op: "import",
+        previousState: existing ? { name: existing.name, parentId: existing.parentId } : null,
+        actorId: principalId,
+        recordedAt: now,
+    });
+    await deps.stampWatermark();
+    await deps.outbox.enqueue({ 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. */
@@ -132,7 +297,7 @@ export async function renameTerm(required, _optional = {}) {
         actorId: principalId,
         recordedAt: now,
     });
-    deps.stampWatermark();
+    await deps.stampWatermark();
     await deps.outbox.enqueue({ name: "taxonomy.term_renamed", termId, actorId: principalId, occurredAt: now });
     return updated;
 }
@@ -203,7 +368,7 @@ export async function assignTerms(required, _optional = {}) {
     for (const termId of termIds) {
         await deps.entryTerms.upsert({ contentType, contentId, termId, addedAt: now });
     }
-    deps.stampWatermark();
+    await deps.stampWatermark();
     await deps.outbox.enqueue({
         name: "taxonomy.terms_assigned",
         contentType,
@@ -229,7 +394,7 @@ export async function unassignTerms(required, _optional = {}) {
         await deps.entryTerms.remove({ contentType, contentId, termId });
     }
     const now = deps.clock.nowIso();
-    deps.stampWatermark();
+    await deps.stampWatermark();
     await deps.outbox.enqueue({
         name: "taxonomy.terms_unassigned",
         contentType,
@@ -329,7 +494,7 @@ export async function deleteTerm(required, _optional = {}) {
             actorId: principalId,
             recordedAt: now,
         });
-        deps.stampWatermark();
+        await deps.stampWatermark();
         await deps.outbox.enqueue({
             name: "taxonomy.term_deleted",
             termId,
@@ -388,7 +553,7 @@ export async function deleteTaxonomy(required, _optional = {}) {
             actorId: principalId,
             recordedAt: now,
         });
-        deps.stampWatermark();
+        await deps.stampWatermark();
         await deps.outbox.enqueue({
             name: "taxonomy.deleted",
             taxonomyId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/cms",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "Content-model capability for Jini-hosted products: framework-free contracts, ports, and domain services in `/core` and per-domain subpaths; Node-bound persistence adapters in `/server`.",
   "license": "Apache-2.0",
   "repository": {