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

package/dist/schema/snapshot.d.ts

@@ -0,0 +1,24 @@
+import type { ResolvedCollection } from "../types/config";
+import type { SchemaSnapshot, TableSnapshot } from "../types/schema";
+/** The table every user-declared collection and global is stored in. */
+export declare const documentsTableName = "documents";
+export declare const documentsDataColumn = "data";
+export interface SnapshotInput {
+    collections: Record<string, ResolvedCollection>;
+    globals: Record<string, ResolvedCollection>;
+    /** Tables contributed by plugins (`CmsPlugin.schema.tables`). */
+    pluginTables?: TableSnapshot[];
+}
+/**
+ * Builds the schema a configuration implies.
+ *
+ * Pure: the same configuration always produces the same snapshot, down to the
+ * ordering of columns and indexes. `generate` diffs two of these and nothing
+ * else, which is what makes a migration reviewable before any database is
+ * involved.
+ */
+export declare function buildSchemaSnapshot(input: SnapshotInput): SchemaSnapshot;
+/** Whether any collection keeps previous slugs, and so needs `slug_history`. */
+export declare function keepsSlugHistory(collections: Iterable<ResolvedCollection>): boolean;
+export declare function emptySnapshot(): SchemaSnapshot;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/schema/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/schema/snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAG1D,OAAO,KAAK,EAIV,cAAc,EACd,aAAa,EACd,MAAM,iBAAiB,CAAC;AAGzB,wEAAwE;AACxE,eAAO,MAAM,kBAAkB,cAAc,CAAC;AAC9C,eAAO,MAAM,mBAAmB,SAAS,CAAC;AAE1C,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAChD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC5C,iEAAiE;IACjE,YAAY,CAAC,EAAE,aAAa,EAAE,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,GAAG,cAAc,CA0BxE;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GACxC,OAAO,CAOT;AAED,wBAAgB,aAAa,IAAI,cAAc,CAE9C"}

package/dist/schema/system.d.ts

@@ -0,0 +1,31 @@
+import type { TableSnapshot } from "../types/schema";
+/**
+ * The journal.
+ *
+ * Owned by the adapter rather than by the schema: it has to exist before the
+ * first migration runs, so it can never be the product of one. `introspect()`
+ * ignores it for the same reason.
+ */
+export declare const migrationsTable = "cms_migrations";
+/**
+ * Every table the engine owns.
+ *
+ * One `documents` table holds all content: a table per collection would turn
+ * "add a field" into DDL and "add a locale" into a migration, which is exactly
+ * what the document model avoids (section 12). Everything else here is
+ * machinery — auth, media, delivery, scheduling — and is queried by the engine
+ * itself, so it gets real columns.
+ */
+export declare function systemTables(): TableSnapshot[];
+/** Names the engine reserves; a collection cannot take one of them. */
+export declare function systemTableNames(): string[];
+/**
+ * Previous addresses of documents, for `slug({ history: true })`.
+ *
+ * Not in `systemTables()`: only a configuration that keeps slug history gets
+ * it, so every other project's next migration stays empty. One row per
+ * address a document used to have; the unique index is the rule that an
+ * address leads to one place.
+ */
+export declare function slugHistoryTableSnapshot(): TableSnapshot;
+//# sourceMappingURL=system.d.ts.map

package/dist/schema/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/schema/system.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAMV,aAAa,EACd,MAAM,iBAAiB,CAAC;AAGzB;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,mBAAmB,CAAC;AA0EhD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,IAAI,aAAa,EAAE,CAoB9C;AAED,uEAAuE;AACvE,wBAAgB,gBAAgB,IAAI,MAAM,EAAE,CAQ3C;AAID;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,IAAI,aAAa,CAsBxD"}

package/dist/schema.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The schema layer: system tables, the snapshot a configuration implies, and
+ * the deterministic diff between two snapshots. No SQL lives here — steps are
+ * neutral and every engine renders them itself (section 12).
+ */
+export * from "./schema/index";
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,cAAc,gBAAgB,CAAC"}

package/dist/schema.js

