@heyo-sh/heyo-cms 0.0.0-stage → 0.2.0

package/dist/index-ypcmns0v.js

@@ -0,0 +1,2 @@
+import{e}from"./index-x72d1hzh.js";var c=new Set(["dashboard","collection-list","document","global","media","trash","settings"]),g=100,r=200,f=120,m=new Set(["users","roles","locales","keys","ai","webhooks","deployment","activity"]);function no(l){if(typeof l!=="object"||l===null||Array.isArray(l))return;let n=l,i=n.kind;if(typeof i!=="string"||!c.has(i))return;let t=Array.isArray(n.dirtyFields)?n.dirtyFields.filter((s)=>typeof s==="string").slice(0,g):void 0,o=Number(n.baselineRevision);return{kind:i,...typeof n.collectionSlug==="string"?{collectionSlug:n.collectionSlug.slice(0,r)}:{},...typeof n.documentId==="string"?{documentId:n.documentId.slice(0,r)}:{},...typeof n.mediaId==="string"?{mediaId:n.mediaId.slice(0,r)}:{},...typeof n.tab==="string"&&n.tab.trim().length>0?{tab:n.tab.trim().slice(0,f)}:{},...typeof n.locale==="string"?{locale:n.locale}:{},...t&&t.length>0?{dirtyFields:t}:{},...Number.isInteger(o)&&o>0?{baselineRevision:o}:{}}}function oo(l,n,i){let t=i!==void 0&&a(l,i)?i:l.i18n.defaultLocale;if(!n)return{kind:"dashboard",collection:null,documentId:null,mediaId:null,tab:null,locale:t,dirtyFields:[],baselineRevision:null};let o=n.locale!==void 0&&a(l,n.locale)?n.locale:t,s=C(l,n);return{kind:n.kind,collection:s,documentId:n.documentId??null,mediaId:n.kind==="media"?n.mediaId??null:null,tab:b(n,s),locale:o,dirtyFields:n.dirtyFields??[],baselineRevision:n.baselineRevision??null}}function b(l,n){let i=l.tab;if(!i)return null;if(l.kind==="settings")return m.has(i)?i:null;if(l.kind==="media")return i==="active"||i==="orphaned"?i:null;if(l.kind==="document"||l.kind==="global")return n?.fields[i]?.type==="richText"?i:null;return null}function C(l,n){if(n.collectionSlug===void 0)return null;let i=n.kind==="global"?"global":n.kind==="document"||n.kind==="collection-list"?"collection":void 0;if(i===void 0)return null;let t={...l.collections,...l.globals},o=Object.values(t).find((s)=>s.slug===n.collectionSlug);if(!o||o.kind!==i)return null;return o}function L(l,n,i){let t={...l.collections,...l.globals},o=t[n],s=Object.values(t).find((u)=>u.slug===n);if(o&&s&&o.name!==s.name)throw e.validation(`"${n}" is ambiguous: it names ${o.name} and is the slug of ${s.name}. Use an unambiguous name or slug from describe_cms.`);let d=o??s;if(!d)throw e.notFound(`There is no collection called "${n}". Call describe_cms for the list.`);if(i&&d.kind!==i)throw e.validation(`"${n}" is a ${d.kind}, not a ${i}.`);return d}function a(l,n){return l.i18n.locales.includes(n)}function de(l,n,i){if(i!==void 0&&a(l,i))return i;if(i!==void 0)throw e.validation(`"${i}" is not a configured locale. Call describe_cms for the list.`);return n.locale}var ue={maxTurns:8,maxToolCalls:16,timeoutMs:90000};
+export{no,oo,L,de,ue};

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `@heyo-sh/heyo-cms`.
+ *
+ * The configuration surface and the contracts. Databases, fields and storage
+ * come from their own entry points so a Worker bundle only carries what it
+ * uses.
+ */
+export { defaultAdminPath, defaultBasePath, defaultMigrationsDirectory, defineCollection, defineGlobal, heyoCms, systemActor, } from "./config";
+export { aiActionsFor, createAi, defineAiAction, getAiAction, piCompletion, registeredAiActions, } from "./ai/index";
+export { defineEditorMark, defineEditorNode, describeEditorSchema, getEditorMark, getEditorNode, registeredEditorMarks, registeredEditorNodes, renderRichText, richTextFromMarkdown, richTextFromText, richTextToHtml, richTextToMarkdown, richTextToPlainText, } from "./editor/index";
+export { createWebhooks, signatureHeader, signPayload, verifySignature, webhookRetryJob, } from "./webhooks/index";
+export { cmsScheduled, runDueJobs, startJobRunner, type JobRunnerHandle, type JobRunnerOptions, } from "./jobs/runner";
+export { expandRoles, grants, intersectPermissions, isValidScope, permissionFor, permits, scopePermissions, } from "./access/index";
+export { CmsConfigError, CmsError } from "./errors";
+export { isRtlLocale, localeName, localeRecords, LOCALE_NAMES, } from "./i18n/index";
+export { createId, createOrderedId } from "./ids";
+export { createCmsHttp, Router, type CmsHttp, type RouteRecord, } from "./http/index";
+export { applyFieldReadAccess, assertFieldWriteAccess, buildHookPipeline, cursorWhere, encodeCursor, globalRowId, hookPipelineEntries, listTrashed, localeContext, resolveLocalized, rowToDocument, scheduledPatch, scopedDb, toStoredData, validateFields, CmsEngine, EventBuffer, JobRunner, Outbox, RelationLoader, relationTarget, runAfterHooks, runBeforeHooks, type CollectionHookPipeline, type EngineOptions, type EventDispatch, type JobDefinition, type JobHost, type ListTrashedOptions, type LocaleContext, type ScheduledPatch, type WriteIntent, } from "./engine/index";
+export { collectMediaReferences, createMedia, mediaGcJob, prepareUpload, probeImage, referencesMedia, stripImageMetadata, syncMediaUsages, toMediaDocument, variantKey, variantTransform, type MediaGcContext, type MediaReference, type MediaServiceOptions, type PreparedUpload, } from "./media/index";
+export { parseByteSize, parseDuration } from "./duration";
+export { describePanel } from "./panel";
+export { buildSchemaSnapshot, documentsDataColumn, documentsTableName, emptySnapshot, planMigration, systemTableNames, systemTables, } from "./schema/index";
+export { defineField } from "./fields/registry";
+export type * from "./types/index";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,0BAA0B,EAC1B,gBAAgB,EAChB,YAAY,EACZ,OAAO,EACP,WAAW,GACZ,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,cAAc,EACd,WAAW,EACX,YAAY,EACZ,mBAAmB,GACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,aAAa,EACb,aAAa,EACb,qBAAqB,EACrB,qBAAqB,EACrB,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,cAAc,EACd,eAAe,EACf,WAAW,EACX,eAAe,EACf,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,YAAY,EACZ,UAAU,EACV,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,WAAW,EACX,MAAM,EACN,oBAAoB,EACpB,YAAY,EACZ,aAAa,EACb,OAAO,EACP,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,EACL,WAAW,EACX,UAAU,EACV,aAAa,EACb,YAAY,GACb,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,EACL,aAAa,EACb,MAAM,EACN,KAAK,OAAO,EACZ,KAAK,WAAW,GACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,QAAQ,EACR,YAAY,EACZ,cAAc,EACd,SAAS,EACT,WAAW,EACX,SAAS,EACT,MAAM,EACN,cAAc,EACd,cAAc,EACd,aAAa,EACb,cAAc,EACd,KAAK,sBAAsB,EAC3B,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,OAAO,EACZ,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,WAAW,GACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,sBAAsB,EACtB,WAAW,EACX,UAAU,EACV,aAAa,EACb,UAAU,EACV,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,eAAe,EACf,UAAU,EACV,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,cAAc,GACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,YAAY,GACb,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,mBAAmB,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+import{he,En}from"./index-g041kfa5.js";import{pe,Y,Le,me,fe,I}from"./index-8x2em6c8.js";import{It,Wn,E,rt,jt,Et,_e,C,fn,A,$e,Je,Ie}from"./index-sgdnp83t.js";import"./index-6m1kjq9g.js";import"./index-abfzb1ve.js";import{dt,je,He,Wt,ut,pt,mt,ft,vn,zt,ht,te,Ht,Bt,Vt,xn,Gt,Kt,Vn,Gn,Kn,yt}from"./index-cv0hpz3d.js";import{Se,jn,qe}from"./index-hpast878.js";import{V,J,Ee,bt,Be,F,Yt,Ge,An,Zt}from"./index-kc1j3h6z.js";import"./index-g4crf47y.js";import{ct,bn,wn}from"./index-a8jcwqsf.js";import{Ke,Rt}from"./index-6w10rch0.js";import{Ae,ke,Cn}from"./index-466cwb0b.js";import{en,tn,nn}from"./index-91fa1gzf.js";import{d}from"./index-9g2n7xa6.js";import{k,Z,Ot,rn,ao,lo,Te,Q,co,X,uo}from"./index-hbx67b20.js";import{ge,et,tt}from"./index-y8kzzn94.js";import{O}from"./index-67e458ws.js";import{Ce}from"./index-vzhxn50e.js";import{p,ln,Pt,_t}from"./index-s9x07zb3.js";import{nt,ot}from"./index-761dec5z.js";import"./index-2prbs05k.js";import{w,se}from"./index-rw0hze6x.js";import{b,ve}from"./index-8nzmqy0f.js";import{e,n}from"./index-x72d1hzh.js";export{n as CmsConfigError,ht as CmsEngine,e as CmsError,pt as EventBuffer,ut as JobRunner,Ht as LOCALE_NAMES,mt as Outbox,ft as RelationLoader,Se as Router,Le as aiActionsFor,fe as applyFieldReadAccess,I as assertFieldWriteAccess,dt as buildHookPipeline,Pt as buildSchemaSnapshot,wn as cmsScheduled,tn as collectMediaReferences,Rt as createAi,qe as createCmsHttp,b as createId,Zt as createMedia,ve as createOrderedId,Gt as createWebhooks,J as cursorWhere,et as defaultAdminPath,ge as defaultBasePath,tt as defaultMigrationsDirectory,pe as defineAiAction,Vn as defineCollection,Z as defineEditorMark,k as defineEditorNode,O as defineField,Gn as defineGlobal,Te as describeEditorSchema,jn as describePanel,ln as documentsDataColumn,p as documentsTableName,_t as emptySnapshot,V as encodeCursor,rt as expandRoles,Y as getAiAction,rn as getEditorMark,Ot as getEditorNode,te as globalRowId,Wn as grants,Kn as heyoCms,Wt as hookPipelineEntries,jt as intersectPermissions,Vt as isRtlLocale,_e as isValidScope,zt as listTrashed,C as localeContext,Bt as localeName,xn as localeRecords,Yt as mediaGcJob,se as parseByteSize,w as parseDuration,It as permissionFor,E as permits,Ke as piCompletion,Ce as planMigration,An as prepareUpload,Ee as probeImage,en as referencesMedia,me as registeredAiActions,lo as registeredEditorMarks,ao as registeredEditorNodes,vn as relationTarget,Q as renderRichText,fn as resolveLocalized,he as richTextFromMarkdown,En as richTextFromText,co as richTextToHtml,X as richTextToMarkdown,uo as richTextToPlainText,A as rowToDocument,He as runAfterHooks,je as runBeforeHooks,ct as runDueJobs,Ie as scheduledPatch,Et as scopePermissions,d as scopedDb,ke as signPayload,Ae as signatureHeader,bn as startJobRunner,Ge as stripImageMetadata,nn as syncMediaUsages,yt as systemActor,ot as systemTableNames,nt as systemTables,F as toMediaDocument,$e as toStoredData,Je as validateFields,Be as variantKey,bt as variantTransform,Cn as verifySignature,Kt as webhookRetryJob};

