@jini-ai/cms 0.3.11 → 0.4.1

package/dist/content-types/lifecycle.js

@@ -1,111 +1,117 @@
+import { nowIso as kernelNowIso } from "@jini-ai/core/primitives";
 import { ContentTypeLifecycleError, ContentTypeNotFoundError, ForbiddenError, VersionConflictError } from "./errors.js";
 async function resolveActiveOrDeprecated(repo, workspaceId, key) {
     const current = await repo.findByKey({ workspaceId, key });
     if (!current) {
-        return { ok: false, error: new ContentTypeNotFoundError(`content type '${key}' was not found in workspace '${workspaceId}'`) };
+        return { ok: false, error: new ContentTypeNotFoundError({ message: `content type '${key}' was not found in workspace '${workspaceId}'` }) };
     }
     return { ok: true, value: current };
 }
 /**
- * AC-13/AC-19 — flips an active type to `deprecated` (blocks only NEW entry creation, REQ-10) and
- * enqueues `content_type.deprecated` in the same call. Rejected unconditionally (INV-06) if the
+ * — flips an active type to `deprecated` (blocks only NEW entry creation) and
+ * enqueues `content_type.deprecated` in the same call. Rejected unconditionally if the
  * type is already `tombstone` — deprecate can never be used to "step back" out of tombstone.
  *
  * @complexity O(1) plus one repo read, one same-tx write pair, and one outbox enqueue.
  * @overallScore 100
+ * See docs/decisions/DR-002-content-lifecycle-and-cleanup.md.
  */
 export async function deprecateContentType(required) {
     const { deps, input } = required;
-    const authResult = await deps.authorize({ principalId: input.actorId, permission: "admin.collections.manage", workspaceId: input.workspaceId, entityType: "content-type" });
+    const authResult = await deps.authorize({ principalId: input.actorId, permission: "admin.collections.manage", workspaceId: input.workspaceId }, { entityType: "content-type" });
     if (!authResult.allowed) {
-        return { ok: false, error: new ForbiddenError(`principal '${input.actorId}' cannot deprecate content type '${input.key}' (${authResult.reason})`) };
+        return { ok: false, error: new ForbiddenError({ message: `principal '${input.actorId}' cannot deprecate content type '${input.key}' (${authResult.reason})` }) };
     }
     const resolved = await resolveActiveOrDeprecated(deps.repo, input.workspaceId, input.key);
     if (!resolved.ok)
         return resolved;
     const current = resolved.value;
     if (current.status === "tombstone") {
-        return { ok: false, error: new ContentTypeLifecycleError(`content type '${input.key}' is tombstoned; INV-06 forbids any transition out of tombstone`) };
+        // See docs/decisions/DR-002-content-lifecycle-and-cleanup.md for the invariant behind this refusal; keep external identifiers out of caller-facing messages.
+        return { ok: false, error: new ContentTypeLifecycleError({ message: `content type '${input.key}' is tombstoned; no transition out of tombstone is allowed` }) };
     }
     if (input.expectedVersion !== current.version) {
-        return { ok: false, error: new VersionConflictError(`expected version ${input.expectedVersion} for content type '${input.key}', found ${current.version}`) };
+        return { ok: false, error: new VersionConflictError({ message: `expected version ${input.expectedVersion} for content type '${input.key}', found ${current.version}` }) };
     }
-    const now = deps.clock.nowIso();
+    const now = kernelNowIso({ clock: deps.clock });
     const updated = { ...current, status: "deprecated", version: current.version + 1 };
-    await deps.repo.transaction(async () => {
-        await deps.repo.save(updated);
-        await deps.repo.appendRevision({
-            contentTypeKey: input.key,
-            workspaceId: input.workspaceId,
-            op: "field-change",
-            stateJson: updated,
-            actorId: input.actorId,
-            principalKind: input.principalKind ?? null,
-            delegatedByWorkspaceId: null,
-            delegatedById: null,
-            recordedAt: now,
-        });
-    });
+    await deps.repo.transaction({ fn: async () => {
+            await deps.repo.save(updated);
+            await deps.repo.appendRevision({
+                contentTypeKey: input.key,
+                workspaceId: input.workspaceId,
+                op: "field-change",
+                stateJson: updated,
+                actorId: input.actorId,
+                principalKind: input.principalKind ?? null,
+                delegatedByWorkspaceId: null,
+                delegatedById: null,
+                recordedAt: now,
+            });
+        } });
     await deps.outbox.enqueue({ name: "content_type.deprecated", payload: { workspaceId: input.workspaceId, key: input.key } });
     return { ok: true, value: { contentType: updated } };
 }
 /**
- * AC-13 — flips a `deprecated` (or already-`active`, a no-op-shaped success) type back to
- * `active`. Rejected unconditionally (AC-14/INV-06) against a tombstoned row.
+ * — flips a `deprecated` (or already-`active`, a no-op-shaped success) type back to
+ * `active`. Rejected unconditionally against a tombstoned row.
  *
  * @complexity O(1) plus one repo read and one same-tx write pair.
  * @overallScore 100
+ * See docs/decisions/DR-002-content-lifecycle-and-cleanup.md.
  */
 export async function reactivateContentType(required) {
     const { deps, input } = required;
-    const authResult = await deps.authorize({ principalId: input.actorId, permission: "admin.collections.manage", workspaceId: input.workspaceId, entityType: "content-type" });
+    const authResult = await deps.authorize({ principalId: input.actorId, permission: "admin.collections.manage", workspaceId: input.workspaceId }, { entityType: "content-type" });
     if (!authResult.allowed) {
-        return { ok: false, error: new ForbiddenError(`principal '${input.actorId}' cannot reactivate content type '${input.key}' (${authResult.reason})`) };
+        return { ok: false, error: new ForbiddenError({ message: `principal '${input.actorId}' cannot reactivate content type '${input.key}' (${authResult.reason})` }) };
     }
     const resolved = await resolveActiveOrDeprecated(deps.repo, input.workspaceId, input.key);
     if (!resolved.ok)
         return resolved;
     const current = resolved.value;
     if (current.status === "tombstone") {
-        return { ok: false, error: new ContentTypeLifecycleError(`content type '${input.key}' is tombstoned; INV-06 forbids any transition out of tombstone`) };
+        // See docs/decisions/DR-002-content-lifecycle-and-cleanup.md for the invariant behind this refusal; keep external identifiers out of caller-facing messages.
+        return { ok: false, error: new ContentTypeLifecycleError({ message: `content type '${input.key}' is tombstoned; no transition out of tombstone is allowed` }) };
     }
     if (input.expectedVersion !== current.version) {
-        return { ok: false, error: new VersionConflictError(`expected version ${input.expectedVersion} for content type '${input.key}', found ${current.version}`) };
+        return { ok: false, error: new VersionConflictError({ message: `expected version ${input.expectedVersion} for content type '${input.key}', found ${current.version}` }) };
     }
-    const now = deps.clock.nowIso();
+    const now = kernelNowIso({ clock: deps.clock });
     const updated = { ...current, status: "active", version: current.version + 1 };
-    await deps.repo.transaction(async () => {
-        await deps.repo.save(updated);
-        await deps.repo.appendRevision({
-            contentTypeKey: input.key,
-            workspaceId: input.workspaceId,
-            op: "field-change",
-            stateJson: updated,
-            actorId: input.actorId,
-            principalKind: input.principalKind ?? null,
-            delegatedByWorkspaceId: null,
-            delegatedById: null,
-            recordedAt: now,
-        });
-    });
+    await deps.repo.transaction({ fn: async () => {
+            await deps.repo.save(updated);
+            await deps.repo.appendRevision({
+                contentTypeKey: input.key,
+                workspaceId: input.workspaceId,
+                op: "field-change",
+                stateJson: updated,
+                actorId: input.actorId,
+                principalKind: input.principalKind ?? null,
+                delegatedByWorkspaceId: null,
+                delegatedById: null,
+                recordedAt: now,
+            });
+        } });
     return { ok: true, value: { contentType: updated } };
 }
 /**
- * AC-17/AC-20/EC-09 — the one-way terminal transition into `tombstone`. Must be entered from
+ * — the one-way terminal transition into `tombstone`. Must be entered from
  * `deprecated` (any other status, including an already-tombstoned row, is rejected with the same
- * "must deprecate first" guard — EC-09/INV-06 collapse to one check). Tears down every queryable-
+ * "must deprecate first" guard — collapse to one check). Tears down every queryable-
  * field index the type ever provisioned BEFORE persisting the status flip, and enqueues
  * `content_type.tombstoned` in the same call.
  *
  * @complexity O(1) plus one repo read, one index-teardown call, one same-tx write pair, and one
  * outbox enqueue.
  * @overallScore 100
+ * See docs/decisions/DR-002-content-lifecycle-and-cleanup.md.
  */
 export async function tombstoneContentType(required) {
     const { deps, input } = required;
-    const authResult = await deps.authorize({ principalId: input.actorId, permission: "admin.collections.manage", workspaceId: input.workspaceId, entityType: "content-type" });
+    const authResult = await deps.authorize({ principalId: input.actorId, permission: "admin.collections.manage", workspaceId: input.workspaceId }, { entityType: "content-type" });
     if (!authResult.allowed) {
-        return { ok: false, error: new ForbiddenError(`principal '${input.actorId}' cannot tombstone content type '${input.key}' (${authResult.reason})`) };
+        return { ok: false, error: new ForbiddenError({ message: `principal '${input.actorId}' cannot tombstone content type '${input.key}' (${authResult.reason})` }) };
     }
     const resolved = await resolveActiveOrDeprecated(deps.repo, input.workspaceId, input.key);
     if (!resolved.ok)
@@ -114,29 +120,30 @@ export async function tombstoneContentType(required) {
     if (current.status !== "deprecated") {
         return {
             ok: false,
-            error: new ContentTypeLifecycleError(`content type '${input.key}' must be 'deprecated' before it can be tombstoned (EC-09); current status is '${current.status}'`),
+            // See docs/decisions/DR-002-content-lifecycle-and-cleanup.md for the invariant behind this refusal; keep external identifiers out of caller-facing messages.
+            error: new ContentTypeLifecycleError({ message: `content type '${input.key}' must be 'deprecated' before it can be tombstoned; current status is '${current.status}'` }),
         };
     }
     if (input.expectedVersion !== current.version) {
-        return { ok: false, error: new VersionConflictError(`expected version ${input.expectedVersion} for content type '${input.key}', found ${current.version}`) };
+        return { ok: false, error: new VersionConflictError({ message: `expected version ${input.expectedVersion} for content type '${input.key}', found ${current.version}` }) };
     }
-    const now = deps.clock.nowIso();
+    const now = kernelNowIso({ clock: deps.clock });
     const updated = { ...current, status: "tombstone", tombstonedAt: now, version: current.version + 1 };
     await deps.indexProvisioner.tearDownAllIndexesForContentType({ workspaceId: input.workspaceId, contentTypeKey: input.key });
-    await deps.repo.transaction(async () => {
-        await deps.repo.save(updated);
-        await deps.repo.appendRevision({
-            contentTypeKey: input.key,
-            workspaceId: input.workspaceId,
-            op: "field-change",
-            stateJson: updated,
-            actorId: input.actorId,
-            principalKind: input.principalKind ?? null,
-            delegatedByWorkspaceId: null,
-            delegatedById: null,
-            recordedAt: now,
-        });
-    });
+    await deps.repo.transaction({ fn: async () => {
+            await deps.repo.save(updated);
+            await deps.repo.appendRevision({
+                contentTypeKey: input.key,
+                workspaceId: input.workspaceId,
+                op: "field-change",
+                stateJson: updated,
+                actorId: input.actorId,
+                principalKind: input.principalKind ?? null,
+                delegatedByWorkspaceId: null,
+                delegatedById: null,
+                recordedAt: now,
+            });
+        } });
     await deps.outbox.enqueue({ name: "content_type.tombstoned", payload: { workspaceId: input.workspaceId, key: input.key } });
     return { ok: true, value: { contentType: updated } };
 }

package/dist/content-types/repo.memory.d.ts

@@ -1,3 +1,4 @@
+import type { Clock } from "@jini-ai/core/primitives";
 import type { ContentTypeRepoPort, ContentTypeRevisionInput, IndexProvisionerPort, OutboxPort } from "./write-service.js";
 import type { TeardownIndexProvisionerPort } from "./lifecycle.js";
 import type { ContentTypeListPort } from "./list.js";
@@ -32,7 +33,9 @@ export declare class InMemoryContentTypeRepo implements ContentTypeRepoPort, Con
         workspaceId: string;
         key: string;
     }): Promise<ContentTypeRecord | null>;
