@jini-ai/cms 0.5.2 → 0.5.3

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

@@ -0,0 +1,121 @@
+/**
+ * @file ADR-031 §3/§8 — the moderation write-service: wraps `CommentRepoPort.applyModeration`/
+ * `purge` with outbox event emission and the `comments.statusChanged` action hook. Routes call
+ * `authorize()` first (ADR-021 flat `comments.*` strings), then this service, never the repo
+ * directly — the same "typed, core-owned write, no side-door" discipline ADR-023 §7 requires of
+ * the repo itself, one layer up.
+ */
+import type { Clock as ClockPort, IdGenerator as IdGeneratorPort, UUID } from "@jini-ai/core/primitives";
+import type { OutboxPort } from "../core/index.js";
+import type { CommentHookRegistry } from "./hooks.js";
+import type { CommentRepoPort } from "./ports.js";
+import type { CommentStatus, ModerationAction } from "./types.js";
+/**
+ * Hands one comment's removal to whoever owns removal in this composition.
+ *
+ * Structurally typed ON PURPOSE — this file imports nothing from `features/trash`, exactly as
+ * `post.ts`'s `RemovePostFn` does not. The composition root binds the real implementation (which
+ * records the item for the Trash screen) and hands it in already bound to this domain's entity
+ * type, so the moderation service never learns that a Trash exists.
+ *
+ * `display` is REQUIRED because the caller already holds the record: `applyModeration` returns the
+ * updated row, so the two strings the Trash screen shows come from columns, with no second read and
+ * no payload parse.
+ */
+export type RemoveCommentFn = (required: {
+    workspaceId: string;
+    id: string;
+    display: {
+        title: string;
+        subtitle?: string | null;
+    };
+    at: string;
+    expectedVersion: number | null;
+    actor: {
+        principalId: string;
+        pluginId?: string | null;
+    };
+}) => Promise<{
+    ok: true;
+    version: number | null;
+} | {
+    ok: false;
+    reason: "not-found" | "version-changed";
+}>;
+/**
+ * Drops any removal record for a comment that has come back out of `trash` by a route other than a
+ * Trash-screen restore — i.e. an ordinary moderation decision.
+ *
+ * This is the half of the pair it is easy to forget, and forgetting it is the expensive mistake:
+ * without it, approving a trashed comment leaves a row in the index pointing at a comment that is
+ * live on the page again, so the Trash screen offers to permanently delete published content.
+ */
+export type ForgetRemovedCommentFn = (required: {
+    workspaceId: string;
+    id: string;
+}) => Promise<void>;
+/**
+ * Runs `fn` inside one database transaction. MUST be reentrant — see the composition root's runner.
+ *
+ * Structurally typed for the same reason as {@link RemoveCommentFn}: no trash import here.
+ */
+export type CommentTransactionRunner = <T>(fn: () => Promise<T>) => Promise<T>;
+export interface CommentWriteServiceDeps {
+    repo: CommentRepoPort;
+    outbox: OutboxPort;
+    hooks: CommentHookRegistry;
+    clock: ClockPort;
+    idGen: IdGeneratorPort;
+    /** See {@link RemoveCommentFn}. Called only on the transition INTO `trash`. */
+    remove: RemoveCommentFn;
+    /** See {@link ForgetRemovedCommentFn}. Called only on the transition OUT of `trash`. */
+    forgetRemoved: ForgetRemovedCommentFn;
+    /**
+     * Wraps the moderation write and the index write so they are both-or-neither. `applyModeration`
+     * opens its own `better-sqlite3` transaction, which nests as a SAVEPOINT when one is already
+     * open, so this runner may be the outer one.
+     */
+    runInTransaction: CommentTransactionRunner;
+}
+/**
+ * Raised when the moderation write landed but its Trash index write could not.
+ *
+ * Only reachable if the comment row changed between two statements of the same transaction, which
+ * it cannot — so this is an invariant breach, not a runtime condition. It is thrown rather than
+ * returned so the enclosing transaction rolls the moderation back: a comment hidden with no Trash
+ * row is unrecoverable from the UI, which is strictly worse than a failed moderation the operator
+ * can retry.
+ */
+export declare class CommentRemovalIndexError extends Error {
+}
+export type ModerationResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "not-found" | "conflict";
+    currentVersion?: number | undefined;
+};
+export interface CommentWriteService {
+    applyModeration(required: {
+        workspaceId: UUID;
+        id: UUID;
+        expectedVersion: number;
+        action: ModerationAction;
+        toStatus: CommentStatus;
+        actorPrincipalId: UUID;
+        /** The assistant's AI marker on the Trash row's `actor.pluginId` (2026-09-21, trash T4c) —
+         *  unset by every non-assistant caller (the admin moderation route), so a human's own moderation
+         *  stays human-only. Held here only for the transition into `trash` ({@link syncRemovalIndex});
+         *  never persisted onto this domain's OWN moderation log, which has no such column. */
+        actorPluginId?: UUID | null;
+        note: string | null;
+    }, optional?: Record<string, never>): Promise<ModerationResult>;
+    purge(required: {
+        workspaceId: UUID;
+        id: UUID;
+        actorPrincipalId: UUID;
+        note: string | null;
+    }, optional?: Record<string, never>): Promise<ModerationResult>;
+}
+export declare function createCommentWriteService(deps: CommentWriteServiceDeps, _optional?: Record<string, never>): CommentWriteService;
+//# sourceMappingURL=write-service.d.ts.map