package/dist/jobs/runner.d.ts

@@ -0,0 +1,77 @@
+import type { Duration } from "../types/config";
+import type { CmsInstance } from "../types/instance";
+import type { JobRunArgs, JobRunReport } from "../types/jobs";
+/**
+ * Something has to call `cms.jobs.run()`.
+ *
+ * The package deliberately starts no timer of its own (stage 5): it has to
+ * load on Workers and on Lambda, where a `setInterval` either does nothing
+ * or keeps an invocation alive and bills for it. So the sweeps are a
+ * function, and this file is the two ways a deployment calls it — a timer
+ * for a process that has one, and a handler for a platform that owns the
+ * clock.
+ *
+ * Both do the same two things in the same order: run what is due, then drain
+ * the outbox. The second part is not optional on serverless, where the
+ * process freezes the moment the handler returns and anything still in the
+ * outbox waits for the next cron.
+ */
+export interface RunDueOptions extends JobRunArgs {
+    /** Delivers the events the sweep produced before returning. Default true. */
+    drainEvents?: boolean;
+}
+export declare function runDueJobs(cms: CmsInstance, options?: RunDueOptions): Promise<JobRunReport>;
+export interface JobRunnerOptions extends RunDueOptions {
+    cms: CmsInstance;
+    /** How often to sweep. Defaults to one minute. */
+    interval?: Duration | number;
+    /** Runs one sweep immediately instead of waiting for the first tick. */
+    immediate?: boolean;
+    onReport?: (report: JobRunReport) => void;
+    /**
+     * Called when a sweep throws.
+     *
+     * A sweep that throws is a database that is unreachable, not a job that
+     * failed — individual failures are recorded and counted inside the report.
+     * Default: log to `console.error`, because a background loop that swallows
+     * its own outage is worse than a noisy one.
+     */
+    onError?: (error: unknown) => void;
+    /** Stops the loop. The same signal a server shutdown already has. */
+    signal?: AbortSignal;
+}
+export interface JobRunnerHandle {
+    /** Runs one sweep now, outside the schedule. */
+    runNow(): Promise<JobRunReport>;
+    /** Stops the loop and waits for a sweep in flight. */
+    stop(): Promise<void>;
+    readonly running: boolean;
+}
+/**
+ * The Node and Bun answer: a timer that never overlaps itself.
+ *
+ * Overlap is the failure that matters here. A sweep that takes longer than
+ * the interval — a backlog of scheduled changes, a slow webhook endpoint —
+ * would otherwise start a second pass over the same rows, and every job in
+ * the product claims its row before acting precisely because that must stay
+ * harmless. Not starting the second pass is cheaper than relying on it.
+ */
+export declare function startJobRunner(options: JobRunnerOptions): JobRunnerHandle;
+/**
+ * The Workers answer: the platform owns the clock.
+ *
+ * ```ts
+ * export default {
+ *   fetch: (request) => cms.handler(request),
+ *   scheduled: cmsScheduled(cms),
+ * };
+ * ```
+ *
+ * `waitUntil` is used when the platform provides it, so the outbox drain is
+ * allowed to outlive the handler rather than being killed halfway through a
+ * webhook.
+ */
+export declare function cmsScheduled(cms: CmsInstance, options?: RunDueOptions): (event: unknown, env?: unknown, context?: {
+    waitUntil?: (promise: Promise<unknown>) => void;
+}) => Promise<void>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/jobs/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/jobs/runner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE9D;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C,6EAA6E;IAC7E,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,wBAAsB,UAAU,CAC9B,GAAG,EAAE,WAAW,EAChB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAKvB;AAED,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACrD,GAAG,EAAE,WAAW,CAAC;IACjB,kDAAkD;IAClD,QAAQ,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC7B,wEAAwE;IACxE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;IAC1C;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,qEAAqE;IACrE,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,gDAAgD;IAChD,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IAChC,sDAAsD;IACtD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,eAAe,CAqEzE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,WAAW,EAChB,OAAO,GAAE,aAAkB,GAC1B,CACD,KAAK,EAAE,OAAO,EACd,GAAG,CAAC,EAAE,OAAO,EACb,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAA;CAAE,KAC1D,OAAO,CAAC,IAAI,CAAC,CAMjB"}