@@ -0,0 +1 @@
+import{Ce,Ue,Oe,Fn}from"./index-vzhxn50e.js";import{p,ln,Pt,_t}from"./index-s9x07zb3.js";import{z,nt,ot}from"./index-761dec5z.js";export{Pt as buildSchemaSnapshot,Oe as describeStep,ln as documentsDataColumn,p as documentsTableName,_t as emptySnapshot,Fn as migrationName,z as migrationsTable,Ce as planMigration,Ue as stableStringify,ot as systemTableNames,nt as systemTables};

package/dist/slugify.d.ts

@@ -0,0 +1,31 @@
+/**
+ * URL slugs, in every script a CMS is likely to be written in.
+ *
+ * ASCII on purpose: an ASCII slug survives being pasted into a chat or an
+ * e-mail, never turns into `%D0%B1…` in a link, and reads the same in every
+ * browser. Unicode normalisation takes care of the accents it can decompose
+ * (é, ü, ç, ą…); the letters it cannot (ł, ß, ø…) and the Cyrillic and Greek
+ * alphabets are transliterated from the tables below. A character with no
+ * transliteration is dropped rather than percent-encoded, which is why a
+ * title written entirely in such a script produces an empty slug — the
+ * caller decides what to do then, usually by falling back to the id.
+ */
+/** What a slug looks like: lowercase ASCII words joined by single hyphens. */
+export declare const slugPattern = "^[a-z0-9]+(?:-[a-z0-9]+)*$";
+export declare function isSlug(value: string): boolean;
+export interface SlugifyOptions {
+    /**
+     * The longest slug produced. Longer input is cut at the last hyphen that
+     * keeps at least half of it, so a slug never ends in the middle of a word.
+     */
+    maxLength?: number;
+}
+/**
+ * Turns any text into a slug: `"Łódź & Kraków — 2024"` → `"lodz-krakow-2024"`.
+ *
+ * Idempotent: a slug passed through it comes back unchanged, which is what
+ * lets the engine run every incoming slug through it without second-guessing
+ * one an editor typed on purpose.
+ */
+export declare function slugify(input: string, options?: SlugifyOptions): string;
+//# sourceMappingURL=slugify.d.ts.map

package/dist/slugify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slugify.d.ts","sourceRoot":"","sources":["../src/slugify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AA6FH,8EAA8E;AAC9E,eAAO,MAAM,WAAW,+BAA+B,CAAC;AAIxD,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,MAAM,CA2B3E"}

package/dist/storage/bytes.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Byte plumbing shared by every storage adapter.
+ *
+ * Kept in one place because the conversions are exactly the kind of thing that
+ * grows a subtly different copy in each adapter — one that forgets a chunk
+ * boundary, or that assumes `Buffer` and therefore excludes Workers.
+ */
+/** Collects whatever a caller handed us into one contiguous buffer. */
+export declare function toBytes(body: ReadableStream | Uint8Array | ArrayBuffer | Blob): Promise<Uint8Array>;
+export declare function concat(chunks: Uint8Array[]): Uint8Array;
+/** A one-shot stream over bytes already in memory. */
+export declare function streamOf(bytes: Uint8Array): ReadableStream<Uint8Array>;
+export declare function hex(bytes: Uint8Array): string;
+/** base64 without `Buffer`, because the core also runs on Workers. */
+export declare function base64(bytes: Uint8Array): string;
+export declare function sha256(data: Uint8Array | string): Promise<Uint8Array>;
+//# sourceMappingURL=bytes.d.ts.map

package/dist/storage/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../src/storage/bytes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,uEAAuE;AACvE,wBAAsB,OAAO,CAC3B,IAAI,EAAE,cAAc,GAAG,UAAU,GAAG,WAAW,GAAG,IAAI,GACrD,OAAO,CAAC,UAAU,CAAC,CAerB;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,UAAU,CAUvD;AAED,sDAAsD;AACtD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,cAAc,CAAC,UAAU,CAAC,CAOtE;AAED,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAI7C;AAED,sEAAsE;AACtE,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAIhD;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAO3E"}

package/dist/storage/http.d.ts