-    transaction<T>(fn: () => Promise<T>): Promise<T>;
+    transaction<T>({ fn }: {
+        fn: () => Promise<T>;
+    }): Promise<T>;
     listByWorkspace(params: {
         workspaceId: string;
     }): Promise<ContentTypeRecord[]>;
@@ -59,9 +62,7 @@ export declare function toContentTypeOutbox(deps: {
             payload: Record<string, unknown>;
         }): Promise<void>;
     };
-    clock: {
-        nowIso(): string;
-    };
+    clock: Clock;
     idGen: {
         newId(): string;
     };

package/dist/content-types/repo.memory.js

@@ -1,3 +1,4 @@
+import { nowIso as kernelNowIso } from "@jini-ai/core/primitives";
 /**
  * @file In-memory adapters for the `content-types` package's write/list ports (port/adapter rule-of-two
  * "one being built now" half). Backs `server/app.ts`'s hermetic test/dev composition AND, until a
@@ -36,7 +37,7 @@ export class InMemoryContentTypeRepo {
         const row = this.rows.get(InMemoryContentTypeRepo.key(params.workspaceId, params.key));
         return row ? { ...row } : null;
     }
-    async transaction(fn) {
+    async transaction({ fn }) {
         return fn();
     }
     async listByWorkspace(params) {
@@ -62,7 +63,7 @@ export function toContentTypeOutbox(deps) {
                 id: deps.idGen.newId(),
                 workspaceId: deps.workspaceId,
                 name: event.name,
-                occurredAt: deps.clock.nowIso(),
+                occurredAt: kernelNowIso({ clock: deps.clock }),
                 payload: event.payload,
             });
         },

package/dist/content-types/tool-registrations.d.ts

@@ -1,3 +1,5 @@
+import type { IdGenerator } from "@jini-ai/core/primitives";
+import type { Clock } from "@jini-ai/core/primitives";
 /**
  * @file Content-types' half of the agent-tool authorization wiring: maps `agent-tools.ts`'s catalog entries onto the
  * `write-service.ts`/`lifecycle.ts` functions the admin HTTP routes call, as `ToolRegistration`s.
@@ -32,7 +34,7 @@
  */
 import type { AuthorizeFn } from "../core/commands/command.js";
 import type { OutboxPort } from "../core/ports.js";
