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

package/dist/http/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The HTTP layer.
+ *
+ * Nothing here knows how a document is stored, who may read it or what a
+ * hook does: every handler parses a URL, calls one method on the instance and
+ * serialises the answer. That is what keeps `cms.api.posts.find()` and
+ * `GET /api/heyo-cms/posts` the same operation rather than two implementations
+ * of the same intention (section 10).
+ */
+export { createCmsHttp, type CmsHttp } from "./handler";
+export { buildOpenApi } from "./openapi";
+export { Router, type RouteHandler, type RouteMatch, type RouteMiddleware, type RouteRecord, } from "./router";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/http/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,aAAa,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EACL,MAAM,EACN,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,WAAW,GACjB,MAAM,UAAU,CAAC"}

package/dist/http/openapi.d.ts

@@ -0,0 +1,5 @@
+import type { CmsInstance } from "../types/instance";
+import type { JsonObject } from "../types/json";
+import type { RouteRecord } from "./router";
+export declare function buildOpenApi(cms: CmsInstance, routes: RouteRecord[]): JsonObject;
+//# sourceMappingURL=openapi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../src/http/openapi.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAgD5C,wBAAgB,YAAY,CAC1B,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,WAAW,EAAE,GACpB,UAAU,CAiEZ"}

package/dist/http/params.d.ts

@@ -0,0 +1,32 @@
+import type { Actor } from "../types/actor";
+import type { FindArgs, ReadArgs } from "../types/api";
+import type { ResolvedCollection } from "../types/config";
+import type { OrderBy, Where } from "../types/query";
+export interface ReadQueryOptions {
+    actor: Actor | null;
+    /** `rest` for everything over HTTP; the panel is marked by a header. */
+    source: ReadArgs["source"];
+}
+/** Locale, depth and the trash flag: what every read takes. */
+export declare function readArgs(query: URLSearchParams, options: ReadQueryOptions): ReadArgs;
+/** The whole of `GET /posts`: filters, sort, paging. */
+export declare function findArgs(query: URLSearchParams, collection: ResolvedCollection, options: ReadQueryOptions): FindArgs;
+/**
+ * The filter, from either syntax.
+ *
+ * Both are resolved through the same path resolver, which is what makes a
+ * localized field filterable without the caller knowing it is stored as a map:
+ * `?title=Hello` with `?locale=de` becomes `data.title.de`, because that is
+ * where the German title lives (section 9).
+ */
+export declare function parseWhere(query: URLSearchParams, collection: ResolvedCollection, locale: string | null): Where | undefined;
+export declare function parseSort(raw: string | null, collection: ResolvedCollection, locale: string | null): OrderBy[] | undefined;
+export declare function integer(raw: string | null, name: string, min: number, max: number): number | undefined;
+/**
+ * `?flag`, `?flag=true` and `?flag=1` all mean yes.
+ *
+ * A bare `?permanent` with no value is what somebody types, and reading it as
+ * "false" would make a destructive flag silently do nothing.
+ */
+export declare function boolean(raw: string | null, name: string): boolean | undefined;
+//# sourceMappingURL=params.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../../src/http/params.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAA2B,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAiF9E,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,wEAAwE;IACxE,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;CAC5B;AAED,+DAA+D;AAC/D,wBAAgB,QAAQ,CACtB,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE,gBAAgB,GACxB,QAAQ,CAiBV;AAED,wDAAwD;AACxD,wBAAgB,QAAQ,CACtB,KAAK,EAAE,eAAe,EACtB,UAAU,EAAE,kBAAkB,EAC9B,OAAO,EAAE,gBAAgB,GACxB,QAAQ,CAkBV;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,eAAe,EACtB,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,MAAM,GAAG,IAAI,GACpB,KAAK,GAAG,SAAS,CAiCnB;AA0ED,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,GAAG,IAAI,EAClB,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,MAAM,GAAG,IAAI,GACpB,OAAO,EAAE,GAAG,SAAS,CAevB;AA2HD,wBAAgB,OAAO,CACrB,GAAG,EAAE,MAAM,GAAG,IAAI,EAClB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV,MAAM,GAAG,SAAS,CAOpB;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAK7E"}

package/dist/http/request-db.d.ts