package/dist/jobs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `@heyo-sh/heyo-cms/jobs`.
+ *
+ * The scheduled-change sweep, the trash purge, `media-gc` and the webhook
+ * retries all run from `cms.jobs.run()`. This entry point is how something
+ * calls it on a schedule: a timer in a long-lived process, or the platform's
+ * own cron on Workers and Vercel.
+ */
+export { cmsScheduled, runDueJobs, startJobRunner, type JobRunnerHandle, type JobRunnerOptions, type RunDueOptions, } from "./jobs/runner";
+export type { CmsJobs, JobFailure, JobResult, JobRunArgs, JobRunReport, } from "./types/jobs";
+//# sourceMappingURL=jobs.d.ts.map

package/dist/jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jobs.d.ts","sourceRoot":"","sources":["../src/jobs.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,YAAY,EACZ,UAAU,EACV,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,aAAa,GACnB,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,OAAO,EACP,UAAU,EACV,SAAS,EACT,UAAU,EACV,YAAY,GACb,MAAM,cAAc,CAAC"}

package/dist/jobs.js

@@ -0,0 +1 @@
+import{ct,bn,wn}from"./index-a8jcwqsf.js";export{wn as cmsScheduled,ct as runDueJobs,bn as startJobRunner};

package/dist/media/cloudflare.d.ts