@@ -0,0 +1,43 @@
+import type { SignedUrlOptions, StorageAdapter } from "../types/storage";
+/**
+ * The shape of every object store we reach over HTTP.
+ *
+ * S3, R2, GCS and Azure differ in how a request is signed and in where the
+ * bucket name goes. They do not differ in what PUT, GET, DELETE and HEAD mean,
+ * so that part is written once here and each adapter supplies the two
+ * functions that are actually its own.
+ */
+export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export interface SignableRequest {
+    method: string;
+    url: URL;
+    headers: Record<string, string>;
+    payload: Uint8Array | "UNSIGNED-PAYLOAD";
+    contentLength: number;
+}
+export interface HttpStorageOptions {
+    id: string;
+    /** Where the bytes actually live, including credentials-bearing hosts. */
+    endpoint(key: string): URL;
+    sign(request: SignableRequest): Promise<Record<string, string>>;
+    /** What a browser should be given; a CDN domain when one is configured. */
+    publicUrl(key: string): string;
+    /** Produces a time-limited URL. Absent when the adapter cannot sign one. */
+    signedUrl?(key: string, options: SignedUrlOptions | undefined): Promise<string>;
+    prefix?: (file: {
+        id: string;
+        filename: string;
+    }) => string;
+    fetch?: FetchLike;
+    /** Headers every request carries, such as a storage class or an ACL. */
+    defaultHeaders?: Record<string, string>;
+}
+export declare function httpStorage(options: HttpStorageOptions): StorageAdapter;
+/**
+ * Every segment encoded, slashes kept.
+ *
+ * Object keys are not URL paths: `a b/c.png` is one perfectly ordinary key and
+ * has to survive the round trip to the same bytes it went in as.
+ */
+export declare function encodeKey(key: string): string;
+//# sourceMappingURL=http.d.ts.map

package/dist/storage/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/storage/http.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,gBAAgB,EAChB,cAAc,EAEf,MAAM,kBAAkB,CAAC;AAG1B;;;;;;;GAOG;AAEH,MAAM,MAAM,SAAS,GAAG,CACtB,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAC7B,IAAI,CAAC,EAAE,WAAW,KACf,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEvB,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,OAAO,EAAE,UAAU,GAAG,kBAAkB,CAAC;IACzC,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,0EAA0E;IAC1E,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IAC3B,IAAI,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChE,2EAA2E;IAC3E,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,4EAA4E;IAC5E,SAAS,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAChF,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM,CAAC;IAC5D,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,wEAAwE;IACxE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,cAAc,CAsGvE;AAiBD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK7C"}

package/dist/storage/local.d.ts

@@ -0,0 +1,31 @@
+import type { StorageAdapter } from "../types/storage";
+export interface MemoryStorageOptions {
+    baseUrl?: string;
+}
+/**
+ * In-process storage.
+ *
+ * Exported rather than kept in the test folder on purpose: the storage
+ * contract suite has to run against something, and an example that boots
+ * without a bucket is worth more than a mock nobody else can use.
+ */
+export declare function memory(options?: MemoryStorageOptions): StorageAdapter;
+export interface LocalStorageOptions {
+    /** Directory on disk. Created on first write. */
+    directory: string;
+    /** Public prefix the files are served from. */
+    baseUrl?: string;
+    prefix?: (file: {
+        id: string;
+        filename: string;
+    }) => string;
+}
+/**
+ * Local disk.
+ *
+ * `node:fs` is imported inside the methods, not at the top of the module: a
+ * Worker bundle that merely configures storage must not drag a filesystem
+ * into a runtime that has none.
+ */
+export declare function local(options: LocalStorageOptions): StorageAdapter;
+//# sourceMappingURL=local.d.ts.map

package/dist/storage/local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../../src/storage/local.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,cAAc,EAEf,MAAM,kBAAkB,CAAC;AAiB1B,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,OAAO,GAAE,oBAAyB,GAAG,cAAc,CAmCzE;AAED,MAAM,WAAW,mBAAmB;IAClC,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM,CAAC;CAC7D;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,mBAAmB,GAAG,cAAc,CA6DlE"}

package/dist/storage/providers.d.ts