@@ -0,0 +1,19 @@
+import type { DatabaseAdapter } from "../types/database";
+import type { ScopedDb } from "../types/hooks";
+/**
+ * `ctx.db` for a route rather than for a hook.
+ *
+ * A hook runs inside the operation's transaction, so its `db` joins it. A
+ * route is not an operation: there is nothing for a second statement to be
+ * atomic with, and holding a transaction open across an `await fetch()` in
+ * somebody's plugin would pin a pool connection for as long as the slowest
+ * third party takes to answer. So every call here gets its own short
+ * transaction, and a route that genuinely needs two statements to agree asks
+ * for the adapter and opens one itself.
+ *
+ * Lazy on purpose: resolving the adapter is what opens a pool or reads a
+ * binding, and most requests — a bundled asset, the OpenAPI document, a 404 —
+ * never touch the database at all.
+ */
+export declare function requestDb(database: () => Promise<DatabaseAdapter>): ScopedDb;
+//# sourceMappingURL=request-db.d.ts.map

package/dist/http/request-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-db.d.ts","sourceRoot":"","sources":["../../src/http/request-db.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG/C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,eAAe,CAAC,GAAG,QAAQ,CAuB5E"}

package/dist/http/respond.d.ts

@@ -0,0 +1,48 @@
+import type { JsonObject } from "../types/json";
+/**
+ * Every response the handler produces, in one place.
+ *
+ * The shape matters more than it looks: a client written against this has to
+ * be able to tell "the hook stopped it" from "the document is not there" from
+ * "your filter is nonsense" without parsing prose, which is why errors carry
+ * `code` and why a stopped write is a status rather than a body.
+ */
+export declare const jsonContentType = "application/json; charset=utf-8";
+export declare function json(body: unknown, status?: number, headers?: Record<string, string>): Response;
+export declare function text(body: string, status?: number): Response;
+export declare function noContent(headers?: Record<string, string>): Response;
+/**
+ * A write a `before` hook stopped.
+ *
+ * `null` is the local API's answer (section 5) and HTTP has no `null`, so this
+ * is the translation: nothing happened, nothing to return, and a header that
+ * says which of the two reasons for a 204 this is. The typed client turns it
+ * back into `null`.
+ */
+export declare function stopped(): Response;
+/**
+ * The one error shape.
+ *
+ * A `CmsError` already carries the status and the code — a hook that threw, a
+ * refused access rule and a failed field validation all arrive here as one
+ * type — so this function never has to guess. Anything else is a bug in the
+ * CMS and is reported as a 500 whose message is not forwarded: an exception
+ * from a database driver routinely contains a connection string.
+ */
+export declare function errorResponse(error: unknown): Response;
+/**
+ * The JSON body of a request.
+ *
+ * An empty body reads as `{}` because `PATCH /posts/:id` with nothing to say
+ * is a legal, if pointless, request — and answering it with a parse error
+ * would be a worse description of what happened.
+ */
+export declare function readJson(request: Request): Promise<unknown>;
+/** The body as an object, which is what every write route wants. */
+export declare function readJsonObject(request: Request): Promise<JsonObject>;
+/** `data` out of a write body, refusing the shapes that cannot be a patch. */
+export declare function requireData(body: JsonObject, key?: string): JsonObject;
+export declare function requireString(body: JsonObject, key: string): string;
+export declare function optionalString(body: JsonObject, key: string): string | undefined;
+export declare function optionalStringArray(body: JsonObject, key: string): string[] | undefined;
+//# sourceMappingURL=respond.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"respond.d.ts","sourceRoot":"","sources":["../../src/http/respond.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;;;;;GAOG;AAEH,eAAO,MAAM,eAAe,oCAAoC,CAAC;AAEjE,wBAAgB,IAAI,CAClB,IAAI,EAAE,OAAO,EACb,MAAM,SAAM,EACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B,QAAQ,CAKV;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,SAAM,GAAG,QAAQ,CAKzD;AAED,wBAAgB,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,QAAQ,CAEpE;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,IAAI,QAAQ,CAElC;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CA4BtD;AAED;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAWjE;AAED,oEAAoE;AACpE,wBAAsB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,CAS1E;AAED,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,SAAS,GAAG,UAAU,CAStE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAMnE;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,MAAM,GACV,MAAM,GAAG,SAAS,CAOpB;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,MAAM,GACV,MAAM,EAAE,GAAG,SAAS,CAStB"}

package/dist/http/rich-text.d.ts