@@ -0,0 +1,58 @@
+import type { ImageInfo, ImageProcessor, ImageTransform } from "../types/media";
+/** The Workers Images binding, structurally. Typing it avoids depending on the types. */
+export interface CloudflareImagesBinding {
+    input(image: ReadableStream<Uint8Array>): CloudflareImageTransformer;
+}
+export interface CloudflareImageTransformer {
+    transform(options: Record<string, unknown>): CloudflareImageTransformer;
+    output(options: Record<string, unknown>): Promise<CloudflareImageOutput>;
+}
+export interface CloudflareImageOutput {
+    contentType(): string;
+    image(): ReadableStream<Uint8Array>;
+}
+/**
+ * The binding, or where to get it.
+ *
+ * A function, usually: the processor is constructed while the configuration
+ * module loads, and on Workers the bindings only exist once a request (or the
+ * `cloudflare:workers` module) hands them over. Returning `undefined` is
+ * allowed — that is "this runtime has no binding", reported as an error only
+ * if something actually asks for pixels.
+ */
+export type CloudflareImagesSource = CloudflareImagesBinding | (() => CloudflareImagesBinding | undefined | Promise<CloudflareImagesBinding | undefined>);
+export declare function cloudflareImages(source: CloudflareImagesSource): ImageProcessor;
+export interface CloudflarePlan {
+    /** What to pass to `.transform()`, or null when only re-encoding. */
+    options: Record<string, unknown> | null;
+    /** The dimensions the output should have, for when the probe cannot say. */
+    width: number;
+    height: number;
+}
+/**
+ * One `ImageTransform`, translated into the binding's vocabulary.
+ *
+ * The crop and the focal point are resolved here rather than delegated:
+ * `sourceRegion` already turns both into a single rectangle of the original
+ * (the exact logic the sharp processor uses, tested in isolation), and that
+ * rectangle becomes a `trim`. It is sent as an origin and a size —
+ * `{ top, left, width, height }` — rather than as four margins: the size is
+ * what the rest of the plan is computed from, and stating it means the
+ * service cannot round its way to a rectangle one pixel off the one the
+ * dimensions were reported for.
+ *
+ * The fit names do not line up one to one, and two of them are false friends:
+ *
+ * | heyo-cms (sharp)       | Cloudflare       |
+ * | ---------------------- | ---------------- |
+ * | `inside` (default)     | `scale-down`     |
+ * | `contain` (letterbox)  | `pad`            |
+ * | `cover`                | `cover`, clamped |
+ * | `outside`              | computed + `scale-down` |
+ *
+ * `scale-down` never enlarges, which matches the `withoutEnlargement` the
+ * sharp processor always sets; `cover` would enlarge, so the requested box is
+ * shrunk to the source first — a 400px logo asked for at 1920 stays 400px.
+ */
+export declare function cloudflareTransform(info: ImageInfo, transform: ImageTransform): CloudflarePlan;
+//# sourceMappingURL=cloudflare.d.ts.map

package/dist/media/cloudflare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../src/media/cloudflare.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,SAAS,EACT,cAAc,EACd,cAAc,EAEf,MAAM,gBAAgB,CAAC;AAuCxB,yFAAyF;AACzF,MAAM,WAAW,uBAAuB;IACtC,KAAK,CAAC,KAAK,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,0BAA0B,CAAC;CACtE;AAED,MAAM,WAAW,0BAA0B;IACzC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,0BAA0B,CAAC;IACxE,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;CAC1E;AAED,MAAM,WAAW,qBAAqB;IACpC,WAAW,IAAI,MAAM,CAAC;IACtB,KAAK,IAAI,cAAc,CAAC,UAAU,CAAC,CAAC;CACrC;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,sBAAsB,GAC9B,uBAAuB,GACvB,CAAC,MACG,uBAAuB,GACvB,SAAS,GACT,OAAO,CAAC,uBAAuB,GAAG,SAAS,CAAC,CAAC,CAAC;AAEtD,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,sBAAsB,GAC7B,cAAc,CA+ChB;AAED,MAAM,WAAW,cAAc;IAC7B,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxC,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,cAAc,GACxB,cAAc,CAiEhB"}