@@ -0,0 +1,95 @@
+import type { StorageAdapterFactory } from "../types/storage";
+import { type FetchLike } from "./http";
+export interface S3StorageOptions {
+    bucket: string;
+    region?: string;
+    /** Set for an S3-compatible service: MinIO, Tigris, Wasabi, Ceph. */
+    endpoint?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+    acl?: "private" | "public-read";
+    signedUrls?: {
+        enabled: boolean;
+        expiresIn?: string;
+    };
+    /** Serve from a CDN while writing straight to the bucket. */
+    publicUrl?: string;
+    /** Where new objects go, given the file. Defaults to `{year}/{id}`. */
+    prefix?: (file: {
+        id: string;
+        filename: string;
+    }) => string;
+    /** Path-style addressing. Forced on when an `endpoint` is given. */
+    forcePathStyle?: boolean;
+    fetch?: FetchLike;
+}
+/**
+ * S3 and everything that speaks its API.
+ *
+ * Credentials are read from the environment when they are not given, which is
+ * what makes an IAM role or a `~/.aws` profile work without naming a secret in
+ * a file that is checked in.
+ */
+export declare function s3(options: S3StorageOptions): StorageAdapterFactory;
+export interface R2StorageOptions extends Omit<S3StorageOptions, "region" | "endpoint"> {
+    /** From the Cloudflare dashboard. Not needed when a binding is passed. */
+    accountId?: string;
+}
+/** A Workers R2 binding, structurally. Typing it avoids depending on the types. */
+export interface R2Binding {
+    put(key: string, value: unknown, options?: unknown): Promise<unknown>;
+    get(key: string): Promise<R2ObjectBody | null>;
+    delete(keys: string | string[]): Promise<void>;
+    head(key: string): Promise<R2ObjectLike | null>;
+}
+interface R2ObjectLike {
+    size: number;
+    uploaded?: Date;
+    httpMetadata?: {
+        contentType?: string;
+    };
+}
+interface R2ObjectBody extends R2ObjectLike {
+    body: ReadableStream;
+}
+/**
+ * Cloudflare R2, either way round.
+ *
+ * Given a binding it uses the binding, which costs nothing and leaves the
+ * Worker's own network. Given credentials it speaks S3 over HTTPS, which is
+ * what a Node process or a build script has to do.
+ */
+export declare function r2(binding: R2Binding | (R2StorageOptions & {
+    bucket: string;
+})): StorageAdapterFactory;
+export interface GcsStorageOptions extends Omit<S3StorageOptions, "endpoint" | "forcePathStyle"> {
+    /** An HMAC key from Cloud Storage interoperability settings. */
+    accessKeyId?: string;
+    secretAccessKey?: string;
+}
+/**
+ * Google Cloud Storage, through its S3-compatible XML endpoint.
+ *
+ * Interoperability mode rather than the JSON API because it needs an HMAC key
+ * pair and nothing else: the JSON API wants a service-account JWT, which means
+ * RSA signing, key rotation and a JSON file on disk, for the same four verbs.
+ */
+export declare function gcs(options: GcsStorageOptions): StorageAdapterFactory;
+export interface AzureStorageOptions {
+    /** The storage account name, not its URL. */
+    account: string;
+    container: string;
+    /** The account key. Falls back to `AZURE_STORAGE_KEY`. */
+    accountKey?: string;
+    publicUrl?: string;
+    prefix?: (file: {
+        id: string;
+        filename: string;
+    }) => string;
+    fetch?: FetchLike;
+}
+/** Azure Blob Storage, signed with a shared key. */
+export declare function azure(options: AzureStorageOptions): StorageAdapterFactory;
+export {};
+//# sourceMappingURL=providers.d.ts.map

package/dist/storage/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/storage/providers.ts"],"names":[],"mappings":"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"}