@@ -0,0 +1,41 @@
+import type { ResolvedCollection } from "../types/config";
+import type { RichTextFormat, RichTextMediaImage } from "../types/editor";
+import type { CmsInstance } from "../types/instance";
+import type { JsonObject } from "../types/json";
+/**
+ * `?richText=html` on a read.
+ *
+ * The reason this exists is the one `defineEditorNode()` enforces: a
+ * ProseMirror document is useless to a consumer that has no ProseMirror. A
+ * static site generator, an RSS feed, a mail template and a search index all
+ * want the same thing, and without this each of them writes its own
+ * half-correct renderer against a tree they do not control.
+ *
+ * It is opt-in and not the default, because the document *is* the stored
+ * value: a client that writes back what it read must get back what is
+ * stored, and a response that silently replaced a document with a string
+ * would make `GET` then `PATCH` destructive.
+ */
+export declare function richTextFormat(value: string | null): RichTextFormat | undefined;
+export interface RenderOptions {
+    collection: ResolvedCollection;
+    format: RichTextFormat;
+    /** Resolves a `mediaId` on an image node to a URL this deployment serves. */
+    mediaUrl: (id: string) => string;
+    /** Resolves a `mediaId` to a whole `<img>`: dimensions, `srcset`, alt. */
+    mediaImage?: (id: string) => RichTextMediaImage | null;
+}
+/** Renders every rich-text field of one document, in place. */
+export declare function renderDocumentRichText(document: JsonObject, options: RenderOptions): JsonObject;
+export declare function renderPageRichText(documents: JsonObject[], options: RenderOptions): void;
+/** The URL the CMS itself serves a file from, for an image inside prose. */
+export declare function mediaUrlResolver(basePath: string): (id: string) => string;
+/**
+ * Every library image the rich-text fields of these documents show, loaded
+ * in one query and described for an `<img>`.
+ *
+ * Undefined without `uploads`: there is no library to look in, and the
+ * serialiser's plain `mediaUrl` fallback is the whole answer.
+ */
+export declare function richTextMediaResolver(cms: CmsInstance, documents: JsonObject[], collection: ResolvedCollection, locale: string | null): Promise<((id: string) => RichTextMediaImage | null) | undefined>;
+//# sourceMappingURL=rich-text.d.ts.map

package/dist/http/rich-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rich-text.d.ts","sourceRoot":"","sources":["../../src/http/rich-text.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,eAAe,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,cAAc,GAAG,SAAS,CAQ5B;AAED,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,kBAAkB,CAAC;IAC/B,MAAM,EAAE,cAAc,CAAC;IACvB,6EAA6E;IAC7E,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IACjC,0EAA0E;IAC1E,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,kBAAkB,GAAG,IAAI,CAAC;CACxD;AAED,+DAA+D;AAC/D,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,aAAa,GACrB,UAAU,CAkBZ;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,UAAU,EAAE,EACvB,OAAO,EAAE,aAAa,GACrB,IAAI,CAEN;AAED,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAEzE;AAED;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,WAAW,EAChB,SAAS,EAAE,UAAU,EAAE,EACvB,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,MAAM,GAAG,IAAI,GACpB,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,MAAM,KAAK,kBAAkB,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC,CAmBlE"}

package/dist/http/router.d.ts

