@jini-ai/cms 0.3.10 → 0.4.0

package/dist/media/tool-registrations.js

@@ -1,7 +1,8 @@
-import { buildDomainRegistrations, indexCatalogById, requireInputRecord, requireString, requireToolPermission, withSchemaOnRejection, } from "../core/tools/registration-kit.js";
+import { buildDomainRegistrations, indexCatalogById, requireInputRecord, requireString, withSchemaOnRejection } from "@jini-ai/core";
+import { adaptLegacyAuthorize, requireToolPermission } from "../core/tools/index.js";
 import { mediaAgentToolCatalog } from "./agent-tools.js";
 import { listMedia, MediaValidationError, rollbackUploadedMedia, trashMedia, updateMediaMetadata, uploadMedia } from "./media-service.js";
-const CATALOG_BY_ID = indexCatalogById(mediaAgentToolCatalog);
+const CATALOG_BY_ID = indexCatalogById({ catalog: mediaAgentToolCatalog });
 /**
  * This wiring layer's OWN risk classification, authored from what each handler below actually
  * calls. See `DerivedRiskByToolId` in the kit for why it is independent of the catalog's own
@@ -19,7 +20,7 @@ export const mediaDerivedRisk = new Map([
     ["media_trash_asset", "mutates-durable-state"],
 ]);
 /** The only Media rejection worth decorating with the published schema — a shape problem a different input would fix. */