package/dist/storage/sign.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Request signing for the object stores we speak to over HTTP.
+ *
+ * Written out rather than taken from an SDK on purpose. `@aws-sdk/client-s3`
+ * is roughly twenty megabytes of dependency for four HTTP verbs, which is the
+ * entire installation budget this project set itself (section 0), and it does
+ * not run unchanged on every runtime we target. Signing is about ninety lines
+ * when the only operations are PUT, GET, DELETE and HEAD.
+ */
+export interface AwsCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    /** Set when the credentials come from an assumed role. */
+    sessionToken?: string;
+}
+export interface AwsSignRequest {
+    method: string;
+    url: URL;
+    headers: Record<string, string>;
+    /** `UNSIGNED-PAYLOAD` is legal over TLS and avoids buffering a stream. */
+    payload: Uint8Array | "UNSIGNED-PAYLOAD";
+    region: string;
+    service: string;
+    credentials: AwsCredentials;
+    now?: Date;
+}
+/**
+ * AWS Signature Version 4.
+ *
+ * Used for S3, for R2 (which speaks the S3 API) and for Google Cloud Storage
+ * through its S3-compatible XML endpoint, so one implementation covers three
+ * of the five adapters.
+ */
+export declare function signAwsV4(request: AwsSignRequest): Promise<Record<string, string>>;
+export interface AzureSignRequest {
+    method: string;
+    url: URL;
+    headers: Record<string, string>;
+    account: string;
+    /** The base64 account key from the portal. */
+    key: string;
+    contentLength?: number;
+    now?: Date;
+}
+/**
+ * Azure Blob Storage shared key.
+ *
+ * A different scheme from SigV4 and not reducible to it: the string to sign is
+ * a fixed list of positional headers, most of which we never send and all of
+ * which still have to be there as empty lines.
+ */
+export declare function signAzure(request: AzureSignRequest): Promise<Record<string, string>>;
+//# sourceMappingURL=sign.d.ts.map

package/dist/storage/sign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign.d.ts","sourceRoot":"","sources":["../../src/storage/sign.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,0DAA0D;IAC1D,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,0EAA0E;IAC1E,OAAO,EAAE,UAAU,GAAG,kBAAkB,CAAC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,cAAc,CAAC;IAC5B,GAAG,CAAC,EAAE,IAAI,CAAC;CACZ;AAID;;;;;;GAMG;AACH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CA8DjC;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,EAAE,IAAI,CAAC;CACZ;AAED;;;;;;GAMG;AACH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAsDjC"}

package/dist/strings.d.ts

@@ -0,0 +1,13 @@
+/**
+ * String helpers shared across modules.
+ */
+/**
+ * Remove trailing slashes without a regex.
+ *
+ * The obvious `replace(/\/+$/, "")` backtracks quadratically on a string
+ * built out of slashes (CodeQL `js/polynomial-redos`). The values trimmed
+ * here are configuration most of the time, but a loop from the end is linear
+ * no matter what arrives, so every caller uses it.
+ */
+export declare function trimTrailingSlashes(value: string): string;
+//# sourceMappingURL=strings.d.ts.map

package/dist/strings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../src/strings.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIzD"}

package/dist/telemetry.d.ts