@@ -0,0 +1,55 @@
+import type { RouteInspection } from "../types/instance";
+import type { OpenApiRouteSpec, RouteContext, RouteMethod } from "../types/plugin";
+/**
+ * The router.
+ *
+ * Written here rather than taken from a package, and that is a decision worth
+ * defending. The plan points at Better Auth's arrangement (section 10) and
+ * Better Auth does exactly this: its own matcher, because the router ends up
+ * in the public contract. Ours is in `RouteContext`, which a plugin author
+ * types against — and a plugin ecosystem pinned to somebody else's router
+ * major version is the framework coupling this project exists to avoid.
+ *
+ * What it owes: `:param` and a trailing `*`, static-before-dynamic
+ * precedence, 405 with an `Allow` header, and collisions detected while the
+ * configuration is still loading.
+ */
+export type RouteHandler = (context: RouteContext) => Response | Promise<Response>;
+export type RouteMiddleware = (context: RouteContext, next: () => Promise<Response>) => Promise<Response>;
+export interface RouteRecord {
+    method: RouteMethod;
+    /** Relative to `basePath`: `/posts/:id`, `/admin/*`. */
+    path: string;
+    /** `core`, or the id of the plugin that registered it. */
+    source: string;
+    handler: RouteHandler;
+    middleware?: RouteMiddleware[];
+    openapi?: OpenApiRouteSpec;
+}
+export type RouteMatch = {
+    kind: "found";
+    route: RouteRecord;
+    params: Record<string, string>;
+} | {
+    kind: "method-not-allowed";
+    allowed: RouteMethod[];
+} | {
+    kind: "not-found";
+};
+export declare class Router {
+    private readonly compiled;
+    private readonly signatures;
+    add(route: RouteRecord): void;
+    /** Registration order is not match order; this is match order. */
+    list(): RouteRecord[];
+    /**
+     * What `cms.inspect().routes` prints.
+     *
+     * Paths carry `basePath`, because the question somebody has when they print
+     * this is "what do I call", and the answer to that is a URL rather than a
+     * pattern the router happens to store.
+     */
+    routes(basePath: string): RouteInspection[];
+    match(method: string, path: string): RouteMatch;
+}
+//# sourceMappingURL=router.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/http/router.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EACV,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACZ,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,YAAY,GAAG,CACzB,OAAO,EAAE,YAAY,KAClB,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAElC,MAAM,MAAM,eAAe,GAAG,CAC5B,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,KAC1B,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEvB,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,WAAW,CAAC;IACpB,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,YAAY,CAAC;IACtB,UAAU,CAAC,EAAE,eAAe,EAAE,CAAC;IAC/B,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B;AAeD,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GACrE;IAAE,IAAI,EAAE,oBAAoB,CAAC;IAAC,OAAO,EAAE,WAAW,EAAE,CAAA;CAAE,GACtD;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC;AAE1B,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuB;IAChD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IAExD,GAAG,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAuC5B;IAED,kEAAkE;IAClE,IAAI,IAAI,WAAW,EAAE,CAEpB;IAED;;;;;;OAMG;IACH,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,EAAE,CAO1C;IAED,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAkB9C;CACF"}

package/dist/http/routes/access.d.ts

@@ -0,0 +1,13 @@
+import type { CmsInstance } from "../../types/instance";
+import type { RouteRecord } from "../router";
+/**
+ * Who may edit, and what each role means.
+ *
+ * These are the endpoints with no collection behind them, so the permission
+ * check is explicit — `users:read`, `roles:create` — and an authenticated
+ * caller is required even when `rbac` is absent (see `guard.ts`). Everything
+ * else is `cms.auth`, unchanged: the panel and a provisioning script get the
+ * same invitations, the same hashed secrets and the same events.
+ */
+export declare function accessRoutes(cms: CmsInstance): RouteRecord[];
+//# sourceMappingURL=access.d.ts.map

package/dist/http/routes/access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../../../src/http/routes/access.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAWxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG7C;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CAyT5D"}

package/dist/http/routes/admin.d.ts

@@ -0,0 +1,28 @@
+import type { CmsInstance } from "../../types/instance";
+import type { JsonObject } from "../../types/json";
+import type { RouteRecord } from "../router";
+/**
+ * The panel, served from the same handler as the API.
+ *
+ * No separate deployment, no CORS, no second origin to configure: the bundle
+ * is files, the handler serves files, and the panel talks to the API through
+ * relative URLs (section 10). `admin.assets` is where the files come from —
+ * an interface rather than a directory, because the bundle has to be readable
+ * from a Worker, where there is no filesystem.
+ *
+ * Without one — `admin.assets` unset — this answers with a page that says
+ * what is missing and links to the generated OpenAPI document.
+ * Deliberately not a 404: a mount point that answers nothing is
+ * indistinguishable from a mount point that is wrong, and the first thing
+ * somebody does after wiring the catch-all route is open this URL.
+ */
+export declare function adminRoutes(cms: CmsInstance): RouteRecord[];
+/**
+ * `GET /openapi.json`: the canonical description of this deployment.
+ *
+ * Takes a function rather than the document because the document describes
+ * this route too: the router has to be complete before it can be generated,
+ * and generating it on first request also keeps it off the cold-start path.
+ */
+export declare function openApiRoute(document: () => JsonObject): RouteRecord;
+//# sourceMappingURL=admin.d.ts.map

package/dist/http/routes/admin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.d.ts","sourceRoot":"","sources":["../../../src/http/routes/admin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG7C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CAyF3D;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,UAAU,GAAG,WAAW,CAepE"}

package/dist/http/routes/ai.d.ts