-function isMediaShapeRejection(error) {
+function isMediaShapeRejection({ error }) {
     return error instanceof MediaValidationError;
 }
 /**
@@ -53,10 +54,21 @@ function toMediaToolView(record) {
  * responsibility — see `MediaToolDeps.resolvePublicUrls`'s own doc).
  */
 async function toMediaToolViewsWithPublicUrls(routeDeps, records) {
-    const urls = routeDeps.resolvePublicUrls ? await routeDeps.resolvePublicUrls(records) : new Map();
+    const urls = routeDeps.resolvePublicUrls ? await routeDeps.resolvePublicUrls({ assets: records }) : new Map();
     return records.map((record) => ({ ...toMediaToolView(record), publicUrl: urls.get(record.id) ?? null }));
 }
-export function buildMediaRegistrations(routeDeps) {
+export function buildMediaRegistrations(required, optional = {}) {
+    const routeDeps = {
+        authorize: required.authorize,
+        workspaceId: required.workspaceId,
+        clock: required.clock,
+        idGen: required.idGen,
+        mediaRepo: required.mediaRepo,
+        assetBlobRepo: required.assetBlobRepo,
+        assetRenditionRepo: required.assetRenditionRepo,
+        blobStore: required.blobStore,
+        ...optional,
+    };
     const mediaWriteDeps = () => ({
         clock: routeDeps.clock,
         idGen: routeDeps.idGen,
@@ -67,84 +79,84 @@ export function buildMediaRegistrations(routeDeps) {
     });
     const handlers = {
         media_list_assets: async (ctx) => {
-            await requireToolPermission(routeDeps, { principalId: ctx.principal.id, permission: "media.read", entityType: "media" });
+            await requireToolPermission({ authorize: adaptLegacyAuthorize({ authorize: routeDeps.authorize }), workspaceId: routeDeps.workspaceId, principalId: ctx.principal.id, permission: "media.read" }, { entityType: "media" });
             const { media } = await listMedia({ deps: { mediaRepo: routeDeps.mediaRepo }, input: { workspaceId: routeDeps.workspaceId } });
             return { media: await toMediaToolViewsWithPublicUrls(routeDeps, media) };
         },
         media_upload_asset: async (ctx) => {
-            const input = requireInputRecord(ctx.input);
-            await requireToolPermission(routeDeps, { principalId: ctx.principal.id, permission: "media.upload", entityType: "media" });
-            return withSchemaOnRejection({ toolId: "media_upload_asset", catalog: CATALOG_BY_ID, isShapeRejection: isMediaShapeRejection }, async () => {
-                const dataBase64 = requireString(input, "dataBase64");
-                let bytes;
-                try {
-                    bytes = new Uint8Array(Buffer.from(dataBase64, "base64"));
-                }
-                catch {
-                    throw new Error("'dataBase64' is not valid base64");
-                }
-                const { media } = await uploadMedia({
-                    deps: mediaWriteDeps(),
-                    input: {
-                        workspaceId: routeDeps.workspaceId,
-                        bytes,
-                        filename: requireString(input, "filename"),
-                        contentType: requireString(input, "contentType"),
-                        alt: typeof input.alt === "string" ? input.alt : undefined,
-                        caption: typeof input.caption === "string" ? input.caption : undefined,
-                        credit: typeof input.credit === "string" ? input.credit : undefined,
-                        createdByPrincipal: ctx.principal.id,
-                    },
-                }, { maxUploadBytes: routeDeps.maxUploadBytes });
-                if (routeDeps.recordUploadContentType) {
+            const input = requireInputRecord({ input: ctx.input });
+            await requireToolPermission({ authorize: adaptLegacyAuthorize({ authorize: routeDeps.authorize }), workspaceId: routeDeps.workspaceId, principalId: ctx.principal.id, permission: "media.upload" }, { entityType: "media" });
+            return withSchemaOnRejection({ toolId: "media_upload_asset", catalog: CATALOG_BY_ID, isShapeRejection: isMediaShapeRejection, fn: async () => {
+                    const dataBase64 = requireString({ input, key: "dataBase64" });
+                    let bytes;
                     try {
-                        await routeDeps.recordUploadContentType({ media, bytes });
+                        bytes = new Uint8Array(Buffer.from(dataBase64, "base64"));
                     }
-                    catch (err) {
-                        // The blob/media/rendition rows uploadMedia() just wrote must not survive as orphans
-                        // when the caller is about to see this whole upload as failed (the fix for that gap —
-                        // see rollbackUploadedMedia's own doc). The original hook error is rethrown unchanged.
-                        await rollbackUploadedMedia({
-                            deps: {
-                                mediaRepo: routeDeps.mediaRepo,
-                                blobRepo: routeDeps.assetBlobRepo,
-                                renditionRepo: routeDeps.assetRenditionRepo,
-                                clock: routeDeps.clock,
-                            },
-                            input: { workspaceId: routeDeps.workspaceId, media },
-                        });
-                        throw err;
+                    catch {
+                        throw new Error("'dataBase64' is not valid base64");
                     }
-                }
-                const [view] = await toMediaToolViewsWithPublicUrls(routeDeps, [media]);
-                return { media: view };
-            });
+                    const { media } = await uploadMedia({
+                        deps: mediaWriteDeps(),
+                        input: {
+                            workspaceId: routeDeps.workspaceId,
+                            bytes,
+                            filename: requireString({ input, key: "filename" }),
+                            contentType: requireString({ input, key: "contentType" }),
+                            alt: typeof input.alt === "string" ? input.alt : undefined,
+                            caption: typeof input.caption === "string" ? input.caption : undefined,
+                            credit: typeof input.credit === "string" ? input.credit : undefined,
+                            createdByPrincipal: ctx.principal.id,
+                        },
+                    }, { maxUploadBytes: routeDeps.maxUploadBytes });
+                    if (routeDeps.recordUploadContentType) {
+                        try {
+                            await routeDeps.recordUploadContentType({ media, bytes });
+                        }
+                        catch (err) {
+                            // The blob/media/rendition rows uploadMedia() just wrote must not survive as orphans
+                            // when the caller is about to see this whole upload as failed (the fix for that gap —
+                            // see rollbackUploadedMedia's own doc). The original hook error is rethrown unchanged.
+                            await rollbackUploadedMedia({
+                                deps: {
+                                    mediaRepo: routeDeps.mediaRepo,
+                                    blobRepo: routeDeps.assetBlobRepo,
+                                    renditionRepo: routeDeps.assetRenditionRepo,
+                                    clock: routeDeps.clock,
+                                },
+                                input: { workspaceId: routeDeps.workspaceId, media },
+                            });
+                            throw err;
+                        }
+                    }
+                    const [view] = await toMediaToolViewsWithPublicUrls(routeDeps, [media]);
+                    return { media: view };
+                } });
         },
         media_update_metadata: async (ctx) => {
-            const input = requireInputRecord(ctx.input);
-            const mediaId = requireString(input, "mediaId");
-            await requireToolPermission(routeDeps, { principalId: ctx.principal.id, permission: "media.update", entityType: "media", entityId: mediaId });
-            return withSchemaOnRejection({ toolId: "media_update_metadata", catalog: CATALOG_BY_ID, isShapeRejection: isMediaShapeRejection }, async () => {
-                const { media } = await updateMediaMetadata({
-                    deps: { clock: routeDeps.clock, mediaRepo: routeDeps.mediaRepo },
-                    input: {
-                        workspaceId: routeDeps.workspaceId,
-                        id: mediaId,
-                        title: typeof input.title === "string" ? input.title : undefined,
-                        alt: typeof input.alt === "string" ? input.alt : undefined,
-                        caption: typeof input.caption === "string" ? input.caption : undefined,
-                        credit: typeof input.credit === "string" ? input.credit : undefined,
-                        slug: typeof input.slug === "string" ? input.slug : undefined,
-                        cssClass: typeof input.cssClass === "string" ? input.cssClass : undefined,
-                        htmlAttributes: typeof input.htmlAttributes === "string" ? input.htmlAttributes : undefined,
-                    },
-                });
-                return { media: toMediaToolView(media) };
-            });
+            const input = requireInputRecord({ input: ctx.input });
+            const mediaId = requireString({ input, key: "mediaId" });
+            await requireToolPermission({ authorize: adaptLegacyAuthorize({ authorize: routeDeps.authorize }), workspaceId: routeDeps.workspaceId, principalId: ctx.principal.id, permission: "media.update" }, { entityType: "media", entityId: mediaId });
+            return withSchemaOnRejection({ toolId: "media_update_metadata", catalog: CATALOG_BY_ID, isShapeRejection: isMediaShapeRejection, fn: async () => {
+                    const { media } = await updateMediaMetadata({
+                        deps: { clock: routeDeps.clock, mediaRepo: routeDeps.mediaRepo },
+                        input: {
+                            workspaceId: routeDeps.workspaceId,
+                            id: mediaId,
+                            title: typeof input.title === "string" ? input.title : undefined,
+                            alt: typeof input.alt === "string" ? input.alt : undefined,
+                            caption: typeof input.caption === "string" ? input.caption : undefined,
+                            credit: typeof input.credit === "string" ? input.credit : undefined,
+                            slug: typeof input.slug === "string" ? input.slug : undefined,
+                            cssClass: typeof input.cssClass === "string" ? input.cssClass : undefined,
+                            htmlAttributes: typeof input.htmlAttributes === "string" ? input.htmlAttributes : undefined,
+                        },
+                    });
+                    return { media: toMediaToolView(media) };
+                } });
         },
         media_trash_asset: async (ctx) => {
-            const mediaId = requireString(requireInputRecord(ctx.input), "mediaId");
-            await requireToolPermission(routeDeps, { principalId: ctx.principal.id, permission: "media.delete", entityType: "media", entityId: mediaId });
+            const mediaId = requireString({ input: requireInputRecord({ input: ctx.input }), key: "mediaId" });
+            await requireToolPermission({ authorize: adaptLegacyAuthorize({ authorize: routeDeps.authorize }), workspaceId: routeDeps.workspaceId, principalId: ctx.principal.id, permission: "media.delete" }, { entityType: "media", entityId: mediaId });
             const { media } = await trashMedia({
                 deps: { clock: routeDeps.clock, mediaRepo: routeDeps.mediaRepo },
                 input: { workspaceId: routeDeps.workspaceId, id: mediaId },

package/dist/media/transform-lock.d.ts

@@ -1,21 +1,22 @@
 /**
  * @file Generic in-process keyed mutex factory, extracted from
- * `blob-gc-lock.ts`'s `withSha256Lock` shape (INV-1's
+ * `blob-gc-lock.ts`'s `withSha256Lock` shape (
  * "Serialization" clause) so the same FIFO-per-key critical-section pattern
  * can back two independent lock namespaces this domain needs:
  *
- *  - `withTransformRegistryLock` — serializes `registerTransform`'s
- *    read-max-version-then-insert-next-version sequence per `(workspaceId,
- *    name)`, so two concurrent registrations of the same name can't both
- *    read the same "current max" and mint a colliding version.
- *  - `withRenditionLock` — serializes lazy rendition generation per
- *    `(sha256, transformName, version)` ("single-flight"), so two
- *    concurrent requests for the same not-yet-generated rendition never run
- *    the image transformer twice.
+ * - `withTransformRegistryLock` — serializes `registerTransform`'s
+ * read-max-version-then-insert-next-version sequence per `(workspaceId,
+ * name)`, so two concurrent registrations of the same name can't both
+ * read the same "current max" and mint a colliding version.
+ * - `withRenditionLock` — serializes lazy rendition generation per
+ * `(sha256, transformName, version)` ("single-flight"), so two
+ * concurrent requests for the same not-yet-generated rendition never run
+ * the image transformer twice.
  *
  * `blob-gc-lock.ts` itself is untouched — this is a separate module, not a
  * modification of that file's exports (its shape is deliberately mirrored
  * here, not imported, so `blob-gc-lock.ts`'s own signature stays untouched).
+ * See docs/decisions/DR-004-journaled-blob-gc.md.
  */
 /**
  * Creates one independent keyed-lock namespace: calls sharing the same `key`
@@ -28,9 +29,18 @@
  * by the number of other calls currently queued for the same key.
  * @overallScore 100
  */
-export declare function createKeyedLock(): <T>(key: string, criticalSection: () => Promise<T>) => Promise<T>;
+export declare function createKeyedLock(_required: Record<string, never>, _optional?: Record<string, never>): <T>(required: {
+    key: string;
+    criticalSection: () => Promise<T>;
+}, optional?: Record<string, never>) => Promise<T>;
 /** Keyed on `${workspaceId}:${name}` — see file header. */
-export declare const withTransformRegistryLock: <T>(key: string, criticalSection: () => Promise<T>) => Promise<T>;
+export declare const withTransformRegistryLock: <T>(required: {
+    key: string;
+    criticalSection: () => Promise<T>;
+}, optional?: Record<string, never>) => Promise<T>;
 /** Keyed on `${sha256}:${transformName}:${version}` — see file header. */
-export declare const withRenditionLock: <T>(key: string, criticalSection: () => Promise<T>) => Promise<T>;
+export declare const withRenditionLock: <T>(required: {
+    key: string;
+    criticalSection: () => Promise<T>;
+}, optional?: Record<string, never>) => Promise<T>;
 //# sourceMappingURL=transform-lock.d.ts.map

package/dist/media/transform-lock.js

@@ -1,21 +1,22 @@
 /**
  * @file Generic in-process keyed mutex factory, extracted from
- * `blob-gc-lock.ts`'s `withSha256Lock` shape (INV-1's
+ * `blob-gc-lock.ts`'s `withSha256Lock` shape (
  * "Serialization" clause) so the same FIFO-per-key critical-section pattern
  * can back two independent lock namespaces this domain needs:
  *
- *  - `withTransformRegistryLock` — serializes `registerTransform`'s
- *    read-max-version-then-insert-next-version sequence per `(workspaceId,
- *    name)`, so two concurrent registrations of the same name can't both
- *    read the same "current max" and mint a colliding version.
- *  - `withRenditionLock` — serializes lazy rendition generation per
- *    `(sha256, transformName, version)` ("single-flight"), so two
- *    concurrent requests for the same not-yet-generated rendition never run
- *    the image transformer twice.
+ * - `withTransformRegistryLock` — serializes `registerTransform`'s
+ * read-max-version-then-insert-next-version sequence per `(workspaceId,
+ * name)`, so two concurrent registrations of the same name can't both
+ * read the same "current max" and mint a colliding version.
+ * - `withRenditionLock` — serializes lazy rendition generation per
+ * `(sha256, transformName, version)` ("single-flight"), so two
+ * concurrent requests for the same not-yet-generated rendition never run
+ * the image transformer twice.
  *
  * `blob-gc-lock.ts` itself is untouched — this is a separate module, not a
  * modification of that file's exports (its shape is deliberately mirrored
  * here, not imported, so `blob-gc-lock.ts`'s own signature stays untouched).
+ * See docs/decisions/DR-004-journaled-blob-gc.md.
  */
 /**
  * Creates one independent keyed-lock namespace: calls sharing the same `key`
@@ -28,9 +29,9 @@
  * by the number of other calls currently queued for the same key.
  * @overallScore 100
  */
-export function createKeyedLock() {
+export function createKeyedLock(_required, _optional = {}) {
     const lockTails = new Map();
-    return function withLock(key, criticalSection) {
+    return function withLock({ key, criticalSection }, _optional = {}) {
         const priorTail = lockTails.get(key) ?? Promise.resolve();
         const run = priorTail.then(criticalSection, criticalSection);
         const settledTail = run.then(() => undefined, () => undefined);
@@ -44,7 +45,7 @@ export function createKeyedLock() {
     };
 }
 /** Keyed on `${workspaceId}:${name}` — see file header. */
-export const withTransformRegistryLock = createKeyedLock();
+export const withTransformRegistryLock = createKeyedLock({});
 /** Keyed on `${sha256}:${transformName}:${version}` — see file header. */
-export const withRenditionLock = createKeyedLock();
+export const withRenditionLock = createKeyedLock({});
 //# sourceMappingURL=transform-lock.js.map

package/dist/media/transform-registry.d.ts

@@ -6,7 +6,7 @@
  * Mirrors `media-service.ts`'s shape: plain async functions taking
  * `{ deps, input }` (+ optional `options`), typed domain errors.
  */
-import type { ClockPort, IdGeneratorPort, UUID } from "../core/ports.js";
+import type { Clock, IdGenerator, UUID } from "@jini-ai/core/primitives";
 import type { TransformDefinitionRepoPort } from "./ports.js";
 import { TransformValidationError, type TransformDefinitionRecord, type TransformParams } from "./transform-types.js";
 export { TransformValidationError };
@@ -18,8 +18,8 @@ export interface RegisterTransformInput {
     owner: string;
 }
 export interface RegisterTransformDeps {
-    clock: ClockPort;
-    idGen: IdGeneratorPort;
+    clock: Clock;
+    idGen: IdGenerator;
     transformRepo: TransformDefinitionRepoPort;
 }
 export interface RegisterTransformRequired {

package/dist/media/transform-registry.js

@@ -1,3 +1,4 @@
+import { nowIso as kernelNowIso } from "@jini-ai/core/primitives";
 import { assertValidTransformParams, TransformValidationError } from "./transform-types.js";
 import { withTransformRegistryLock } from "./transform-lock.js";
 export { TransformValidationError };
@@ -21,26 +22,26 @@ export async function registerTransform(required, _optional = {}) {
     const { deps, input } = required;
     const name = input.name.trim();
     if (!name)
-        throw new TransformValidationError("transform name is required");
+        throw new TransformValidationError({ message: "transform name is required" });
     const owner = input.owner.trim();
     if (!owner)
-        throw new TransformValidationError("owner is required");
-    assertValidTransformParams(input.params);
-    return withTransformRegistryLock(`${input.workspaceId}:${name}`, async () => {
-        const existingVersions = await deps.transformRepo.listByName({ workspaceId: input.workspaceId, name });
-        const currentMaxVersion = existingVersions.reduce((max, row) => Math.max(max, row.version), 0);
-        const definition = {
-            id: deps.idGen.newId(),
-            workspaceId: input.workspaceId,
-            name,
-            version: currentMaxVersion + 1,
-            params: input.params,
-            owner,
-            createdAt: deps.clock.nowIso(),
-        };
-        await deps.transformRepo.insert(definition);
-        return { definition };
-    });
+        throw new TransformValidationError({ message: "owner is required" });
+    assertValidTransformParams({ format: input.params.format }, { width: input.params.width, height: input.params.height, fit: input.params.fit });
+    return withTransformRegistryLock({ key: `${input.workspaceId}:${name}`, criticalSection: async () => {
+            const existingVersions = await deps.transformRepo.listByName({ workspaceId: input.workspaceId, name });
+            const currentMaxVersion = existingVersions.reduce((max, row) => Math.max(max, row.version), 0);
+            const definition = {
+                id: deps.idGen.newId(),
+                workspaceId: input.workspaceId,
+                name,
+                version: currentMaxVersion + 1,
+                params: input.params,
+                owner,
+                createdAt: kernelNowIso({ clock: deps.clock }),
+            };
+            await deps.transformRepo.insert(definition);
+            return { definition };
+        } });
 }
 /**
  * Returns the highest-`version` row registered for `name`, or `null` if

package/dist/media/transform-types.d.ts

@@ -21,7 +21,7 @@
  * solves the identical "who registered this, extensibly" problem for the
  * permission catalog.
  */
-import type { ISODateTime, UUID } from "../core/ports.js";
+import type { ISODateTime, UUID } from "@jini-ai/core/primitives";
 /** Resize behavior, mirrors `sharp`'s `fit` vocabulary (a deliberately small subset). */
 export type TransformFit = "cover" | "contain" | "fill" | "inside" | "outside";
 /**
@@ -60,12 +60,17 @@ export interface TransformDefinitionRecord {
     createdAt: ISODateTime;
 }
 export declare class TransformValidationError extends Error {
+    constructor({ message }: {
+        message: string;
+    }, optionalArgs?: ErrorOptions);
 }
 /**
  * @complexity O(1).
  * @overallScore 100
  */
-export declare function mimeForTransformFormat(format: TransformFormat): string;
+export declare function mimeForTransformFormat(requiredArgs: {
+    format: TransformFormat;
+}, optionalArgs?: Record<string, never>): string;
 /** Upper bound on a requested resize dimension — an output-side resource-use guard (not the
  * full pixel-bomb ingest cap, which polices upload input; this polices the transform
  * definition itself so a registered definition can't ask the image transformer to allocate an
@@ -78,5 +83,5 @@ export declare const MAX_TRANSFORM_DIMENSION_PX = 8000;
  * @complexity O(1).
  * @overallScore 100
  */
-export declare function assertValidTransformParams(params: TransformParams): void;
+export declare function assertValidTransformParams(required: Pick<TransformParams, "format">, optional?: Omit<TransformParams, "format">): void;
 //# sourceMappingURL=transform-types.d.ts.map

package/dist/media/transform-types.js

@@ -1,4 +1,7 @@
 export class TransformValidationError extends Error {
+    constructor({ message }, optionalArgs = {}) {
+        super(message, optionalArgs);
+    }
 }
 /** Maps a {@link TransformFormat} to the MIME type served on the rendition response. */
 const MIME_BY_TRANSFORM_FORMAT = {
@@ -11,7 +14,8 @@ const MIME_BY_TRANSFORM_FORMAT = {
  * @complexity O(1).
  * @overallScore 100
  */
-export function mimeForTransformFormat(format) {
+export function mimeForTransformFormat(requiredArgs, optionalArgs = {}) {
+    const { format } = requiredArgs;
     return MIME_BY_TRANSFORM_FORMAT[format];
 }
 /** Upper bound on a requested resize dimension — an output-side resource-use guard (not the
@@ -26,9 +30,10 @@ export const MAX_TRANSFORM_DIMENSION_PX = 8000;
  * @complexity O(1).
  * @overallScore 100
  */
-export function assertValidTransformParams(params) {
+export function assertValidTransformParams(required, optional = {}) {
+    const params = { format: required.format, ...optional };
     if (!params.format || !(params.format in MIME_BY_TRANSFORM_FORMAT)) {
-        throw new TransformValidationError(`transform params.format must be one of ${Object.keys(MIME_BY_TRANSFORM_FORMAT).join(", ")}`);
+        throw new TransformValidationError({ message: `transform params.format must be one of ${Object.keys(MIME_BY_TRANSFORM_FORMAT).join(", ")}` });
     }
     for (const [key, value] of [
         ["width", params.width],
@@ -37,11 +42,11 @@ export function assertValidTransformParams(params) {
         if (value === undefined)
             continue;
         if (!Number.isInteger(value) || value < 1 || value > MAX_TRANSFORM_DIMENSION_PX) {
-            throw new TransformValidationError(`transform params.${key} must be an integer between 1 and ${MAX_TRANSFORM_DIMENSION_PX}`);
+            throw new TransformValidationError({ message: `transform params.${key} must be an integer between 1 and ${MAX_TRANSFORM_DIMENSION_PX}` });
         }
     }
     if (params.fit !== undefined && !(params.width && params.height)) {
-        throw new TransformValidationError("transform params.fit requires both width and height");
+        throw new TransformValidationError({ message: "transform params.fit requires both width and height" });
     }
 }
 //# sourceMappingURL=transform-types.js.map

package/dist/media/types.d.ts

@@ -22,7 +22,7 @@
  * the original design describes — they were always meant to be core-owned tables
  * independent of the entries model, so no scope adjustment was needed there.
  */
-import type { ISODateTime, UUID } from "../core/ports.js";
+import type { ISODateTime, UUID } from "@jini-ai/core/primitives";
 /** Deletion ladder status (mirrored from `navigation`'s menu ladder). */
 export type MediaStatus = "active" | "trashed";
 /**
@@ -91,13 +91,14 @@ export interface MediaRecord {
     htmlAttributes: string | null;
 }
 /**
- * Blob-GC lifecycle status (INV-1's two-phase journaled protocol,
+ * Blob-GC lifecycle status ( two-phase journaled protocol,
  * implemented in `blob-gc.ts`). `active` — has at least one live reference as
  * of the last check (or has never been checked). `tombstoned` — the
  * tombstone-pass found it unreferenced and is waiting out `gc_grace` before
  * the delete-pass may remove the row; a dedup upload observing `tombstoned`
  * resurrects it back to `active` in the same locked section instead of
  * writing a duplicate blob.
+ * See docs/decisions/DR-004-journaled-blob-gc.md.
  */
 export type AssetBlobStatus = "active" | "tombstoned";
 /**
@@ -119,7 +120,7 @@ export interface AssetBlobRecord {
     tombstonedAt?: ISODateTime | undefined;
 }
 /**
- * `blob_gc_journal` sidecar (INV-1's two-phase protocol,
+ * `blob_gc_journal` sidecar ( two-phase protocol,
  * `blob-gc.ts`): written by the delete-pass in the same locked step as the
  * `asset_blobs` row deletion, drained by the unlink-pass. This is what makes
  * the unlink crash-safe/retriable instead of "delete row, hope the unlink
@@ -128,6 +129,7 @@ export interface AssetBlobRecord {
  * in-memory table like every other `media` repo in this pass — it does not
  * survive a process restart; see `repo.memory.ts` file header for the
  * standing disclosed precedent.)
+ * See docs/decisions/DR-004-journaled-blob-gc.md.
  */
 export interface BlobGcJournalEntry {
     id: UUID;
@@ -152,16 +154,28 @@ export interface AssetRenditionRecord {
     createdAt: ISODateTime;
 }
 export declare class MediaNotFoundError extends Error {
+    constructor({ message }: {
+        message: string;
+    }, optionalArgs?: ErrorOptions);
 }
 export declare class MediaValidationError extends Error {
+    constructor({ message }: {
+        message: string;
+    }, optionalArgs?: ErrorOptions);
 }
 export declare class MediaConflictError extends Error {
+    constructor({ message }: {
+        message: string;
+    }, optionalArgs?: ErrorOptions);
 }
 /**
  * The write-once source guard rejected an attempt to change an
  * already-set `source.sha256` ("settable-once-from-absent").
  */
 export declare class MediaSourceImmutableError extends MediaValidationError {
+    constructor({ message }: {
+        message: string;
+    }, optionalArgs?: ErrorOptions);
 }
 /**
  * The 409-style purge rejection (deletion ladder, mirrors
@@ -171,6 +185,9 @@ export declare class MediaSourceImmutableError extends MediaValidationError {
  */
 export declare class MediaStillReferencedError extends MediaConflictError {
     readonly referencing: readonly string[];
-    constructor(message: string, referencing: readonly string[]);
+    constructor(requiredArgs: {
+        message: string;
+        referencing: readonly string[];
+    }, optionalArgs?: Record<string, never>);
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/media/types.js

@@ -1,14 +1,26 @@
 export class MediaNotFoundError extends Error {
+    constructor({ message }, optionalArgs = {}) {
+        super(message, optionalArgs);
+    }
 }
 export class MediaValidationError extends Error {
+    constructor({ message }, optionalArgs = {}) {
+        super(message, optionalArgs);
+    }
 }
 export class MediaConflictError extends Error {
+    constructor({ message }, optionalArgs = {}) {
+        super(message, optionalArgs);
+    }
 }
 /**
  * The write-once source guard rejected an attempt to change an
  * already-set `source.sha256` ("settable-once-from-absent").
  */
 export class MediaSourceImmutableError extends MediaValidationError {
+    constructor({ message }, optionalArgs = {}) {
+        super({ message }, optionalArgs);
+    }
 }
 /**
  * The 409-style purge rejection (deletion ladder, mirrors
@@ -18,8 +30,9 @@ export class MediaSourceImmutableError extends MediaValidationError {
  */
 export class MediaStillReferencedError extends MediaConflictError {
     referencing;
-    constructor(message, referencing) {
-        super(message);
+    constructor(requiredArgs, optionalArgs = {}) {
+        const { message, referencing } = requiredArgs;
+        super({ message: message });
         this.referencing = referencing;
     }
 }