package/dist/media/document.d.ts

@@ -0,0 +1,29 @@
+import type { JsonObject } from "../types/json";
+import type { MediaDocument } from "../types/media";
+import type { Row } from "../types/query";
+import type { StorageAdapter } from "../types/storage";
+/**
+ * Metadata keys the engine owns.
+ *
+ * The crop rectangle and the list of rendered sizes live inside the `metadata`
+ * column because they are per-file facts no index ever has to answer about,
+ * and two more columns on a system table is two more migrations for every
+ * deployment that will ever exist. They are hidden from
+ * `MediaDocument.metadata` and refused on write, so "your metadata" stays
+ * yours.
+ */
+export declare const reservedMetadata: readonly ["crop", "variants"];
+/**
+ * A `media` row as the rest of the world sees it.
+ *
+ * `url` is where the deployment serves the file: under `uploads.publicPath`
+ * when there is one, otherwise the adapter's public URL. Never a signed one:
+ * signing is cryptography, and making this asynchronous would charge every
+ * list of twenty-five files twenty-five signatures for a feature most
+ * deployments do not use. A private bucket signs at the moment of serving
+ * instead, which is what `cms.media.variant()` returns.
+ */
+export declare function toMediaDocument(row: Row, storage: StorageAdapter, publicPath?: string): MediaDocument;
+/** The document as an event payload: plain JSON, no behaviour, no aliasing. */
+export declare function mediaJson(media: MediaDocument): JsonObject;
+//# sourceMappingURL=document.d.ts.map

package/dist/media/document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../src/media/document.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,eAAe,CAAC;AAC3D,OAAO,KAAK,EAAwB,aAAa,EAAe,MAAM,gBAAgB,CAAC;AACvF,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,YAAI,MAAM,EAAE,UAAU,CAAU,CAAC;AAE9D;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,cAAc,EACvB,UAAU,CAAC,EAAE,MAAM,GAClB,aAAa,CAmCf;AAED,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,KAAK,EAAE,aAAa,GAAG,UAAU,CAE1D"}

package/dist/media/gc.d.ts

@@ -0,0 +1,46 @@
+import type { JobDefinition } from "../engine/jobs";
+import type { BufferedEvent, OutboxEntryMeta } from "../engine/outbox";
+import type { ResolvedCmsConfig, UploadsConfig } from "../types/config";
+import type { DatabaseAdapter } from "../types/database";
+import type { MediaCollectArgs, MediaCollectReport, MediaDocument } from "../types/media";
+import type { Row, Tx } from "../types/query";
+import type { StorageAdapter } from "../types/storage";
+export interface MediaGcContext {
+    config: ResolvedCmsConfig;
+    database: () => Promise<DatabaseAdapter>;
+    storage: () => Promise<StorageAdapter>;
+    emit: (tx: Tx, events: BufferedEvent[], meta: OutboxEntryMeta) => Promise<void>;
+    deliver: () => void;
+}
+/** Files whose grace period has run out, oldest obligation first. */
+export declare function dueMedia(context: MediaGcContext, now: Date, limit: number): Promise<Row[]>;
+export declare function collectMedia(context: MediaGcContext, args?: MediaCollectArgs): Promise<MediaCollectReport>;
+export type CollectOutcome = "purged" | "reclaimed" | "taken";
+/**
+ * Takes one file, or discovers it should not be taken.
+ *
+ * The status change is a conditional update — the same portable claim the
+ * outbox and the scheduler use — so two collectors running at once cannot
+ * both delete the same object, on any of the three engines and without a
+ * lock.
+ */
+export declare function collectOne(context: MediaGcContext, row: Row, now: Date): Promise<CollectOutcome>;
+/**
+ * The sweep, as the job registry sees it.
+ *
+ * Registered next to `scheduled-changes` and `trash-purge` rather than run on
+ * a timer of its own: the deployment decides what calls `cms.jobs.run()`,
+ * because the package does not know whether it is in a process that has
+ * timers (stage 5).
+ */
+export declare function mediaGcJob(context: MediaGcContext): JobDefinition;
+/**
+ * Every object this file owns: the original and every size rendered from it.
+ *
+ * The recorded list plus the declared one. A size removed from the
+ * configuration still has objects in the bucket, and a size added since the
+ * last render has none but costs nothing to ask about — and a leaked
+ * derivative is a file nobody will ever find again.
+ */
+export declare function storageKeysOf(media: MediaDocument, uploads: UploadsConfig | undefined): string[];
+//# sourceMappingURL=gc.d.ts.map