@@ -0,0 +1,26 @@
+import type { CmsInstance } from "../../types/instance";
+import type { RouteRecord } from "../router";
+/**
+ * The AI endpoints, generated from the configuration like everything else.
+ *
+ * Two shapes per field action, and the reason there are two is that a document
+ * being written for the first time has no id. The panel asks about what is on
+ * the screen, which for a new document is only in the browser, so the draft
+ * travels in the body and the stored document — when there is one — is read
+ * through `cms.api` and merged underneath it.
+ *
+ *   POST /posts/:id/ai/:field/:action
+ *   POST /posts/ai/:field/:action        (an unsaved draft)
+ *
+ * Then the panel-wide assistant, which is addressed by nothing in particular
+ * because it is not about one collection:
+ *
+ *   POST /ai/assistant                   (SSE)
+ *   POST /ai/assistant/plans/:id/approve
+ *
+ * The per-field routes exist only when a field declares `aiGenerate` or a legacy `ai` action.
+ * A deployment with no AI has no AI endpoints, which is what
+ * `cms.inspect().routes` should say (section 8).
+ */
+export declare function aiRoutes(cms: CmsInstance): RouteRecord[];
+//# sourceMappingURL=ai.d.ts.map

package/dist/http/routes/ai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.d.ts","sourceRoot":"","sources":["../../../src/http/routes/ai.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAIxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CA+JxD"}

package/dist/http/routes/auth.d.ts

@@ -0,0 +1,13 @@
+import type { CmsInstance } from "../../types/instance";
+import type { RouteRecord } from "../router";
+/**
+ * Editor authentication over HTTP.
+ *
+ * Every handler is a call into `cms.auth` plus a cookie, and the routes that
+ * exist are decided by `admin.auth.methods`: a deployment that never enabled
+ * magic links does not answer `POST /auth/magic-link` with "not configured",
+ * it does not have the endpoint. `cms.inspect().routes` is then a true
+ * statement about the doors this deployment has.
+ */
+export declare function authRoutes(cms: CmsInstance): RouteRecord[];
+//# sourceMappingURL=auth.d.ts.map

package/dist/http/routes/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/http/routes/auth.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAWxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG7C;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CAkpB1D"}

package/dist/http/routes/documents.d.ts

@@ -0,0 +1,24 @@
+import type { ResolvedCollection } from "../../types/config";
+import type { CmsInstance } from "../../types/instance";
+import type { RouteRecord } from "../router";
+/**
+ * CRUD, generated from the configuration.
+ *
+ * Every handler here is three lines around a call into `cms.api`, and that is
+ * the whole design: the REST layer parses a URL and serialises a result, and
+ * knows nothing about access control, hooks, locales, the trash or events.
+ * A second implementation of any of those — the usual outcome of writing
+ * route handlers by hand — is a second set of bugs (section 10).
+ */
+export declare function documentRoutes(cms: CmsInstance): RouteRecord[];
+/**
+ * Singletons.
+ *
+ * Mounted under `/globals/` rather than at the root: a global and a
+ * collection are the same machinery, but a URL that could be either would
+ * make `/settings` ambiguous the day somebody adds a `settings` collection.
+ */
+export declare function globalRoutes(cms: CmsInstance): RouteRecord[];
+export declare function schemaName(collection: ResolvedCollection): string;
+export declare function inputName(collection: ResolvedCollection): string;
+//# sourceMappingURL=documents.d.ts.map

package/dist/http/routes/documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../../../src/http/routes/documents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAkBxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAkE7C;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CA0T9D;AA6KD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CA8I5D;AAED,wBAAgB,UAAU,CAAC,UAAU,EAAE,kBAAkB,GAAG,MAAM,CAEjE;AAED,wBAAgB,SAAS,CAAC,UAAU,EAAE,kBAAkB,GAAG,MAAM,CAEhE"}

package/dist/http/routes/generate.d.ts

@@ -0,0 +1,5 @@
+import type { CmsInstance } from "../../types/instance";
+import type { RouteRecord } from "../router";
+/** Deterministic field generation: server functions stay on the server. */
+export declare function generateRoutes(cms: CmsInstance): RouteRecord[];
+//# sourceMappingURL=generate.d.ts.map

package/dist/http/routes/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/http/routes/generate.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG7C,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CA6J9D"}

package/dist/http/routes/media.d.ts