package/dist/comments/write-service.js

@@ -0,0 +1,144 @@
+import { nowIso as clockNowIso } from "@jini-ai/core/primitives";
+/** The one `CommentStatus` value that means "deleted" — the marker the Trash index mirrors. */
+const TRASHED_STATUS = "trash";
+/** Longest body excerpt stored as the Trash row's subtitle; matches the backfill's `substr(...,120)`. */
+const TRASH_SUBTITLE_MAX = 120;
+/**
+ * Raised when the moderation write landed but its Trash index write could not.
+ *
+ * Only reachable if the comment row changed between two statements of the same transaction, which
+ * it cannot — so this is an invariant breach, not a runtime condition. It is thrown rather than
+ * returned so the enclosing transaction rolls the moderation back: a comment hidden with no Trash
+ * row is unrecoverable from the UI, which is strictly worse than a failed moderation the operator
+ * can retry.
+ */
+export class CommentRemovalIndexError extends Error {
+}
+const EVENT_NAME_BY_ACTION = {
+    approve: "comments.approved",
+    mark_spam: "comments.marked_spam",
+    trash: "comments.trashed",
+};
+// Inline object literal at the enqueue() call site (not a `CommentDomainEvent`-typed
+// intermediate) — see ingress.ts's identical note on why: TS only infers a
+// `Record<string, unknown>`-compatible index signature for a FRESH literal argument.
+async function emitEvent(deps, required) {
+    await deps.outbox.enqueue({
+        id: deps.idGen.newId(),
+        name: required.name,
+        occurredAt: clockNowIso({ clock: deps.clock }),
+        aggregateId: required.commentId,
+        workspaceId: required.workspaceId,
+        payload: { commentId: required.commentId, entryId: required.entryId, status: required.status },
+    });
+}
+/**
+ * Keeps the Trash index in step with a moderation decision that just landed.
+ *
+ * Keys off the TRANSITION, not off the target status, and takes the transition from
+ * `log.fromStatus` — which `applyModeration` reads inside its own compare-and-set, so it is the one
+ * signal here that cannot race a concurrent moderation. That is what makes both failure modes
+ * unreachable rather than merely unlikely:
+ *
+ *  - **double index write** — `fromStatus !== trash` fires at most once per entry into the Trash,
+ *    so a repeated `trash` action cannot add a second row (the index's own uniqueness is a second
+ *    net, not the first one);
+ *  - **stranded index row** — `fromStatus === trash` with any other target fires on every exit,
+ *    including the ones that never touch the Trash screen, so an approved comment cannot stay
+ *    listed as deleted.
+ *
+ * Runs inside the caller's transaction, so a throw here rolls the moderation back with it.
+ *
+ * @complexity O(1) — at most one delegated write.
+ */
+async function syncRemovalIndex(deps, required) {
+    const from = required.log.fromStatus;
+    const to = required.record.status;
+    if (to === TRASHED_STATUS && from !== TRASHED_STATUS) {
+        const removed = await deps.remove({
+            workspaceId: required.record.workspaceId,
+            id: required.record.id,
+            // From the row `applyModeration` just returned — columns only, no second read.
+            display: {
+                title: `Comment on ${required.record.entryId}`,
+                subtitle: required.record.bodyText.slice(0, TRASH_SUBTITLE_MAX),
+            },
+            at: required.at,
+            // The version AFTER the flip: what the sweeper's compare-and-delete checks, and what a
+            // restore bumps past so the item always survives a race.
+            expectedVersion: required.record.version,
+            actor: { principalId: required.log.actorPrincipalId, pluginId: required.actorPluginId },
+        });
+        if (!removed.ok) {
+            throw new CommentRemovalIndexError(`comments: comment '${required.record.id}' was moved to trash but could not be indexed (${removed.reason})`);
+        }
+        return;
+    }
+    if (from === TRASHED_STATUS && to !== TRASHED_STATUS) {
+        await deps.forgetRemoved({ workspaceId: required.record.workspaceId, id: required.record.id });
+    }
+}
+export function createCommentWriteService(deps, _optional = {}) {
+    return {
+        async applyModeration(required) {
+            // Pulled out before the spread below: `deps.repo.applyModeration` persists this domain's OWN
+            // moderation log, which has no `actorPluginId` column — spreading it in would be an excess
+            // property on a fresh object literal (a real `tsc` error, not just a lint nit). The Trash's
+            // `actor.pluginId` is a SEPARATE concern, carried only as far as `syncRemovalIndex` below.
+            const { actorPluginId, ...repoRequired } = required;
+            const at = clockNowIso({ clock: deps.clock });
+            const result = await deps.runInTransaction(async () => {
+                const applied = await deps.repo.applyModeration({ ...repoRequired, at });
+                if (!applied.ok)
+                    return applied;
+                await syncRemovalIndex(deps, { at, log: applied.log, record: applied.record, actorPluginId: actorPluginId ?? null });
+                return applied;
+            });
+            if (!result.ok)
+                return result;
+            await deps.hooks.runStatusChangedHooks({
+                workspaceId: required.workspaceId,
+                commentId: required.id,
+                fromStatus: result.log.fromStatus,
+                toStatus: result.record.status,
+            });
+            const eventName = EVENT_NAME_BY_ACTION[required.action];
+            if (eventName) {
+                await emitEvent(deps, {
+                    workspaceId: required.workspaceId,
+                    name: eventName,
+                    commentId: required.id,
+                    entryId: result.record.entryId,
+                    status: result.record.status,
+                });
+            }
+            return { ok: true };
+        },
+        async purge(required) {
+            const at = clockNowIso({ clock: deps.clock });
+            const before = await deps.repo.findById({ workspaceId: required.workspaceId, id: required.id });
+            const result = await deps.runInTransaction(async () => {
+                const purged = await deps.repo.purge({ ...required, at });
+                // The row is gone for good, so its index row would otherwise outlive it and offer the Trash
+                // screen a "Restore" that can never succeed. Same both-or-neither transaction as the
+                // moderation path above.
+                if (purged.ok)
+                    await deps.forgetRemoved({ workspaceId: required.workspaceId, id: required.id });
+                return purged;
+            });
+            if (!result.ok)
+                return result;
+            if (before) {
+                await emitEvent(deps, {
+                    workspaceId: required.workspaceId,
+                    name: "comments.purged",
+                    commentId: required.id,
+                    entryId: before.entryId,
+                    status: before.status,
+                });
+            }
+            return { ok: true };
+        },
+    };
+}
+//# sourceMappingURL=write-service.js.map