package/dist/media/gc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gc.d.ts","sourceRoot":"","sources":["../../src/media/gc.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGzD,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,aAAa,EACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAmBvD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,MAAM,OAAO,CAAC,eAAe,CAAC,CAAC;IACzC,OAAO,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,CAAC;IACvC,IAAI,EAAE,CACJ,EAAE,EAAE,EAAE,EACN,MAAM,EAAE,aAAa,EAAE,EACvB,IAAI,EAAE,eAAe,KAClB,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,qEAAqE;AACrE,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,cAAc,EACvB,GAAG,EAAE,IAAI,EACT,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,GAAG,EAAE,CAAC,CAqBhB;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,IAAI,GAAE,gBAAqB,GAC1B,OAAO,CAAC,kBAAkB,CAAC,CAyB7B;AAED,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,WAAW,GAAG,OAAO,CAAC;AAE9D;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,cAAc,EACvB,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,IAAI,GACR,OAAO,CAAC,cAAc,CAAC,CAyDzB;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,aAAa,CAcjE;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,aAAa,GAAG,SAAS,GACjC,MAAM,EAAE,CASV"}

package/dist/media/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Media: storage, processing and the lifecycle.
+ *
+ * Three separate concerns that only make sense together. Storage is where the
+ * bytes live; processing is what happens to them on the way in and on the way
+ * out; the lifecycle is the reference counting that lets a file be removed
+ * from a page without being destroyed (section 6).
+ *
+ * Nothing here is HTTP-aware. The routes in stage 7 and the library screen in
+ * stage 8 call exactly these functions.
+ */
+export { mediaJson, reservedMetadata, toMediaDocument } from "./document";
+export { collectMedia, collectOne, dueMedia, mediaGcJob, storageKeysOf, type CollectOutcome, type MediaGcContext, } from "./gc";
+export { matchesMime, prepareUpload, sanitiseFilename, type PrepareUploadOptions, type PreparedUpload, } from "./pipeline";
+export { extensionFor, imageContentType, probeImage } from "./probe";
+export { createMedia, type MediaServiceOptions } from "./service";
+export { stripImageMetadata } from "./strip";
+export { collectMediaReferences, mediaTable, mediaUsagesTable, purgeDeadline, referencesMedia, richTextMediaAttribute, syncMediaUsages, type MediaReference, type SyncMediaUsagesOptions, type SyncMediaUsagesResult, } from "./usages";
+export { renderVariant, variantContentType, variantKey, variantNames, variantQuery, variantSize, variantTransform, } from "./variants";
+//# sourceMappingURL=index.d.ts.map

package/dist/media/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/media/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,EACL,YAAY,EACZ,UAAU,EACV,QAAQ,EACR,UAAU,EACV,aAAa,EACb,KAAK,cAAc,EACnB,KAAK,cAAc,GACpB,MAAM,MAAM,CAAC;AACd,OAAO,EACL,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,KAAK,oBAAoB,EACzB,KAAK,cAAc,GACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EACL,sBAAsB,EACtB,UAAU,EACV,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,sBAAsB,EACtB,eAAe,EACf,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,GAC3B,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,gBAAgB,GACjB,MAAM,YAAY,CAAC"}

package/dist/media/pipeline.d.ts

@@ -0,0 +1,55 @@
+import type { UploadsConfig } from "../types/config";
+import type { ImageInfo } from "../types/media";
+/**
+ * What happens between "here is a file" and "it is in the bucket".
+ *
+ * Validate, identify, shrink, strip, fingerprint — in that order, and all of
+ * it before a single byte reaches storage. Doing any of it afterwards would
+ * mean a rejected upload still costs a write, and a downscale that failed
+ * would leave the original in the bucket forever.
+ */
+export interface PreparedUpload {
+    data: Uint8Array;
+    contentType: string;
+    filename: string;
+    /** Null for anything that is not an image we can read. */
+    info: ImageInfo | null;
+    checksum: string;
+    extension: string;
+    /**
+     * Why the configured processing did not happen, when it failed.
+     *
+     * Null when it ran, or when there was nothing to run. Set when the
+     * processor threw and the original was stored instead (see
+     * `renderOriginal`): the upload succeeds, and the caller reports this as
+     * `media.processing.failed` so somebody can notice.
+     */
+    processingError: string | null;
+}
+export interface PrepareUploadOptions {
+    bytes: Uint8Array;
+    filename: string;
+    /** What the client claimed. Overruled by the bytes when they disagree. */
+    contentType: string;
+    uploads: UploadsConfig;
+}
+export declare function prepareUpload(options: PrepareUploadOptions): Promise<PreparedUpload>;
+/**
+ * A processor that cannot run at all, as opposed to one that failed once.
+ *
+ * `image_processor_missing` is a deployment mistake — no binding, no `sharp`
+ * installed — and degrading to the original would hide it until somebody
+ * wondered, months later, why nothing was ever converted. Every other error
+ * is the kind that goes away on its own.
+ */
+export declare function isProcessorMisconfigured(error: unknown): boolean;
+export declare function describeError(error: unknown): string;
+export declare function matchesMime(contentType: string, pattern: string): boolean;
+/**
+ * A filename that is safe to show, log and put in a header.
+ *
+ * It is never used to build a storage key — those are derived from the id —
+ * so this is about display and `content-disposition`, not about traversal.
+ */
+export declare function sanitiseFilename(filename: string): string;
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/media/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/media/pipeline.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAgB,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,gBAAgB,CAAC;AAIhE;;;;;;;GAOG;AAEH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;OAOG;IACH,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,aAAa,CAAC;CACxB;AAED,wBAAsB,aAAa,CACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,cAAc,CAAC,CAgEzB;AAwGD;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEhE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAUpD;AAoBD,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAMzE;AAWD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAOzD"}