@@ -0,0 +1,58 @@
+import type { CmsInstance } from "../../types/instance";
+import type { MediaVariantResult } from "../../types/media";
+import type { RouteRecord } from "../router";
+/**
+ * The media library over HTTP.
+ *
+ * Registered only when `uploads` is configured. A deployment with no storage
+ * adapter has no library, and routes that exist in order to answer "add an
+ * uploads section" would put that sentence in `cms.inspect().routes` as if it
+ * were a feature.
+ *
+ * Reading is not gated by RBAC and writing is: a file's URL is public the
+ * moment it is on a page, so gating reads would break anonymous rendering and
+ * protect nothing that a private bucket and a signed URL do not already
+ * protect (stage 6).
+ */
+export declare function mediaRoutes(cms: CmsInstance): RouteRecord[];
+/**
+ * One file, as an HTTP response: the API route and the public route share it.
+ *
+ * The tag is the checksum of the original plus the variant name: two
+ * deployments of the same bytes produce the same tag, and a re-render of the
+ * same size does not invalidate a cache that is already correct. A variant is
+ * addressed by a name whose meaning is fixed by the configuration, so the
+ * bytes behind one URL only change when an editor re-crops — which changes
+ * the checksum and the tag — and the answer may be kept for a year.
+ *
+ * Except when the size could not be rendered and the original stands in for
+ * it: that answer is right for now and wrong once the processor recovers, so
+ * it carries its own tag and is cached for minutes, not for a year.
+ */
+export declare function mediaResponse(request: Request, result: MediaVariantResult, extraHeaders?: Record<string, string>): Promise<Response>;
+/**
+ * The files themselves, at addresses made for the web:
+ *
+ *   /media/med_0mv…/condition-report.png
+ *   /media/med_0mv…/card/condition-report.webp
+ *
+ * Registered only with `uploads.publicPath`, outside `basePath`, on the root
+ * router: the application mounts the CMS handler on this path as well. The
+ * id says which file and the optional middle segment which size; the name is
+ * for people and image search, and is otherwise ignored, so a renamed file
+ * keeps every link it ever had. No actor, no hooks, no RBAC — a file on a
+ * page is public, which is what this route exists to say.
+ */
+export declare function publicMediaRoutes(cms: CmsInstance): RouteRecord[];
+/**
+ * The orphan sweep, as an endpoint.
+ *
+ * Here rather than in the jobs module because it is the media lifecycle's
+ * only destructive step and reads better next to the library it collects
+ * from. It is also registered in `cms.jobs`, so a deployment with a cron
+ * never needs this route.
+ */
+export declare function mediaCollectRoute(cms: CmsInstance): RouteRecord[];
+/** The two names a declared size may not take; see the variant route. */
+export declare const reservedMediaSubRoutes: string[];
+//# sourceMappingURL=media.d.ts.map

package/dist/http/routes/media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../../src/http/routes/media.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,KAAK,EAKV,kBAAkB,EACnB,MAAM,mBAAmB,CAAC;AAI3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAW7C;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CA6R3D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,kBAAkB,EAC1B,YAAY,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GACxC,OAAO,CAAC,QAAQ,CAAC,CAwBnB;AAYD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CA2CjE;AAcD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CAsCjE;AAED,yEAAyE;AACzE,eAAO,MAAM,sBAAsB,UAA0C,CAAC"}

package/dist/http/routes/panel.d.ts

@@ -0,0 +1,20 @@
+import type { CmsInstance } from "../../types/instance";
+import type { RouteRecord } from "../router";
+/**
+ * `GET /panel`: the configuration, as data.
+ *
+ * The panel is one static bundle that has to render every deployment, so the
+ * first thing it does is ask what this one is: which collections exist, what
+ * fields they carry, which languages are registered, whether there is a
+ * trash, what the caller is allowed to press. All of it is derived from the
+ * configuration — there is no second place to maintain it, which is the same
+ * argument that produced the auto-router and the generated OpenAPI document.
+ *
+ * Open to anonymous callers on purpose. It describes the shape of the
+ * deployment, never its content and never a secret, and the sign-in screen
+ * needs the title and the enabled methods *before* anybody is signed in. The
+ * per-actor parts — `can`, and field-level access — simply answer for
+ * "nobody" then, which is the correct answer for nobody.
+ */
+export declare function panelRoutes(cms: CmsInstance): RouteRecord[];
+//# sourceMappingURL=panel.d.ts.map