package/dist/core/commands/command.d.ts

@@ -1,3 +1,4 @@
+import { ToolPermissionDeniedError as ForbiddenError } from "@jini-ai/core";
 import type { Clock, IdGenerator, JsonObject, UUID } from "@jini-ai/core/primitives";
 import type { OutboxPort } from "../ports.js";
 import type { ChangeSetOperation, ChangeSetRepoPort } from "./change-set.js";
@@ -146,15 +147,7 @@ export declare class DuplicateCommandError extends Error {
  * `DuplicateCommandError` either.
  * See docs/decisions/DR-006-mutation-audit-atomicity.md.
  */
-export declare class ForbiddenError extends Error {
-    readonly permission: string;
-    readonly reason: string;
-    constructor({ message, permission, reason }: {
-        message: string;
-        permission: string;
-        reason: string;
-    }, _optional?: Record<string, never>);
-}
+export { ForbiddenError };
 /**
  * Execute a mutation through the command gateway.
  *

package/dist/core/commands/command.js

@@ -1,3 +1,4 @@
+import { ToolPermissionDeniedError as ForbiddenError } from "@jini-ai/core";
 import { nowIso as kernelNowIso } from "@jini-ai/core/primitives";
 /**
  * Thrown when a command's idempotency key was already used in the workspace.
@@ -18,15 +19,7 @@ export class DuplicateCommandError extends Error {
  * `DuplicateCommandError` either.
  * See docs/decisions/DR-006-mutation-audit-atomicity.md.
  */
-export class ForbiddenError extends Error {
-    permission;
-    reason;
-    constructor({ message, permission, reason }, _optional = {}) {
-        super(message);
-        this.permission = permission;
-        this.reason = reason;
-    }
-}
+export { ForbiddenError };
 /**
  * Detects a UNIQUE-constraint violation on `changeSets.insert()`'s idempotency-key index —
  * the losing side of the TOCTOU race between the pre-execute `findByIdempotencyKey` check and

package/dist/core/index.d.ts

@@ -44,10 +44,11 @@
  * measured reason no domain could be extracted on its own. A per-entity applier registry belongs
  * behind a registration call the host makes, not behind a kernel barrel.
  */
-export type { DomainEvent, EventBusPort, OutboxRecord, OutboxPort, } from './ports.js';
+export type { DomainEvent, EventBusPort, OutboxRecord, OutboxPort, TransactionalRepoPort, } from './ports.js';
 export type { ChangeSetStatus, ChangeSetOperation, ChangeSetRecord, ChangeSetItemRecord, ChangeSetWithItems, ChangeSetRepoPort, } from './commands/change-set.js';
 export * from './commands/command.js';
 export * from './entity-liveness.js';
 export * from './tools/args.js';
 export type { AuthorizationPort, AuthorizationRequired, AuthorizationOptional } from './authorization.js';
+export { encodeKeysetCursor, decodeKeysetCursor, type KeysetPosition } from "./keyset-cursor.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -47,4 +47,5 @@
 export * from './commands/command.js';
 export * from './entity-liveness.js';
 export * from './tools/args.js';
+export { encodeKeysetCursor, decodeKeysetCursor } from "./keyset-cursor.js";
 //# sourceMappingURL=index.js.map

package/dist/core/keyset-cursor.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @file The opaque `${createdAt}::${id}` keyset cursor shared by the `(created_at, id)`-ordered
+ * list queries (the database ledger, the comment moderation queue).
+ *
+ * The cursor carries the position itself rather than naming a row to look up, so a page resumes
+ * correctly even after the row it ended on was deleted: the comment queue's cursor used to be the
+ * last comment's id, and once another moderator purged that comment, every "Load more" was refused
+ * with "invalid cursor" and retrying sent the same cursor forever.
+ */
+/** A position in a `(created_at, id)` order. */
+export type KeysetPosition = {
+    createdAt: string;
+    id: string;
+};
+/** Builds the cursor for the row a page ended on. @complexity O(1). */
+export declare function encodeKeysetCursor(required: KeysetPosition, _optional?: Record<string, never>): string;
+/** Splits a cursor {@link encodeKeysetCursor} built. A cursor it could not have built used to decode
+ *  to `null` and read as "no cursor", silently restarting the scan from its first page (the newest
+ *  ledger row; the oldest queued comment).
+ *  @throws {ToolInputError} `invalid cursor` (a 400 to the tool and admin transports alike).
+ *  @complexity O(cursor length). */
+export declare function decodeKeysetCursor(required: {
+    cursor: string;
+}, _optional?: Record<string, never>): KeysetPosition;
+//# sourceMappingURL=keyset-cursor.d.ts.map

package/dist/core/keyset-cursor.js

@@ -0,0 +1,20 @@
+import { ToolInputError } from "@jini-ai/core";
+/** Builds the cursor for the row a page ended on. @complexity O(1). */
+export function encodeKeysetCursor(required, _optional = {}) {
+    return `${required.createdAt}::${required.id}`;
+}
+/** Splits a cursor {@link encodeKeysetCursor} built. A cursor it could not have built used to decode
+ *  to `null` and read as "no cursor", silently restarting the scan from its first page (the newest
+ *  ledger row; the oldest queued comment).
+ *  @throws {ToolInputError} `invalid cursor` (a 400 to the tool and admin transports alike).
+ *  @complexity O(cursor length). */
+export function decodeKeysetCursor(required, _optional = {}) {
+    const separatorIndex = required.cursor.indexOf("::");
+    const createdAt = required.cursor.slice(0, separatorIndex);
+    const id = required.cursor.slice(separatorIndex + 2);
+    if (separatorIndex < 0 || id.length === 0 || Number.isNaN(Date.parse(createdAt))) {
+        throw new ToolInputError({ message: "invalid cursor" });
+    }
+    return { createdAt, id };
+}
+//# sourceMappingURL=keyset-cursor.js.map

package/dist/core/ports.d.ts

@@ -147,4 +147,34 @@ export interface OutboxPort {
     }, optional?: Record<string, never>): Promise<void>;
 }
 /** Clock and ID generator contracts are owned by the shared kernel primitives. */