package/dist/media/probe.d.ts

@@ -0,0 +1,6 @@
+import type { ImageFormat, ImageInfo } from "../types/media";
+export declare function imageContentType(format: ImageFormat): string;
+export declare function probeImage(bytes: Uint8Array): ImageInfo | null;
+/** The extension a stored object should carry for a content type. */
+export declare function extensionFor(contentType: string): string;
+//# sourceMappingURL=probe.d.ts.map

package/dist/media/probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe.d.ts","sourceRoot":"","sources":["../../src/media/probe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAyB7D,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAE5D;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,IAAI,CAS9D;AAED,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAuBxD"}

package/dist/media/service.d.ts

@@ -0,0 +1,26 @@
+import type { BufferedEvent, OutboxEntryMeta } from "../engine/outbox";
+import type { ResolvedCmsConfig } from "../types/config";
+import type { DatabaseAdapter } from "../types/database";
+import type { CmsMedia } from "../types/media";
+import type { Tx } from "../types/query";
+export interface MediaServiceOptions {
+    config: ResolvedCmsConfig;
+    database: () => Promise<DatabaseAdapter>;
+    /** Appends events to the outbox inside the caller's transaction. */
+    emit: (tx: Tx, events: BufferedEvent[], meta: OutboxEntryMeta) => Promise<void>;
+    /** Schedules delivery once the transaction has committed. */
+    deliver: () => void;
+}
+/**
+ * `cms.media`.
+ *
+ * Media is a high-level setting rather than a plugin (section 3), and a file
+ * is not a document: it has a lifecycle no document has — active, orphaned,
+ * collected — and a body that lives somewhere the database cannot see. Hence
+ * its own service, with the same rule as `cms.api`: everything is a method
+ * rather than a route, so the REST endpoints in stage 7, the panel in stage 8
+ * and a seed script all get identical behaviour, including the parts that are
+ * easy to get wrong.
+ */
+export declare function createMedia(options: MediaServiceOptions): CmsMedia;
+//# sourceMappingURL=service.d.ts.map

package/dist/media/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/media/service.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAQvE,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGzD,OAAO,KAAK,EACV,QAAQ,EAiBT,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAO,EAAE,EAAS,MAAM,gBAAgB,CAAC;AA4BrD,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,MAAM,OAAO,CAAC,eAAe,CAAC,CAAC;IACzC,oEAAoE;IACpE,IAAI,EAAE,CACJ,EAAE,EAAE,EAAE,EACN,MAAM,EAAE,aAAa,EAAE,EACvB,IAAI,EAAE,eAAe,KAClB,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,6DAA6D;IAC7D,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,mBAAmB,GAAG,QAAQ,CA8uBlE"}

package/dist/media/sharp.d.ts

@@ -0,0 +1,28 @@
+import type { ImageProcessor, ImageTransform } from "../types/media";
+export interface SharpImagesOptions {
+    /**
+     * The decompression-bomb ceiling, in pixels.
+     *
+     * `sharp` defaults to roughly 268 megapixels. The upload pipeline already
+     * refuses anything over `uploads.limits.maxImageDimensions`, so this is the
+     * second fence rather than the first.
+     */
+    limitInputPixels?: number | false;
+    /**
+     * Honour the EXIF orientation flag before doing anything else.
+     *
+     * On by default, and it matters: a phone photograph is stored sideways with
+     * a flag saying so, and stripping metadata without applying the flag first
+     * turns every portrait into a landscape.
+     */
+    autoOrient?: boolean;
+}
+export declare function sharpImages(options?: SharpImagesOptions): ImageProcessor;
+/** The rectangle of the source that a cover crop should keep. */
+export declare function sourceRegion(width: number, height: number, transform: ImageTransform): {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+} | null;
+//# sourceMappingURL=sharp.d.ts.map

package/dist/media/sharp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sharp.d.ts","sourceRoot":"","sources":["../../src/media/sharp.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,cAAc,EACd,cAAc,EAEf,MAAM,gBAAgB,CAAC;AAwBxB,MAAM,WAAW,kBAAkB;IACjC;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAClC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AA8CD,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,cAAc,CA6D5E;AAED,iEAAiE;AACjE,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,cAAc,GACxB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA0BrE"}

package/dist/media/strip.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Metadata removal, without a decoder.
+ *
+ * `stripMetadata` exists for one concrete reason: a photograph taken on a
+ * phone carries the coordinates of the place it was taken, and a CMS that
+ * publishes it publishes those too (section 6). That is a privacy obligation,
+ * not an optimisation, so it must not depend on whether an optional image
+ * processor happens to be installed — which is why it is implemented here, by
+ * dropping container chunks rather than by re-encoding pixels.
+ *
+ * ICC colour profiles are deliberately kept. Dropping them is what most tools
+ * do under "strip metadata", and it visibly shifts the colours of every
+ * wide-gamut photograph, which is not what anybody asking for privacy meant.
+ */
+export declare function stripImageMetadata(bytes: Uint8Array, contentType: string): Uint8Array;
+//# sourceMappingURL=strip.d.ts.map