package/dist/http/routes/panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../../src/http/routes/panel.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG7C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CA8B3D"}

package/dist/http/routes/system.d.ts

@@ -0,0 +1,25 @@
+import type { CmsInstance } from "../../types/instance";
+import type { RouteRecord } from "../router";
+/**
+ * The endpoints that are about the CMS rather than about content: the trash,
+ * the language registry, the audit trail and the sweeps.
+ *
+ * All four are read through an instance method rather than a query written
+ * here, for the same reason the document routes are three lines each. The
+ * trash list in particular has to be one paged query across collections —
+ * assembling it per collection would page wrongly the moment two collections
+ * have entries.
+ */
+export declare function trashRoutes(cms: CmsInstance): RouteRecord[];
+export declare function localeRoutes(cms: CmsInstance): RouteRecord[];
+export declare function activityRoutes(cms: CmsInstance): RouteRecord[];
+/**
+ * The sweeps, as endpoints.
+ *
+ * The package deliberately starts no timer (`cms.jobs` is not a daemon,
+ * because it has to run on Workers and on Lambda), so something has to call
+ * this: a Vercel cron with an API key, `wrangler`'s scheduled handler calling
+ * `cms.jobs.run()` directly, or a developer with curl.
+ */
+export declare function jobRoutes(cms: CmsInstance): RouteRecord[];
+//# sourceMappingURL=system.d.ts.map

package/dist/http/routes/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../../src/http/routes/system.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAIxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG7C;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CAkH3D;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CAmC5D;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CA4D9D;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CAqEzD"}

package/dist/http/routes/webhooks.d.ts

@@ -0,0 +1,17 @@
+import type { CmsInstance } from "../../types/instance";
+import type { RouteRecord } from "../router";
+/**
+ * Subscriptions, deliveries, replay.
+ *
+ * Registered only when `webhooks.enabled` is true, so a deployment that does
+ * not use them does not answer on these paths at all — and the panel, which
+ * reads `cms.inspect()`-shaped data from `/panel`, hides the screen rather
+ * than showing one that 501s.
+ *
+ * Every endpoint needs a permission in the `resource:action` grammar the
+ * rest of the product uses: `webhooks:read`, `webhooks:create`,
+ * `webhooks:update`, `webhooks:delete`. Managing where this CMS sends its
+ * content is an administrative act, not an editorial one.
+ */
+export declare function webhookRoutes(cms: CmsInstance): RouteRecord[];
+//# sourceMappingURL=webhooks.d.ts.map

package/dist/http/routes/webhooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["../../../src/http/routes/webhooks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAMxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG7C;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,CA2N7D"}

package/dist/http/spec.d.ts

@@ -0,0 +1,28 @@
+import type { JsonObject } from "../types/json";
+/**
+ * The small vocabulary the route modules use to document themselves.
+ *
+ * Keeping it here rather than inline is not tidiness: a response envelope
+ * described slightly differently on forty endpoints produces a generated
+ * document nobody can code-generate a client from.
+ */
+export declare function ref(schema: string): JsonObject;
+export declare function pathParam(name: string, description: string): JsonObject;
+export declare function queryParam(name: string, type: "string" | "integer" | "boolean", description: string, extra?: JsonObject): JsonObject;
+/** Locale and fallback: every read takes them, so they are written once. */
+export declare const localeParams: JsonObject[];
+export declare const depthParam: JsonObject;
+/** The filter, sort and paging parameters of a list endpoint. */
+export declare function listParams(collection: string): JsonObject[];
+export declare function jsonBody(schema: JsonObject, required?: boolean): JsonObject;
+export declare function okJson(schema: JsonObject, description: string): JsonObject;
+/**
+ * The responses every write shares.
+ *
+ * `204` is in here on purpose: a `before` hook returning `false` stops the
+ * operation without an error (section 5), and a client that does not know
+ * that will read an empty body as a broken endpoint.
+ */
+export declare function writeResponses(schema: JsonObject, description: string, status?: number): JsonObject;
+export declare function readResponses(schema: JsonObject, description: string): JsonObject;
+//# sourceMappingURL=spec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../src/http/spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;;;;GAMG;AAEH,wBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAE9C;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,UAAU,CAQvE;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,SAAS,EACtC,WAAW,EAAE,MAAM,EACnB,KAAK,GAAE,UAAe,GACrB,UAAU,CAQZ;AAED,4EAA4E;AAC5E,eAAO,MAAM,YAAY,EAAE,UAAU,EAGpC,CAAC;AAEF,eAAO,MAAM,UAAU,YAKtB,CAAC;AAEF,iEAAiE;AACjE,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,EAAE,CAoB3D;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,UAAO,GAAG,UAAU,CAKxE;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,GAAG,UAAU,CAK1E;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,MAAM,EACnB,MAAM,SAAM,GACX,UAAU,CAaZ;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,MAAM,GAClB,UAAU,CAKZ"}