+/**
+ * Opens/commits/rolls back one transaction around `fn` — the same shape and contract as this
+ * codebase's other write chokepoints that need one (`RedirectsWriteDeps.transaction`,
+ * `SqliteSettingsRepo.transaction`).
+ *
+ * `deleteTerm`/`deleteTaxonomy` run their ENTIRE body — every guard read (`findById`,
+ * `countChildren`, `countByTerm`) AND every write (`delete`, `revisions.insert`, `outbox.enqueue`)
+ * — inside one call to this. Two failure modes this closes that a guard-then-transaction split
+ * would not:
+ *
+ * 1. **TOCTOU on the guard.** A guard read taken BEFORE the transaction opens can go stale the
+ *    instant it returns — content can be assigned to the term in the gap between the read and the
+ *    delete, and the delete would proceed having checked a now-wrong count. Putting the read
+ *    inside the same transaction as the delete is what makes the guard's answer still true at the
+ *    moment the delete actually runs.
+ * 2. **Partial cascade.** `deleteTaxonomy` deletes N member terms then the taxonomy row itself,
+ *    with no FK/CASCADE at the schema level (`db/schema.ts` — `taxonomies`/`terms`/`entry_terms`/
+ *    `taxonomy_revisions` are plain columns, no foreign keys) to undo a mid-cascade failure. A
+ *    real transaction is the only thing that can.
+ *
+ * A caller-supplied identity/no-op implementation is a valid choice for a backend that has no
+ * separate transaction primitive to offer (see `repo.memory.ts`'s `InMemoryTaxonomyRepo` for the
+ * disclosed rationale) — the port exists so `deleteTerm`/`deleteTaxonomy` never have to know which
+ * kind of backend they're running against.
+ */
+export interface TransactionalRepoPort {
+    transaction<T>({ fn }: {
+        fn: () => Promise<T>;
+    }): Promise<T>;
+}
 //# sourceMappingURL=ports.d.ts.map