@@ -0,0 +1,137 @@
+import type { CmsInstance } from "./types/instance";
+import type { TelemetryConfig } from "./types/telemetry";
+export type { TelemetryConfig };
+/**
+ * Adoption telemetry — what it is, and what it refuses to be.
+ *
+ * The CMS has no analytics on the deployments it runs in: a server built from
+ * this package never phones home, in any environment, for any reason. What
+ * does report is the **command line**: `heyo-cms generate`, `migrate`,
+ * `seed`, `create-admin`, `import`, `export`, and the project generator. Those
+ * run on a developer's machine, once in a while, and answer the only question
+ * the project actually needs answered — is anybody using this, and with which
+ * database and framework.
+ *
+ * What is sent is in `TelemetryPayload` below and nowhere else. It is a fixed
+ * set of counts and identifiers: no content, no field names, no connection
+ * strings, no file paths, no addresses, no keys. `heyo-cms telemetry` prints
+ * the exact body that would be sent, so the claim is checkable rather than
+ * promised.
+ *
+ * Opting out, any one of which is enough:
+ *
+ *   HEYO_TELEMETRY_DISABLED=1      the project's own switch
+ *   DO_NOT_TRACK=1                 the cross-tool convention, honoured
+ *   telemetry: { enabled: false }  in heyo-cms.config.ts
+ *
+ * It is also off, without being asked, on CI and under a test runner: a build
+ * agent is not a user, and counting one as a user would make the number this
+ * exists to produce worthless.
+ */
+export declare const telemetryEndpoint = "https://telemetry.heyo.sh/v1/cms";
+export interface TelemetryDecision {
+    enabled: boolean;
+    /** Why, in words, so `heyo-cms telemetry` can print it. */
+    reason: string;
+}
+/**
+ * The whole payload. Adding a field here is a documentation change too.
+ */
+export interface TelemetryPayload {
+    /** The command that ran: `generate`, `migrate`, `create`, ... */
+    event: string;
+    /** The version of `@heyo-sh/heyo-cms` that sent it. */
+    version: string;
+    /**
+     * A project identifier that is not a project.
+     *
+     * The SHA-256 of the configuration's shape — collection names, the database
+     * id, the base path — truncated to 16 hex characters. Two runs from the
+     * same shape agree. This is not a unique installation id: projects with
+     * the same shape collide, and low-entropy inputs can be guessed. It must
+     * not be treated as a count of distinct users or as encryption.
+     */
+    project: string;
+    runtime: {
+        name: string;
+        version: string;
+    };
+    system: {
+        platform: string;
+        arch: string;
+        release: string;
+    };
+    /** The adapter id: `postgres`, `sqlite`, `d1`, `mongodb`. */
+    database: string;
+    /** Counts, never names. */
+    usage: {
+        collections: number;
+        globals: number;
+        fields: number;
+        plugins: number;
+        locales: number;
+    };
+    /** Which optional sections exist. Booleans, never their configuration. */
+    features: {
+        /** The panel bundle is mounted. */
+        panel: boolean;
+        /** Editor authentication is configured. */
+        auth: boolean;
+        /** The storage adapter id, or `null` when the CMS stores no files. */
+        uploads: string | null;
+        ai: boolean;
+        webhooks: boolean;
+        trash: boolean;
+    };
+}
+export interface TelemetryEnvironment {
+    [key: string]: string | undefined;
+}
+/**
+ * Decides whether anything may be sent, and says why.
+ *
+ * Every branch returns a sentence rather than a boolean alone, because the
+ * question a person asks is never "is it on" — it is "why is it on".
+ */
+export declare function telemetryDecision(config: TelemetryConfig | undefined, environment?: TelemetryEnvironment): TelemetryDecision;
+/**
+ * Builds the body from the configuration.
+ *
+ * Deliberately total: it never reads a file, never resolves a database and
+ * never touches the network, so printing it costs nothing and cannot fail in
+ * a way that breaks the command it was attached to.
+ */
+export declare function telemetryPayload(event: string, cms: CmsInstance, version: string): TelemetryPayload;
+export interface SendOptions {
+    endpoint?: string;
+    /** Injected by the tests; nothing else should pass it. */
+    fetch?: typeof fetch;
+    /** Milliseconds before the attempt is abandoned. */
+    timeout?: number;
+}
+/**
+ * Sends one payload, and never matters.
+ *
+ * Failure is not reported and not retried: a CLI that took longer, printed a
+ * warning or exited non-zero because a telemetry endpoint was down would be a
+ * worse tool than one with no telemetry at all.
+ */
+export declare function sendTelemetry(payload: TelemetryPayload, options?: SendOptions): Promise<"sent" | "failed">;
+/**
+ * The one call a command makes: decide, build, send, forget.
+ *
+ * Returns what happened so `heyo-cms telemetry` can print it; every caller
+ * except that command ignores the result.
+ */
+export declare function reportTelemetry(args: {
+    event: string;
+    cms: CmsInstance;
+    version: string;
+    config?: TelemetryConfig;
+    environment?: TelemetryEnvironment;
+    send?: SendOptions;
+}): Promise<{
+    decision: TelemetryDecision;
+    result: "sent" | "failed" | "skipped";
+}>;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,eAAO,MAAM,iBAAiB,qCAAqC,CAAC;AAEpE,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;OAQG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5D,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,2BAA2B;IAC3B,KAAK,EAAE;QACL,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,0EAA0E;IAC1E,QAAQ,EAAE;QACR,mCAAmC;QACnC,KAAK,EAAE,OAAO,CAAC;QACf,2CAA2C;QAC3C,IAAI,EAAE,OAAO,CAAC;QACd,sEAAsE;QACtE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,EAAE,EAAE,OAAO,CAAC;QACZ,QAAQ,EAAE,OAAO,CAAC;QAClB,KAAK,EAAE,OAAO,CAAC;KAChB,CAAC;CACH;AAED,MAAM,WAAW,oBAAoB;IACnC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACnC;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,eAAe,GAAG,SAAS,EACnC,WAAW,GAAE,oBAAkC,GAC9C,iBAAiB,CAiBnB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,MAAM,GACd,gBAAgB,CAuClB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,oDAAoD;IACpD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,MAAM,GAAG,QAAQ,CAAC,CAa5B;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,WAAW,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,WAAW,CAAC,EAAE,oBAAoB,CAAC;IACnC,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,GAAG,OAAO,CAAC;IACV,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;CACvC,CAAC,CASD"}