package/dist/http.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `@heyo-sh/heyo-cms/http`.
+ *
+ * The HTTP layer, for the two callers who need it directly: a plugin writing
+ * route handlers, and a test or tool that wants the router without a request.
+ * An application mounts `cms.handler` through a framework adapter and never
+ * imports this.
+ */
+export { createCmsHttp, type CmsHttp } from "./http/handler";
+export { buildOpenApi } from "./http/openapi";
+export { Router, type RouteHandler, type RouteMatch, type RouteMiddleware, type RouteRecord, } from "./http/router";
+export { errorResponse, json, noContent, optionalString, optionalStringArray, readJson, readJsonObject, requireData, requireString, stopped, text, } from "./http/respond";
+export { requestSource, requireActor, requirePermission, requireSession, } from "./http/guard";
+export { boolean as booleanParam, findArgs, integer as integerParam, parseSort, parseWhere, readArgs, } from "./http/params";
+export { requestDb } from "./http/request-db";
+export { jsonBody, listParams, localeParams, okJson, pathParam, queryParam, readResponses, ref, writeResponses, } from "./http/spec";
+//# sourceMappingURL=http.d.ts.map

package/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,aAAa,EAAE,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EACL,MAAM,EACN,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,WAAW,GACjB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACb,IAAI,EACJ,SAAS,EACT,cAAc,EACd,mBAAmB,EACnB,QAAQ,EACR,cAAc,EACd,WAAW,EACX,aAAa,EACb,OAAO,EACP,IAAI,GACL,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,aAAa,EACb,YAAY,EACZ,iBAAiB,EACjB,cAAc,GACf,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,OAAO,IAAI,YAAY,EACvB,QAAQ,EACR,OAAO,IAAI,YAAY,EACvB,SAAS,EACT,UAAU,EACV,QAAQ,GACT,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EACL,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,MAAM,EACN,SAAS,EACT,UAAU,EACV,aAAa,EACb,GAAG,EACH,cAAc,GACf,MAAM,aAAa,CAAC"}

package/dist/http.js

@@ -0,0 +1 @@
+import"./index-6m1kjq9g.js";import"./index-sgdnp83t.js";import"./index-g041kfa5.js";import{Ye,g,Ze,y,j,On,Xn,eo,P,G,i,Pn,oe,K,St,Xt,f,De,v,W,Re,o,c,a,q,_n,h,r,N,Tt,$n,In,Se,qe}from"./index-hpast878.js";import"./index-8x2em6c8.js";import"./index-91fa1gzf.js";import"./index-2prbs05k.js";export{Se as Router,G as booleanParam,$n as buildOpenApi,qe as createCmsHttp,St as errorResponse,On as findArgs,P as integerParam,i as json,h as jsonBody,_n as listParams,q as localeParams,oe as noContent,r as okJson,W as optionalString,Re as optionalStringArray,eo as parseSort,Xn as parseWhere,c as pathParam,a as queryParam,j as readArgs,Xt as readJson,f as readJsonObject,Tt as readResponses,o as ref,In as requestDb,y as requestSource,Ye as requireActor,De as requireData,g as requirePermission,Ze as requireSession,v as requireString,K as stopped,Pn as text,N as writeResponses};

package/dist/i18n/index.d.ts

@@ -0,0 +1,12 @@
+import type { ResolvedCmsConfig } from "../types/config";
+import type { LocaleRecord } from "../types/locales";
+export { isRtlLocale, localeName, LOCALE_NAMES } from "./names";
+/**
+ * The configured languages, named.
+ *
+ * In the order they were configured: a switcher that reorders what somebody
+ * typed is a switcher whose order nobody can control. The default locale is
+ * flagged rather than hoisted, for the same reason.
+ */
+export declare function localeRecords(config: ResolvedCmsConfig): LocaleRecord[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/i18n/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGrD,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEhE;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,iBAAiB,GAAG,YAAY,EAAE,CAOvE"}