package/dist/core/ports.js

@@ -1,3 +1,2 @@
 export {};
-/** Clock and ID generator contracts are owned by the shared kernel primitives. */
 //# sourceMappingURL=ports.js.map

package/dist/core/tools/args.d.ts

@@ -1,49 +1,4 @@
 /** CMS permission checking preserves the CMS command denial contract. Generic registration wiring lives in the kernel. */
-import { type AuthorizeFn } from "../commands/command.js";
-import type { AuthorizationPort } from "../authorization.js";
+export { requireToolPermission, adaptLegacyAuthorize, type RequireToolPermissionRequired, type RequireToolPermissionOptional, } from "@jini-ai/core";
 export type { AuthorizationPort, AuthorizationRequired, AuthorizationOptional } from "../authorization.js";
-export interface RequireToolPermissionRequired {
-    authorize: AuthorizationPort;
-    workspaceId: string;
-    principalId: string;
-    permission: string;
-}
-export interface RequireToolPermissionOptional {
-    entityType?: string | undefined;
-    entityId?: string | undefined;
-}
-/**
- * Runs the identical inline `authorize()` check the corresponding admin HTTP route performs, for a
- * tool whose own domain function carries no `authorize()` call to inherit.
- *
- * This is NOT a second evaluator alongside another check — that is exactly the single-evaluator
- * rule's concern. For each tool that
- * calls it, this IS the only gate that tool's execution ever reaches, reached by an identical path
- * to the one a human clicking the same admin route reaches. Domains split cleanly on which kind
- * they are: content-types/Forms/Identity mutations and every Widgets write-service call self-enforce
- * inside the domain function and must NOT call this; Comments/Members/Newsletter/Media/Menus/
- * Database/Recovery gate in the route instead, so their handlers call this in the route's place.
- * Which kind a given tool is stays documented next to that tool's handler, not here.
- *
- * Throws `core/commands`'s `ForbiddenError` — the same class `executeCommand` itself throws — so a
- * tool caller and a route caller see the identical error shape for an identical denial. Throw
- * rather than a 403 body because the caller here is `ToolExecutor`, which reads a thrown error as a
- * failed execution and has no response to write to.
- *
- * Import the defining command module directly: its barrel also exports mutation appliers that
- * name content features. Pulling that barrel into shared permission wiring would couple every
- * tool domain to those features; the direct import preserves the identical denial class without
- * that dependency closure.
- *
- * @param required - The `authorize()` evaluator and the workspace the run is scoped to.
- * @param optional - Entity scope for who is asking, for what permission, optionally against which entity.
- * @throws {ForbiddenError} If `authorize()` denies.
- * @complexity O(1) beyond the injected `authorize()` call.
- * @overallScore 100
- */
-export declare function requireToolPermission(required: RequireToolPermissionRequired, optional?: RequireToolPermissionOptional): Promise<void>;
-/** Adapt an existing evaluator without losing entity scope. @complexity O(1) plus evaluation. */
-export declare function adaptLegacyAuthorize(required: {
-    authorize: AuthorizeFn;
-}, _optional?: Record<string, never>): AuthorizationPort;
 //# sourceMappingURL=args.d.ts.map