package/dist/telemetry.js

@@ -0,0 +1 @@
+import{wo,Ut,Jt,vo,yn}from"./index-szaq03qq.js";export{yn as reportTelemetry,vo as sendTelemetry,Ut as telemetryDecision,wo as telemetryEndpoint,Jt as telemetryPayload};

package/dist/types/activity.d.ts

@@ -0,0 +1,68 @@
+import type { ActorSource, OperationSource } from "./actor";
+import type { JsonObject } from "./json";
+/**
+ * One line of the audit trail.
+ *
+ * Written by the engine inside the transaction that caused it, which is the
+ * difference between an audit trail and a log: a change that committed is in
+ * here, and a change that rolled back is not (section 11).
+ */
+export interface ActivityEntry {
+    id: string;
+    /** `document.created`, `document.trashed`, … — the event vocabulary. */
+    action: string;
+    actorId: string | null;
+    actorSource: ActorSource | null;
+    /**
+     * Where the write came from: `admin`, `rest`, `job`, `ai`, …
+     *
+     * Distinct from `actorSource`, which says how the actor authenticated. An AI
+     * write has a human actor with a session and `source: "ai"`, and a trail
+     * that could only report one of those could not answer "what did the
+     * assistant change today".
+     */
+    source: OperationSource | null;
+    collection: string | null;
+    documentId: string | null;
+    locale: string | null;
+    /**
+     * `{ fields: [...] }` for a write: what actually changed.
+     *
+     * Carries `runId` as well when the assistant made the change, which is what
+     * ties a row back to the conversation that caused it.
+     */
+    changes: JsonObject | null;
+    ip: string | null;
+    createdAt: string | null;
+}
+export interface ActivityListArgs {
+    collection?: string;
+    documentId?: string;
+    actorId?: string;
+    action?: string;
+    /** `"ai"` answers "what did the assistant change" without a scan. */
+    source?: OperationSource;
+    limit?: number;
+    /** Keyset, over the ordered id. Pass back `cursor` from the last page. */
+    cursor?: string;
+}
+export interface ActivityPage {
+    entries: ActivityEntry[];
+    limit: number;
+    hasNextPage: boolean;
+    cursor: string | null;
+}
+/**
+ * `cms.activity`.
+ *
+ * Read-only on purpose: there is no `write` and no `delete`. The engine is the
+ * only writer, and an audit trail with a delete method is a list of the
+ * changes somebody was willing to leave behind.
+ *
+ * Paged by the row id rather than by `created_at`, because the ids are ordered
+ * and two writes to the same document routinely land in the same millisecond.
+ */
+export interface CmsActivity {
+    list(args?: ActivityListArgs): Promise<ActivityPage>;
+}
+//# sourceMappingURL=activity.d.ts.map

package/dist/types/activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../../src/types/activity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC;;;;;;;OAOG;IACH,MAAM,EAAE,eAAe,GAAG,IAAI,CAAC;IAC/B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB;;;;;OAKG;IACH,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;IAC3B,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,IAAI,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CACtD"}

package/dist/types/actor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Who is performing an operation.
+ *
+ * Both authentication methods (editor session, machine API key) collapse into
+ * the same shape on purpose: every access rule, hook and activity-log entry
+ * then has one thing to read, and a rule written against sessions cannot
+ * silently stop applying to API keys.
+ */
+export interface Actor {
+    id: string;
+    source: ActorSource;
+    roles: string[];
+    /** Flattened `collection:action` grants, wildcards already expanded. */
+    permissions: string[];
+}
+export type ActorSource = "session" | "api-key";
+/**
+ * Where an operation entered the engine. Carried through to hooks and events.
+ *
+ * `ai` is the global assistant writing on an editor's behalf. It is a source
+ * and not an actor: the person who asked for the change is still the actor,
+ * because "who is accountable" and "what typed it" are different questions and
+ * an audit trail that confuses them cannot answer either.
+ */
+export type OperationSource = "rest" | "admin" | "local" | "cli" | "job" | "ai";
+//# sourceMappingURL=actor.d.ts.map