-import { type DerivedRiskByToolId, type ToolRegistration } from "../core/tools/registration-kit.js";
+import { type DerivedRiskByToolId, type ToolRegistration } from "@jini-ai/core";
 import { type ContentTypeListPort } from "./list.js";
 import { type TeardownIndexProvisionerPort } from "./lifecycle.js";
 import { type ContentTypeRepoPort, type IndexProvisionerPort } from "./write-service.js";
@@ -40,17 +42,13 @@ import { type ContentTypeRepoPort, type IndexProvisionerPort } from "./write-ser
  * The exact slice of the route-deps bag Content-Types' tool handlers read. Declared structurally
  * (rather than importing `server/routes/types`'s `RouteDeps`) so this module carries no back-edge
  * into the composition root. `server/routes/*` satisfies this structurally by passing its existing
- * `RouteDeps` object; nothing there changes.
+ * `RouteDeps` object with the kernel clock/ID contracts.
  */
 export interface ContentTypesToolDeps {
     authorize: AuthorizeFn;
     workspaceId: string;
-    clock: {
-        nowIso(): string;
-    };
-    idGen: {
-        newId(): string;
-    };
+    clock: Clock;
+    idGen: IdGenerator;
     outbox: OutboxPort;
     contentTypeRepo: ContentTypeRepoPort & ContentTypeListPort;
     contentTypeIndexProvisioner: IndexProvisionerPort & TeardownIndexProvisionerPort;

package/dist/content-types/tool-registrations.js

@@ -1,10 +1,11 @@
-import { AGENT_TOOL_PRINCIPAL_KIND, buildDomainRegistrations, decorateWithSchema, fromResult, indexCatalogById, requireInputRecord, requireNoInput, requireNumber, requireString, requireToolPermission, } from "../core/tools/registration-kit.js";
+import { AGENT_TOOL_PRINCIPAL_KIND, buildDomainRegistrations, decorateWithSchema, fromResult, indexCatalogById, requireInputRecord, requireNoInput, requireNumber, requireString } from "@jini-ai/core";
+import { adaptLegacyAuthorize, requireToolPermission } from "../core/tools/index.js";
 import { contentTypesAgentToolCatalog } from "./agent-tools.js";
 import { parseContentTypeFieldDefs } from "./field-defs.js";
 import { listContentTypes } from "./list.js";
 import { deprecateContentType, reactivateContentType, tombstoneContentType } from "./lifecycle.js";
 import { registerContentType, updateContentTypeFields } from "./write-service.js";
-const CATALOG_BY_ID = indexCatalogById(contentTypesAgentToolCatalog);
+const CATALOG_BY_ID = indexCatalogById({ catalog: contentTypesAgentToolCatalog });
 /** Descriptors for the 2 cleanup tools this pass does not wire — see file header. */
 const UNWIRED_CONTENT_TYPES_TOOL_IDS = new Set(["collections_plan_cleanup", "collections_execute_cleanup"]);
 /**
@@ -39,7 +40,7 @@ export const contentTypesDerivedRisk = new Map([
  * @overallScore 100
  */
 function requireFields(input, toolId) {
-    const parsed = parseContentTypeFieldDefs(input.fields);
+    const parsed = parseContentTypeFieldDefs({ value: input.fields });
     if (parsed.ok)
         return parsed.value;
     throw decorateWithSchema({ toolId, catalog: CATALOG_BY_ID, message: parsed.error.message });
@@ -76,14 +77,14 @@ function toContentTypeView(record) {
     return view;
 }
 function fromContentTypeResult(fn) {
-    return fromResult(fn).then(({ contentType }) => ({ contentType: toContentTypeView(contentType) }));
+    return fromResult({ fn: fn }).then(({ contentType }) => ({ contentType: toContentTypeView(contentType) }));
 }
 function contentTypesDeps(routeDeps) {
     return {
         repo: routeDeps.contentTypeRepo,
         clock: routeDeps.clock,
         ids: routeDeps.idGen,
-        authorize: routeDeps.authorize,
+        authorize: adaptLegacyAuthorize({ authorize: routeDeps.authorize }),
         outbox: routeDeps.outbox,
         indexProvisioner: routeDeps.contentTypeIndexProvisioner,
     };
@@ -91,79 +92,75 @@ function contentTypesDeps(routeDeps) {
 export function buildContentTypesRegistrations(routeDeps) {
     const handlers = {
         collections_content_type_list: async (ctx) => {
-            requireNoInput(ctx.input);
-            await requireToolPermission(routeDeps, {
-                principalId: ctx.principal.id,
-                permission: "admin.collections.read",
-                entityType: "content-type",
-            });
+            requireNoInput({ input: ctx.input });
+            await requireToolPermission({ authorize: adaptLegacyAuthorize({ authorize: routeDeps.authorize }), workspaceId: routeDeps.workspaceId, principalId: ctx.principal.id, permission: "admin.collections.read" }, { entityType: "content-type" });
             const { items } = await listContentTypes({ repo: routeDeps.contentTypeRepo, workspaceId: routeDeps.workspaceId });
             return { contentTypes: items.map(toContentTypeView) };
         },
         collections_content_type_define: async (ctx) => {
-            const input = requireInputRecord(ctx.input);
+            const input = requireInputRecord({ input: ctx.input });
             return fromContentTypeResult(() => registerContentType({
                 deps: contentTypesDeps(routeDeps),
                 input: {
                     actorId: ctx.principal.id,
                     principalKind: AGENT_TOOL_PRINCIPAL_KIND,
                     workspaceId: routeDeps.workspaceId,
-                    key: requireString(input, "key"),
-                    label: requireString(input, "label"),
+                    key: requireString({ input, key: "key" }),
+                    label: requireString({ input, key: "label" }),
                     fields: requireFields(input, "collections_content_type_define"),
                 },
             }));
         },
         collections_content_type_update_fields: async (ctx) => {
-            const input = requireInputRecord(ctx.input);
+            const input = requireInputRecord({ input: ctx.input });
             return fromContentTypeResult(() => updateContentTypeFields({
                 deps: contentTypesDeps(routeDeps),
                 input: {
                     actorId: ctx.principal.id,
                     principalKind: AGENT_TOOL_PRINCIPAL_KIND,
                     workspaceId: routeDeps.workspaceId,
-                    key: requireString(input, "key"),
+                    key: requireString({ input, key: "key" }),
                     fields: requireFields(input, "collections_content_type_update_fields"),
-                    expectedVersion: requireNumber(input, "expectedVersion"),
+                    expectedVersion: requireNumber({ input, key: "expectedVersion" }),
                 },
             }));
         },
         collections_content_type_deprecate: async (ctx) => {
-            const input = requireInputRecord(ctx.input);
+            const input = requireInputRecord({ input: ctx.input });
             return fromContentTypeResult(() => deprecateContentType({
                 deps: contentTypesDeps(routeDeps),
                 input: {
                     actorId: ctx.principal.id,
                     principalKind: AGENT_TOOL_PRINCIPAL_KIND,
                     workspaceId: routeDeps.workspaceId,
-                    key: requireString(input, "key"),
-                    expectedVersion: requireNumber(input, "expectedVersion"),
+                    key: requireString({ input, key: "key" }),
+                    expectedVersion: requireNumber({ input, key: "expectedVersion" }),
                 },
             }));
         },
         collections_content_type_reactivate: async (ctx) => {
-            const input = requireInputRecord(ctx.input);
+            const input = requireInputRecord({ input: ctx.input });
             return fromContentTypeResult(() => reactivateContentType({
                 deps: contentTypesDeps(routeDeps),
                 input: {
                     actorId: ctx.principal.id,
                     principalKind: AGENT_TOOL_PRINCIPAL_KIND,
                     workspaceId: routeDeps.workspaceId,
-                    key: requireString(input, "key"),
-                    expectedVersion: requireNumber(input, "expectedVersion"),
+                    key: requireString({ input, key: "key" }),
+                    expectedVersion: requireNumber({ input, key: "expectedVersion" }),
                 },
             }));
         },
         collections_content_type_tombstone: async (ctx) => {
-            const input = requireInputRecord(ctx.input);
+            const input = requireInputRecord({ input: ctx.input });
             return fromContentTypeResult(() => tombstoneContentType({
                 deps: contentTypesDeps(routeDeps),
                 input: {
                     actorId: ctx.principal.id,
                     principalKind: AGENT_TOOL_PRINCIPAL_KIND,
                     workspaceId: routeDeps.workspaceId,
-                    key: requireString(input, "key"),
-                    expectedVersion: requireNumber(input, "expectedVersion"),
+                    key: requireString({ input, key: "key" }),
+                    expectedVersion: requireNumber({ input, key: "expectedVersion" }),
                 },
             }));
         },
@@ -174,7 +171,6 @@ export function buildContentTypesRegistrations(routeDeps) {
         catalog: CATALOG_BY_ID,
         handlers,
         derivedRisk: contentTypesDerivedRisk,
-        unwiredToolIds: UNWIRED_CONTENT_TYPES_TOOL_IDS,
-    });
+    }, { unwiredToolIds: UNWIRED_CONTENT_TYPES_TOOL_IDS });
 }
 //# sourceMappingURL=tool-registrations.js.map

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

@@ -24,15 +24,16 @@
  * `features/content-types` domain vocabulary. No dependencies.
  */
 /**
- * CIC U-001-B1 — the closed, 5-entry INDEXABLE SCALAR set. Never extend ad hoc.
+ * — the closed, 5-entry INDEXABLE SCALAR set. Never extend ad hoc.
  *
  * Unchanged since the original enum: every value that has ever reached a `CAST` literal is still
  * here, in this order. Kept as its own constant so the "these five are the original, untouched
  * scalars" claim is expressible in code rather than only in a comment.
+ * See docs/decisions/DR-001-safe-schema-and-index-transitions.md.
  */
 export declare const CONTENT_TYPE_SCALAR_KINDS: readonly ["text", "integer", "real", "boolean", "datetime"];
 /**
- * CIC U-001-B1 — kinds that MAY carry `queryable: true` and therefore MAY reach
+ * — kinds that MAY carry `queryable: true` and therefore MAY reach
  * `mapFieldKindToCast`. Every member MUST have an entry in `index-provisioning.ts`'s
  * `KIND_TO_CAST_LITERAL`; the compiler enforces this via `Record<IndexableFieldKind, string>`, so
  * adding a member here fails the build until a CAST literal is supplied for it.
@@ -40,6 +41,7 @@ export declare const CONTENT_TYPE_SCALAR_KINDS: readonly ["text", "integer", "re
  * `relation` stores a foreign entity id and shares `text`'s storage class, so its CAST target is
  * the already-present literal `"TEXT"` — it adds a KEY to that table, never a new VALUE to the
  * DDL alphabet.
+ * See docs/decisions/DR-001-safe-schema-and-index-transitions.md.
  */
 export declare const INDEXABLE_FIELD_KINDS: readonly ["text", "integer", "real", "boolean", "datetime", "relation"];
 export type IndexableFieldKind = (typeof INDEXABLE_FIELD_KINDS)[number];
@@ -52,7 +54,7 @@ export type IndexableFieldKind = (typeof INDEXABLE_FIELD_KINDS)[number];
 export declare const STORAGE_ONLY_FIELD_KINDS: readonly ["json"];
 export type StorageOnlyFieldKind = (typeof STORAGE_ONLY_FIELD_KINDS)[number];
 /**
- * CIC U-001-B1 — the closed field-kind enum. UNCHANGED NAME AND MEANING for every existing
+ * — the closed field-kind enum. UNCHANGED NAME AND MEANING for every existing
  * consumer: it is still the complete, closed set of legal `kind` values, and
  * {@link isContentTypeFieldKind} is still the gate for it.
  *
@@ -61,6 +63,7 @@ export type StorageOnlyFieldKind = (typeof STORAGE_ONLY_FIELD_KINDS)[number];
  * message. The spread order below preserves that; the published agent-tool schema
  * (`agent-tools.ts`) also spreads this constant, so both widen in lockstep with no hand-copied
  * second list to drift.
+ * See docs/decisions/DR-001-safe-schema-and-index-transitions.md.
  */
 export declare const CONTENT_TYPE_FIELD_KINDS: readonly ["text", "integer", "real", "boolean", "datetime", "relation", "json"];
 export type ContentTypeFieldKind = (typeof CONTENT_TYPE_FIELD_KINDS)[number];
@@ -75,7 +78,11 @@ export type ContentTypeFieldKind = (typeof CONTENT_TYPE_FIELD_KINDS)[number];
  * @complexity O(1) — a fixed-size array membership test.
  * @overallScore 100
  */
-export declare function isContentTypeFieldKind(value: unknown): value is ContentTypeFieldKind;
+export declare function isContentTypeFieldKind(required: {
+    value: unknown;
+}, _optional?: Record<string, never>): required is {
+    value: ContentTypeFieldKind;
+};
 /**
  * Type guard for {@link IndexableFieldKind} — the gate `mapFieldKindToCast` applies instead of
  * {@link isContentTypeFieldKind}, and the gate `write-service.ts` applies to reject
@@ -88,7 +95,11 @@ export declare function isContentTypeFieldKind(value: unknown): value is Content
  * @complexity O(1) — a fixed-size array membership test.
  * @overallScore 100
  */
-export declare function isIndexableFieldKind(value: unknown): value is IndexableFieldKind;
+export declare function isIndexableFieldKind(required: {
+    value: unknown;
+}, _optional?: Record<string, never>): required is {
+    value: IndexableFieldKind;
+};
 export interface ContentTypeFieldDef {
     name: string;
     kind: ContentTypeFieldKind;
@@ -113,7 +124,7 @@ export interface ContentTypeRecord {
  * applies to `AuthorizeFn`). `identity.PrincipalRecord.kind` assigns to it directly.
  */
 export type ActorPrincipalKind = "user" | "agent" | "api_key" | "system";
-/** The actor-identity envelope every chokepoint write in this package accepts (REQ-01/02/16). */
+/** The actor-identity envelope every chokepoint write in this package accepts. See docs/decisions/DR-001-safe-schema-and-index-transitions.md. */
 export interface ActorIdentityInput {
     actorId: string;
     /**
@@ -129,11 +140,4 @@ export interface ActorIdentityInput {
     delegatedById?: string | null;
 }
 /** Generic success/failure envelope used across this package instead of throwing for expected rejections. */
-export type Result<T, E> = {
-    ok: true;
-    value: T;
-} | {
-    ok: false;
-    error: E;
-};
 //# sourceMappingURL=types.d.ts.map

package/dist/content-types/types.js

@@ -24,15 +24,16 @@
  * `features/content-types` domain vocabulary. No dependencies.
  */
 /**
- * CIC U-001-B1 — the closed, 5-entry INDEXABLE SCALAR set. Never extend ad hoc.
+ * — the closed, 5-entry INDEXABLE SCALAR set. Never extend ad hoc.
  *
  * Unchanged since the original enum: every value that has ever reached a `CAST` literal is still
  * here, in this order. Kept as its own constant so the "these five are the original, untouched
  * scalars" claim is expressible in code rather than only in a comment.
+ * See docs/decisions/DR-001-safe-schema-and-index-transitions.md.
  */
 export const CONTENT_TYPE_SCALAR_KINDS = ["text", "integer", "real", "boolean", "datetime"];
 /**
- * CIC U-001-B1 — kinds that MAY carry `queryable: true` and therefore MAY reach
+ * — kinds that MAY carry `queryable: true` and therefore MAY reach
  * `mapFieldKindToCast`. Every member MUST have an entry in `index-provisioning.ts`'s
  * `KIND_TO_CAST_LITERAL`; the compiler enforces this via `Record<IndexableFieldKind, string>`, so
  * adding a member here fails the build until a CAST literal is supplied for it.
@@ -40,6 +41,7 @@ export const CONTENT_TYPE_SCALAR_KINDS = ["text", "integer", "real", "boolean",
  * `relation` stores a foreign entity id and shares `text`'s storage class, so its CAST target is
  * the already-present literal `"TEXT"` — it adds a KEY to that table, never a new VALUE to the
  * DDL alphabet.
+ * See docs/decisions/DR-001-safe-schema-and-index-transitions.md.
  */
 export const INDEXABLE_FIELD_KINDS = [...CONTENT_TYPE_SCALAR_KINDS, "relation"];
 /**
@@ -50,7 +52,7 @@ export const INDEXABLE_FIELD_KINDS = [...CONTENT_TYPE_SCALAR_KINDS, "relation"];
  */
 export const STORAGE_ONLY_FIELD_KINDS = ["json"];
 /**
- * CIC U-001-B1 — the closed field-kind enum. UNCHANGED NAME AND MEANING for every existing
+ * — the closed field-kind enum. UNCHANGED NAME AND MEANING for every existing
  * consumer: it is still the complete, closed set of legal `kind` values, and
  * {@link isContentTypeFieldKind} is still the gate for it.
  *
@@ -59,6 +61,7 @@ export const STORAGE_ONLY_FIELD_KINDS = ["json"];
  * message. The spread order below preserves that; the published agent-tool schema
  * (`agent-tools.ts`) also spreads this constant, so both widen in lockstep with no hand-copied
  * second list to drift.
+ * See docs/decisions/DR-001-safe-schema-and-index-transitions.md.
  */
 export const CONTENT_TYPE_FIELD_KINDS = [
     ...INDEXABLE_FIELD_KINDS,
@@ -75,7 +78,8 @@ export const CONTENT_TYPE_FIELD_KINDS = [
  * @complexity O(1) — a fixed-size array membership test.
  * @overallScore 100
  */
-export function isContentTypeFieldKind(value) {
+export function isContentTypeFieldKind(required, _optional = {}) {
+    const { value } = required;
     return typeof value === "string" && CONTENT_TYPE_FIELD_KINDS.includes(value);
 }
 /**
@@ -90,7 +94,9 @@ export function isContentTypeFieldKind(value) {
  * @complexity O(1) — a fixed-size array membership test.
  * @overallScore 100
  */
-export function isIndexableFieldKind(value) {
+export function isIndexableFieldKind(required, _optional = {}) {
+    const { value } = required;
     return typeof value === "string" && INDEXABLE_FIELD_KINDS.includes(value);
 }
+/** Generic success/failure envelope used across this package instead of throwing for expected rejections. */
 //# sourceMappingURL=types.js.map