package/dist/core/tools/args.js

@@ -1,46 +1,3 @@
 /** CMS permission checking preserves the CMS command denial contract. Generic registration wiring lives in the kernel. */
-import { ForbiddenError } from "../commands/command.js";
-/**
- * Runs the identical inline `authorize()` check the corresponding admin HTTP route performs, for a
- * tool whose own domain function carries no `authorize()` call to inherit.
- *
- * This is NOT a second evaluator alongside another check — that is exactly the single-evaluator
- * rule's concern. For each tool that
- * calls it, this IS the only gate that tool's execution ever reaches, reached by an identical path
- * to the one a human clicking the same admin route reaches. Domains split cleanly on which kind
- * they are: content-types/Forms/Identity mutations and every Widgets write-service call self-enforce
- * inside the domain function and must NOT call this; Comments/Members/Newsletter/Media/Menus/
- * Database/Recovery gate in the route instead, so their handlers call this in the route's place.
- * Which kind a given tool is stays documented next to that tool's handler, not here.
- *
- * Throws `core/commands`'s `ForbiddenError` — the same class `executeCommand` itself throws — so a
- * tool caller and a route caller see the identical error shape for an identical denial. Throw
- * rather than a 403 body because the caller here is `ToolExecutor`, which reads a thrown error as a
- * failed execution and has no response to write to.
- *
- * Import the defining command module directly: its barrel also exports mutation appliers that
- * name content features. Pulling that barrel into shared permission wiring would couple every
- * tool domain to those features; the direct import preserves the identical denial class without
- * that dependency closure.
- *
- * @param required - The `authorize()` evaluator and the workspace the run is scoped to.
- * @param optional - Entity scope for who is asking, for what permission, optionally against which entity.
- * @throws {ForbiddenError} If `authorize()` denies.
- * @complexity O(1) beyond the injected `authorize()` call.
- * @overallScore 100
- */
-export async function requireToolPermission(required, optional = {}) {
-    const result = await required.authorize({
-        principalId: required.principalId, permission: required.permission, workspaceId: required.workspaceId,
-    }, optional);
-    if (!result.allowed)
-        throw new ForbiddenError({
-            message: `principal '${required.principalId}' is not authorized for '${required.permission}' (${result.reason})`,
-            permission: required.permission, reason: result.reason,
-        });
-}
-/** Adapt an existing evaluator without losing entity scope. @complexity O(1) plus evaluation. */
-export function adaptLegacyAuthorize(required, _optional = {}) {
-    return (request, optional = {}) => required.authorize({ ...request, ...optional });
-}
+export { requireToolPermission, adaptLegacyAuthorize, } from "@jini-ai/core";
 //# sourceMappingURL=args.js.map