package/dist/media/strip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip.d.ts","sourceRoot":"","sources":["../../src/media/strip.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,UAAU,EACjB,WAAW,EAAE,MAAM,GAClB,UAAU,CAaZ"}

package/dist/media/urls.d.ts

@@ -0,0 +1,77 @@
+import type { ImagesConfig, ResolvedCmsConfig } from "../types/config";
+import type { MediaDocument, MediaImage, MediaImageInput, MediaImageOptions, MediaSrcsetOptions, MediaUrlInput, MediaUrlOptions } from "../types/media";
+/**
+ * Where a file is served from, and what an `<img>` needs to show it well.
+ *
+ * Everything here is arithmetic on the configuration and the `media` row: no
+ * storage call, no rendering, no database. That is what lets a page with
+ * forty pictures build forty `srcset`s without forty round trips — the sizes
+ * a variant *will* have are known before it has ever been rendered, because
+ * the processors never enlarge and the fits are deterministic.
+ */
+/**
+ * The file name in a public URL: the uploaded name, as a slug, with the
+ * extension of what is actually served.
+ *
+ * Only for people and image search, which reads it; the route ignores it.
+ * The extension follows the content type rather than the upload, so a PNG
+ * converted to WebP is `diagram.webp` and not a `.png` that is not one.
+ */
+export declare function publicFileName(media: Pick<MediaDocument, "filename">, contentType: string): string;
+/**
+ * The address of the original under `uploads.publicPath`, or null without one.
+ *
+ * Kept separate from `mediaUrl` because `toMediaDocument` needs it and has no
+ * use for the rest: `MediaDocument.url` is this, when the deployment serves
+ * its own files.
+ */
+export declare function publicOriginalUrl(publicPath: string | undefined, media: Pick<MediaDocument, "id" | "filename" | "mimeType">): string | null;
+/**
+ * `cms.media.url()`.
+ *
+ * With `uploads.publicPath`:
+ *
+ *   /media/med_…/condition-report.png             the original
+ *   /media/med_…/card/condition-report.webp       a declared size
+ *
+ * Without it, the CMS's own API route, `<basePath>/media/med_…/card`. A size
+ * nothing here can render — no processor, or an SVG — is the original's URL
+ * with the size in the query, which is what an image CDN in front of the
+ * deployment reads. A size that would not change the picture is the
+ * original's URL outright, so the browser reuses what it already has.
+ */
+export declare function mediaUrl(config: ResolvedCmsConfig, media: MediaUrlInput, options?: MediaUrlOptions): string;
+/**
+ * The pixel size a named size will have for this file, before it exists.
+ *
+ * The same arithmetic the processors perform: the crop first, then the fit,
+ * never enlarging. Null when the file has no known dimensions (not an image,
+ * or one whose header could not be read).
+ */
+export declare function variantDimensions(images: ImagesConfig | undefined, name: string, media: Pick<MediaUrlInput, "width" | "height" | "crop">): {
+    width: number;
+    height: number;
+} | null;
+/**
+ * `cms.media.srcset()`: the declared sizes that keep the picture's shape, as
+ * a width-descriptor list, with the original at the top end.
+ *
+ * Only sizes that do not change the aspect ratio belong in one `srcset` —
+ * the browser assumes every candidate is the same picture — so a `cover`
+ * square is left out unless asked for by name. Sizes the file is too small
+ * for collapse into the original. With a crop the original is not the same
+ * picture as its sizes, so it is left out and the largest size tops the list.
+ *
+ * Null when there is nothing to choose between: a vector, a file with no
+ * known width, or a configuration without sizes.
+ */
+export declare function mediaSrcset(config: ResolvedCmsConfig, media: MediaUrlInput, options?: MediaSrcsetOptions): string | null;
+/**
+ * `cms.media.image()`: everything an `<img>` needs for one file.
+ *
+ * Width and height are always the ones of the `src` — that is what the
+ * browser reserves space with before a byte arrives, and a wrong ratio there
+ * is the layout shift it exists to prevent.
+ */
+export declare function mediaImage(config: ResolvedCmsConfig, media: MediaImageInput, options?: MediaImageOptions): MediaImage;
+//# sourceMappingURL=urls.d.ts.map

package/dist/media/urls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"urls.d.ts","sourceRoot":"","sources":["../../src/media/urls.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACvE,OAAO,KAAK,EACV,aAAa,EACb,UAAU,EACV,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,eAAe,EAChB,MAAM,gBAAgB,CAAC;AAUxB;;;;;;;;GAQG;AAEH;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,EACtC,WAAW,EAAE,MAAM,GAClB,MAAM,CAGR;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,GAAG,UAAU,GAAG,UAAU,CAAC,GACzD,MAAM,GAAG,IAAI,CAGf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,iBAAiB,EACzB,KAAK,EAAE,aAAa,EACpB,OAAO,GAAE,eAAoB,GAC5B,MAAM,CAmCR;AAOD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,GAAG,SAAS,EAChC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC,GACtD;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA6C1C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,iBAAiB,EACzB,KAAK,EAAE,aAAa,EACpB,OAAO,GAAE,kBAAuB,GAC/B,MAAM,GAAG,IAAI,CAKf;AA4CD;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,iBAAiB,EACzB,KAAK,EAAE,eAAe,EACtB,OAAO,GAAE,iBAAsB,GAC9B,UAAU,CAqCZ"}