package/dist/media/index.d.ts

@@ -21,7 +21,6 @@ export { InMemoryMediaRepo, InMemoryAssetBlobRepo, InMemoryAssetRenditionRepo, I
 export { withSha256Lock } from "./blob-gc-lock.js";
 export { DEFAULT_GC_GRACE_MS, resolveGcGraceMs, isBlobUnreferenced, tombstoneBlobIfUnreferenced, runBlobGcDeletePass, runBlobGcUnlinkPass, runBlobGcCycle, runMonthlyOrphanSweepStub, } from "./blob-gc.js";
 export { InMemoryBlobStore } from "./blob-store.memory.js";
-export { LocalFsBlobStore, type LocalFsBlobStoreDeps } from "./blob-store.fs.js";
 export { DEFAULT_MAX_UPLOAD_BYTES, DEFAULT_ALLOWED_MIME_TYPES, resolveWriteOnceSource, uploadMedia, listMedia, getMediaById, findMediaByIdOrSlug, updateMediaMetadata, trashMedia, purgeMedia, isValidMediaSlugFormat, type UploadMediaInput, type UploadMediaDeps, type UpdateMediaMetadataInput, type FindMediaByIdOrSlugRequired, } from "./media-service.js";
 export type { TransformFit, TransformFormat, TransformParams, TransformDefinitionRecord, } from "./transform-types.js";
 export { TransformValidationError, mimeForTransformFormat, MAX_TRANSFORM_DIMENSION_PX } from "./transform-types.js";
@@ -30,7 +29,6 @@ export { registerTransform, getLatestTransformDefinition, isLatestTransformVersi
 export { resolveMediaRendition, type ResolveMediaRenditionDeps, type ResolveMediaRenditionInput, type ResolveMediaRenditionResult, } from "./rendition-service.js";
 export type { ImageTransformerPort, TransformImageInput, TransformImageOutput } from "./image-transformer.js";
 export { InMemoryImageTransformer } from "./image-transformer.js";
-export { SharpImageTransformer, ImageTransformUnavailableError, ImageSourceCorruptError } from "./image-transformer.sharp.js";
 export { sniffContentType, type SniffedContentType } from "./content-type-sniffer.js";
 /** The agent-tool catalog for this domain (see `agent-tools.ts` for what is deliberately omitted). */
 export { mediaAgentToolCatalog, } from "./agent-tools.js";
@@ -49,5 +47,4 @@ export type { IsBlobUnreferencedRequired, TombstoneBlobRequired, RunBlobGcDelete
 export { rollbackUploadedMedia } from "./media-service.js";
 export type { MediaRowCleanupDeps } from "./media-service.js";
 export { VIDEO_DEFAULT_FRAMES, VIDEO_MAX_FRAMES, VIDEO_MAX_EDGE_PX, VIDEO_MAX_INPUT_BYTES, VIDEO_MAX_FRAME_BYTES, VIDEO_MAX_OUTPUT_BYTES, VIDEO_MAX_SHEET_BYTES, VIDEO_MAX_SHEETS, VIDEO_EXTRACTION_TIMEOUT_MS, planVideoFrames, parseVideoProbe, getVideoFrameEdge, planVideoContactSheets, type VideoMetadata, type VideoFrame, type VideoFrameOptions, type VideoFrameResult, type VideoFrameExtractor, type VideoSheetTile, type VideoSheetLayout, type VideoContactSheet, } from './video-frames.js';
-export { createFfmpegVideoFrameExtractor, findVideoBinaries, runLowPriorityVideoProcess, type VideoBinaries, type VideoBinaryFinder, type VideoProcessRunner, } from './video-frames.ffmpeg.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/media/index.js

@@ -6,14 +6,12 @@ export { InMemoryMediaRepo, InMemoryAssetBlobRepo, InMemoryAssetRenditionRepo, I
 export { withSha256Lock } from "./blob-gc-lock.js";
 export { DEFAULT_GC_GRACE_MS, resolveGcGraceMs, isBlobUnreferenced, tombstoneBlobIfUnreferenced, runBlobGcDeletePass, runBlobGcUnlinkPass, runBlobGcCycle, runMonthlyOrphanSweepStub, } from "./blob-gc.js";
 export { InMemoryBlobStore } from "./blob-store.memory.js";
-export { LocalFsBlobStore } from "./blob-store.fs.js";
 export { DEFAULT_MAX_UPLOAD_BYTES, DEFAULT_ALLOWED_MIME_TYPES, resolveWriteOnceSource, uploadMedia, listMedia, getMediaById, findMediaByIdOrSlug, updateMediaMetadata, trashMedia, purgeMedia, isValidMediaSlugFormat, } from "./media-service.js";
 export { TransformValidationError, mimeForTransformFormat, MAX_TRANSFORM_DIMENSION_PX } from "./transform-types.js";
 export { withRenditionLock, withTransformRegistryLock } from "./transform-lock.js";
 export { registerTransform, getLatestTransformDefinition, isLatestTransformVersion, isReferencedByPublishedContent, } from "./transform-registry.js";
 export { resolveMediaRendition, } from "./rendition-service.js";
 export { InMemoryImageTransformer } from "./image-transformer.js";
-export { SharpImageTransformer, ImageTransformUnavailableError, ImageSourceCorruptError } from "./image-transformer.sharp.js";
 // -----------------------------------------------------------------------------
 // Original-bytes admin preview route support. See `content-type-sniffer.ts`'s
 // file header for the disclosed scope: an allowlist magic-byte sniffer, not a
@@ -31,7 +29,6 @@ export { mediaAgentToolCatalog, } from "./agent-tools.js";
  */
 export { buildMediaRegistrations, mediaDerivedRisk, } from "./tool-registrations.js";
 export { rollbackUploadedMedia } from "./media-service.js";
-// Video previews: policy/port plus a bounded optional-host codec adapter.
+// Video previews: policy/port. The bounded optional-host codec adapter lives in ./node.js.
 export { VIDEO_DEFAULT_FRAMES, VIDEO_MAX_FRAMES, VIDEO_MAX_EDGE_PX, VIDEO_MAX_INPUT_BYTES, VIDEO_MAX_FRAME_BYTES, VIDEO_MAX_OUTPUT_BYTES, VIDEO_MAX_SHEET_BYTES, VIDEO_MAX_SHEETS, VIDEO_EXTRACTION_TIMEOUT_MS, planVideoFrames, parseVideoProbe, getVideoFrameEdge, planVideoContactSheets, } from './video-frames.js';
-export { createFfmpegVideoFrameExtractor, findVideoBinaries, runLowPriorityVideoProcess, } from './video-frames.ffmpeg.js';
 //# sourceMappingURL=index.js.map

package/dist/media/node.d.ts

@@ -0,0 +1,5 @@
+/** Node-bound media adapters; hosts supply the filesystem and optional codecs. */
+export { LocalFsBlobStore, type LocalFsBlobStoreDeps } from "./blob-store.fs.js";
+export { SharpImageTransformer, ImageTransformUnavailableError, ImageSourceCorruptError } from "./image-transformer.sharp.js";
+export { createFfmpegVideoFrameExtractor, findVideoBinaries, runLowPriorityVideoProcess, type VideoBinaries, type VideoBinaryFinder, type VideoProcessRunner, } from './video-frames.ffmpeg.js';
+//# sourceMappingURL=node.d.ts.map

package/dist/media/node.js

@@ -0,0 +1,6 @@
+/** Node-bound media adapters; hosts supply the filesystem and optional codecs. */
+export { LocalFsBlobStore } from "./blob-store.fs.js";
+export { SharpImageTransformer, ImageTransformUnavailableError, ImageSourceCorruptError } from "./image-transformer.sharp.js";
+// Video previews: policy/port plus a bounded optional-host codec adapter.
+export { createFfmpegVideoFrameExtractor, findVideoBinaries, runLowPriorityVideoProcess, } from './video-frames.ffmpeg.js';
+//# sourceMappingURL=node.js.map