emdash 0.28.0 → 0.29.0

package/dist/{byline-fields-Cgrt9-aL.d.mts → relations-CbBpoOys.d.mts}

@@ -93,6 +93,7 @@ declare const contentCreateBody: z.ZodObject<{
     canonical: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     noIndex: z.ZodOptional<z.ZodBoolean>;
   }, z.core.$strip>>;
+  taxonomies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
   publishedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
   createdAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
 }, z.core.$strip>;
@@ -116,6 +117,7 @@ declare const contentUpdateBody: z.ZodObject<{
     canonical: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     noIndex: z.ZodOptional<z.ZodBoolean>;
   }, z.core.$strip>>;
+  taxonomies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
   publishedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
 }, z.core.$strip>;
 declare const contentScheduleBody: z.ZodObject<{
@@ -578,6 +580,66 @@ declare const mediaConfirmResponseSchema: z.ZodObject<{
   }, z.core.$strip>;
 }, z.core.$strip>;
 //#endregion
+//#region src/api/schemas/media-usage.d.ts
+declare const mediaUsageRepairStatusSchema: z.ZodEnum<{
+  failed: "failed";
+  complete: "complete";
+  partial: "partial";
+  stale: "stale";
+}>;
+declare const mediaUsageRepairBody: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  scope: z.ZodLiteral<"collection">;
+  collection: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  scope: z.ZodLiteral<"all">;
+}, z.core.$strict>], "scope">;
+declare const mediaUsageRepairCollectionSummarySchema: z.ZodObject<{
+  collection: z.ZodString;
+  status: z.ZodEnum<{
+    failed: "failed";
+    complete: "complete";
+    partial: "partial";
+    stale: "stale";
+  }>;
+  indexedSourceCount: z.ZodNumber;
+  failedSourceCount: z.ZodNumber;
+  skippedSourceCount: z.ZodNumber;
+  deletedSourceCount: z.ZodNumber;
+  lastErrorCode: z.ZodNullable<z.ZodString>;
+  startedAt: z.ZodString;
+  completedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const mediaUsageRepairResponseSchema: z.ZodObject<{
+  status: z.ZodEnum<{
+    failed: "failed";
+    complete: "complete";
+    partial: "partial";
+    stale: "stale";
+  }>;
+  indexedSourceCount: z.ZodNumber;
+  failedSourceCount: z.ZodNumber;
+  skippedSourceCount: z.ZodNumber;
+  deletedSourceCount: z.ZodNumber;
+  collections: z.ZodArray<z.ZodObject<{
+    collection: z.ZodString;
+    status: z.ZodEnum<{
+      failed: "failed";
+      complete: "complete";
+      partial: "partial";
+      stale: "stale";
+    }>;
+    indexedSourceCount: z.ZodNumber;
+    failedSourceCount: z.ZodNumber;
+    skippedSourceCount: z.ZodNumber;
+    deletedSourceCount: z.ZodNumber;
+    lastErrorCode: z.ZodNullable<z.ZodString>;
+    startedAt: z.ZodString;
+    completedAt: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type MediaUsageRepairRequest = z.infer<typeof mediaUsageRepairBody>;
+type MediaUsageRepairResponse = z.infer<typeof mediaUsageRepairResponseSchema>;
+//#endregion
 //#region src/api/schemas/schema.d.ts
 declare const createCollectionBody: z.ZodObject<{
   slug: z.ZodString;
@@ -626,14 +688,14 @@ declare const createFieldBody: z.ZodObject<{
     string: "string";
     number: "number";
     boolean: "boolean";
+    file: "file";
     slug: "slug";
-    text: "text";
     url: "url";
-    select: "select";
-    file: "file";
     image: "image";
     datetime: "datetime";
+    text: "text";
     integer: "integer";
+    select: "select";
     multiSelect: "multiSelect";
     portableText: "portableText";
     reference: "reference";
@@ -657,12 +719,12 @@ declare const createFieldBody: z.ZodObject<{
         string: "string";
         number: "number";
         boolean: "boolean";
-        text: "text";
         url: "url";
-        select: "select";
         image: "image";
         datetime: "datetime";
+        text: "text";
         integer: "integer";
+        select: "select";
       }>;
       label: z.ZodString;
       required: z.ZodOptional<z.ZodBoolean>;
@@ -684,14 +746,14 @@ declare const updateFieldBody: z.ZodObject<{
     string: "string";
     number: "number";
     boolean: "boolean";
+    file: "file";
     slug: "slug";
-    text: "text";
     url: "url";
-    select: "select";
-    file: "file";
     image: "image";
     datetime: "datetime";
+    text: "text";
     integer: "integer";
+    select: "select";
     multiSelect: "multiSelect";
     portableText: "portableText";
     reference: "reference";
@@ -715,12 +777,12 @@ declare const updateFieldBody: z.ZodObject<{
         string: "string";
         number: "number";
         boolean: "boolean";
-        text: "text";
         url: "url";
-        select: "select";
         image: "image";
         datetime: "datetime";
+        text: "text";
         integer: "integer";
+        select: "select";
       }>;
       label: z.ZodString;
       required: z.ZodOptional<z.ZodBoolean>;
@@ -773,14 +835,14 @@ declare const fieldSchema: z.ZodObject<{
     string: "string";
     number: "number";
     boolean: "boolean";
+    file: "file";
     slug: "slug";
-    text: "text";
     url: "url";
-    select: "select";
-    file: "file";
     image: "image";
     datetime: "datetime";
+    text: "text";
     integer: "integer";
+    select: "select";
     multiSelect: "multiSelect";
     portableText: "portableText";
     reference: "reference";
@@ -838,14 +900,14 @@ declare const collectionWithFieldsResponseSchema: z.ZodObject<{
         string: "string";
         number: "number";
         boolean: "boolean";
+        file: "file";
         slug: "slug";
-        text: "text";
         url: "url";
-        select: "select";
-        file: "file";
         image: "image";
         datetime: "datetime";
+        text: "text";
         integer: "integer";
+        select: "select";
         multiSelect: "multiSelect";
         portableText: "portableText";
         reference: "reference";
@@ -892,14 +954,14 @@ declare const fieldResponseSchema: z.ZodObject<{
       string: "string";
       number: "number";
       boolean: "boolean";
+      file: "file";
       slug: "slug";
-      text: "text";
       url: "url";
-      select: "select";
-      file: "file";
       image: "image";
       datetime: "datetime";
+      text: "text";
       integer: "integer";
+      select: "select";
       multiSelect: "multiSelect";
       portableText: "portableText";
       reference: "reference";
@@ -929,14 +991,14 @@ declare const fieldListResponseSchema: z.ZodObject<{
       string: "string";
       number: "number";
       boolean: "boolean";
+      file: "file";
       slug: "slug";
-      text: "text";
       url: "url";
-      select: "select";
-      file: "file";
       image: "image";
       datetime: "datetime";
+      text: "text";
       integer: "integer";
+      select: "select";
       multiSelect: "multiSelect";
       portableText: "portableText";
       reference: "reference";
@@ -976,6 +1038,7 @@ declare const createCommentBody: z.ZodObject<{
   body: z.ZodString;
   parentId: z.ZodOptional<z.ZodString>;
   website_url: z.ZodOptional<z.ZodString>;
+  turnstileToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 declare const createReactionBody: z.ZodObject<{
   commentId: z.ZodString;
@@ -1594,6 +1657,7 @@ declare const searchQuery: z.ZodObject<{
   status: z.ZodOptional<z.ZodString>;
   locale: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
   limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  cursor: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 declare const searchSuggestQuery: z.ZodObject<{
   q: z.ZodString;
@@ -2139,8 +2203,8 @@ declare const bylineFieldCreateBody: z.ZodObject<{
   type: z.ZodEnum<{
     string: "string";
     boolean: "boolean";
-    text: "text";
     url: "url";
+    text: "text";
     select: "select";
   }>;
   required: z.ZodOptional<z.ZodBoolean>;
@@ -2175,8 +2239,8 @@ declare const bylineFieldDefinitionSchema: z.ZodObject<{
   type: z.ZodEnum<{
     string: "string";
     boolean: "boolean";
-    text: "text";
     url: "url";
+    text: "text";
     select: "select";
   }>;
   required: z.ZodBoolean;
@@ -2196,8 +2260,8 @@ declare const bylineFieldListResponseSchema: z.ZodObject<{
     type: z.ZodEnum<{
       string: "string";
       boolean: "boolean";
-      text: "text";
       url: "url";
+      text: "text";
       select: "select";
     }>;
     required: z.ZodBoolean;
@@ -2226,5 +2290,94 @@ declare const bylineFieldUsageResponseSchema: z.ZodObject<{
   totalAffectedRows: z.ZodNumber;
 }, z.core.$strip>;
 //#endregion
-export { wpRewriteUrlsBody as $, trashedContentItemSchema as $n, commentSchema as $t, reorderWidgetsBody as A, mediaProviderListQuery as An, menuSchema as At, userSchema as B, contentListQuery as Bn, magicLinkSendBody as Bt, notFoundSummarySchema as C, formatFileSize as Cn, termWithCountSchema as Ct, updateRedirectBody as D, mediaItemSchema as Dn, menuItemSchema as Dt, redirectsListQuery as E, mediaExistingResponseSchema as En, createMenuItemBody as Et, widgetSchema as F, contentAuthorSchema as Fn, updateMenuItemBody as Ft, setupAdminVerifyBody as G, contentScheduleBody as Gn, passkeyVerifyBody as Gt, usersListQuery as H, contentPreviewUrlBody as Hn, passkeyRegisterOptionsBody as Ht, allowedDomainCreateBody as I, contentAuthorsResponseSchema as In, authMeActionBody as It, importProbeBody as J, contentTermsBody as Jn, adminCommentListResponseSchema as Jt, setupAtprotoAdminBody as K, contentSeoInput as Kn, signupCompleteBody as Kt, allowedDomainUpdateBody as L, contentCompareResponseSchema as Ln, inviteCompleteBody as Lt, widgetAreaSchema as M, mediaUpdateBody as Mn, menuWithItemsSchema as Mt, widgetAreaWithWidgetsAndCountSchema as N, mediaUploadUrlBody as Nn, reorderMenuItemsBody as Nt, createWidgetAreaBody as O, mediaListQuery as On, menuItemTypeEnum as Ot, widgetAreaWithWidgetsSchema as P, mediaUploadUrlResponseSchema as Pn, updateMenuBody as Pt, wpPrepareBody as Q, contentUpdateBody as Qn, commentListQuery as Qt, userDetailSchema as R, contentCreateBody as Rn, inviteCreateBody as Rt, notFoundSummaryResponseSchema as S, DEFAULT_MAX_UPLOAD_SIZE as Sn, termTranslationsSchema as St, redirectSchema as T, mediaConfirmResponseSchema as Tn, createMenuBody as Tt, atprotoLoginBody as U, contentPublishBody as Un, passkeyRegisterVerifyBody as Ut, userUpdateBody as V, contentListResponseSchema as Vn, passkeyOptionsBody as Vt, setupAdminBody as W, contentResponseSchema as Wn, passkeyRenameBody as Wt, wpPluginAnalyzeBody as X, contentTranslationsResponseSchema as Xn, commentBulkResponseSchema as Xt, wpMediaImportBody as Y, contentTranslationSchema as Yn, commentBulkBody as Yt, wpPluginExecuteBody as Z, contentTrashQuery as Zn, commentCountsResponseSchema as Zt, notFoundEntrySchema as _, orphanedTableListResponseSchema as _n, taxonomyListResponseSchema as _t, bylineFieldUpdateBody as a, collectionGetQuery as an, deleteResponseSchema as ar, searchSuggestQuery as at, notFoundPruneBody as b, updateCollectionBody as bn, termResponseSchema as bt, bylineCreditSchema as c, collectionSchema as cn, localeFilterQuery as cr, createSectionBody as ct, bylineTranslationCreateBody as d, createFieldBody as dn, slugPattern as dr, sectionsListQuery as dt, commentStatusBody as en, trashedContentListResponseSchema as er, searchEnableBody as et, bylineTranslationsResponseSchema as f, fieldListResponseSchema as fn, successEnvelope as fr, updateSectionBody as ft, createRedirectBody as g, orphanRegisterBody as gn, taxonomyDefTranslationsSchema as gt, contentBylineInputSchema as h, fieldSchema as hn, taxonomyDefSchema as ht, bylineFieldReorderBody as i, publicCommentSchema as in, cursorPaginationQuery as ir, searchResultSchema as it, updateWidgetBody as j, mediaResponseSchema as jn, menuTranslationsSchema as jt, createWidgetBody as k, mediaListResponseSchema as kn, menuListItemSchema as kt, bylineListResponseSchema as l, collectionWithFieldsResponseSchema as ln, offsetPaginationQuery as lr, sectionListResponseSchema as lt, bylinesListQuery as m, fieldResponseSchema as mn, createTermBody as mt, bylineFieldDefinitionSchema as n, createReactionBody as nn, apiErrorSchema as nr, searchRebuildBody as nt, bylineFieldUsageResponseSchema as o, collectionListResponseSchema as on, httpUrl as or, settingsUpdateBody as ot, bylineUpdateBody as p, fieldReorderBody as pn, createTaxonomyDefBody as pt, setupBody as q, contentSeoSchema as qn, signupRequestBody as qt, bylineFieldListResponseSchema as r, publicCommentListResponseSchema as rn, countResponseSchema as rr, searchResponseSchema as rt, bylineCreateBody as s, collectionResponseSchema as sn, localeCode as sr, siteSettingsSchema as st, bylineFieldCreateBody as t, createCommentBody as tn, VALID_ROLE_LEVELS as tr, searchQuery as tt, bylineSummarySchema as u, createCollectionBody as un, roleLevel as ur, sectionSchema as ut, notFoundListQuery as v, orphanedTableSchema as vn, termGetResponseSchema as vt, redirectListResponseSchema as w, mediaConfirmBody as wn, updateTermBody as wt, notFoundSummaryQuery as x, updateFieldBody as xn, termSchema as xt, notFoundListResponseSchema as y, schemaExportQuery as yn, termListResponseSchema as yt, userListResponseSchema as z, contentItemSchema as zn, inviteRegisterOptionsBody as zt };
-//# sourceMappingURL=byline-fields-Cgrt9-aL.d.mts.map
+//#region src/api/schemas/relations.d.ts
+declare const createRelationBody: z.ZodObject<{
+  name: z.ZodString;
+  parentCollection: z.ZodOptional<z.ZodString>;
+  childCollection: z.ZodOptional<z.ZodString>;
+  parentLabel: z.ZodString;
+  childLabel: z.ZodString;
+  locale: z.ZodOptional<z.ZodString>;
+  translationOf: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const updateRelationBody: z.ZodObject<{
+  parentLabel: z.ZodOptional<z.ZodString>;
+  childLabel: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const setReferenceChildrenBody: z.ZodObject<{
+  childIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const relationDefSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  parentCollection: z.ZodString;
+  childCollection: z.ZodString;
+  parentLabel: z.ZodString;
+  childLabel: z.ZodString;
+  locale: z.ZodString;
+  translationGroup: z.ZodString;
+}, z.core.$strip>;
+declare const relationListResponseSchema: z.ZodObject<{
+  relations: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    parentCollection: z.ZodString;
+    childCollection: z.ZodString;
+    parentLabel: z.ZodString;
+    childLabel: z.ZodString;
+    locale: z.ZodString;
+    translationGroup: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const relationResponseSchema: z.ZodObject<{
+  relation: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    parentCollection: z.ZodString;
+    childCollection: z.ZodString;
+    parentLabel: z.ZodString;
+    childLabel: z.ZodString;
+    locale: z.ZodString;
+    translationGroup: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const relationTranslationsSchema: z.ZodObject<{
+  translationGroup: z.ZodString;
+  translations: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    locale: z.ZodString;
+    parentLabel: z.ZodString;
+    childLabel: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const entryRefSchema: z.ZodObject<{
+  id: z.ZodString;
+  slug: z.ZodNullable<z.ZodString>;
+  collection: z.ZodString;
+  locale: z.ZodNullable<z.ZodString>;
+  sortOrder: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const referenceChildrenResponseSchema: z.ZodObject<{
+  children: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodNullable<z.ZodString>;
+    collection: z.ZodString;
+    locale: z.ZodNullable<z.ZodString>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  nextCursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const referenceParentsResponseSchema: z.ZodObject<{
+  parents: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodNullable<z.ZodString>;
+    collection: z.ZodString;
+    locale: z.ZodNullable<z.ZodString>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  nextCursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//#endregion
+export { atprotoLoginBody as $, contentCompareResponseSchema as $n, passkeyRegisterVerifyBody as $t, notFoundPruneBody as A, updateCollectionBody as An, termResponseSchema as At, reorderWidgetsBody as B, mediaConfirmBody as Bn, menuSchema as Bt, bylineUpdateBody as C, fieldReorderBody as Cn, localeCode as Cr, createTaxonomyDefBody as Ct, notFoundEntrySchema as D, orphanedTableListResponseSchema as Dn, slugPattern as Dr, taxonomyListResponseSchema as Dt, createRedirectBody as E, orphanRegisterBody as En, roleLevel as Er, taxonomyDefTranslationsSchema as Et, redirectSchema as F, mediaUsageRepairCollectionSummarySchema as Fn, createMenuBody as Ft, widgetSchema as G, mediaListResponseSchema as Gn, updateMenuItemBody as Gt, widgetAreaSchema as H, mediaExistingResponseSchema as Hn, menuWithItemsSchema as Ht, redirectsListQuery as I, mediaUsageRepairResponseSchema as In, createMenuItemBody as It, userDetailSchema as J, mediaUpdateBody as Jn, inviteCreateBody as Jt, allowedDomainCreateBody as K, mediaProviderListQuery as Kn, authMeActionBody as Kt, updateRedirectBody as L, mediaUsageRepairStatusSchema as Ln, menuItemSchema as Lt, notFoundSummaryResponseSchema as M, MediaUsageRepairRequest as Mn, termTranslationsSchema as Mt, notFoundSummarySchema as N, MediaUsageRepairResponse as Nn, termWithCountSchema as Nt, notFoundListQuery as O, orphanedTableSchema as On, successEnvelope as Or, termGetResponseSchema as Ot, redirectListResponseSchema as P, mediaUsageRepairBody as Pn, updateTermBody as Pt, usersListQuery as Q, contentAuthorsResponseSchema as Qn, passkeyRegisterOptionsBody as Qt, createWidgetAreaBody as R, DEFAULT_MAX_UPLOAD_SIZE as Rn, menuItemTypeEnum as Rt, bylineTranslationsResponseSchema as S, fieldListResponseSchema as Sn, httpUrl as Sr, updateSectionBody as St, contentBylineInputSchema as T, fieldSchema as Tn, offsetPaginationQuery as Tr, taxonomyDefSchema as Tt, widgetAreaWithWidgetsAndCountSchema as U, mediaItemSchema as Un, reorderMenuItemsBody as Ut, updateWidgetBody as V, mediaConfirmResponseSchema as Vn, menuTranslationsSchema as Vt, widgetAreaWithWidgetsSchema as W, mediaListQuery as Wn, updateMenuBody as Wt, userSchema as X, mediaUploadUrlResponseSchema as Xn, magicLinkSendBody as Xt, userListResponseSchema as Y, mediaUploadUrlBody as Yn, inviteRegisterOptionsBody as Yt, userUpdateBody as Z, contentAuthorSchema as Zn, passkeyOptionsBody as Zt, bylineCreateBody as _, collectionResponseSchema as _n, VALID_ROLE_LEVELS as _r, siteSettingsSchema as _t, relationDefSchema as a, commentBulkBody as an, contentPublishBody as ar, wpMediaImportBody as at, bylineSummarySchema as b, createCollectionBody as bn, cursorPaginationQuery as br, sectionSchema as bt, relationTranslationsSchema as c, commentListQuery as cn, contentSeoInput as cr, wpPrepareBody as ct, bylineFieldCreateBody as d, createCommentBody as dn, contentTranslationSchema as dr, searchQuery as dt, passkeyRenameBody as en, contentCreateBody as er, setupAdminBody as et, bylineFieldDefinitionSchema as f, createReactionBody as fn, contentTranslationsResponseSchema as fr, searchRebuildBody as ft, bylineFieldUsageResponseSchema as g, collectionListResponseSchema as gn, trashedContentListResponseSchema as gr, settingsUpdateBody as gt, bylineFieldUpdateBody as h, collectionGetQuery as hn, trashedContentItemSchema as hr, searchSuggestQuery as ht, referenceParentsResponseSchema as i, adminCommentListResponseSchema as in, contentPreviewUrlBody as ir, importProbeBody as it, notFoundSummaryQuery as j, updateFieldBody as jn, termSchema as jt, notFoundListResponseSchema as k, schemaExportQuery as kn, termListResponseSchema as kt, setReferenceChildrenBody as l, commentSchema as ln, contentSeoSchema as lr, wpRewriteUrlsBody as lt, bylineFieldReorderBody as m, publicCommentSchema as mn, contentUpdateBody as mr, searchResultSchema as mt, entryRefSchema as n, signupCompleteBody as nn, contentListQuery as nr, setupAtprotoAdminBody as nt, relationListResponseSchema as o, commentBulkResponseSchema as on, contentResponseSchema as or, wpPluginAnalyzeBody as ot, bylineFieldListResponseSchema as p, publicCommentListResponseSchema as pn, contentTrashQuery as pr, searchResponseSchema as pt, allowedDomainUpdateBody as q, mediaResponseSchema as qn, inviteCompleteBody as qt, referenceChildrenResponseSchema as r, signupRequestBody as rn, contentListResponseSchema as rr, setupBody as rt, relationResponseSchema as s, commentCountsResponseSchema as sn, contentScheduleBody as sr, wpPluginExecuteBody as st, createRelationBody as t, passkeyVerifyBody as tn, contentItemSchema as tr, setupAdminVerifyBody as tt, updateRelationBody as u, commentStatusBody as un, contentTermsBody as ur, searchEnableBody as ut, bylineCreditSchema as v, collectionSchema as vn, apiErrorSchema as vr, createSectionBody as vt, bylinesListQuery as w, fieldResponseSchema as wn, localeFilterQuery as wr, createTermBody as wt, bylineTranslationCreateBody as x, createFieldBody as xn, deleteResponseSchema as xr, sectionsListQuery as xt, bylineListResponseSchema as y, collectionWithFieldsResponseSchema as yn, countResponseSchema as yr, sectionListResponseSchema as yt, createWidgetBody as z, formatFileSize as zn, menuListItemSchema as zt };
+//# sourceMappingURL=relations-CbBpoOys.d.mts.map

package/dist/relations-CbBpoOys.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations-CbBpoOys.d.mts","names":[],"sources":["../src/api/schemas/common.ts","../src/api/schemas/content.ts","../src/api/schemas/media.ts","../src/api/schemas/media-usage.ts","../src/api/schemas/schema.ts","../src/api/schemas/comments.ts","../src/api/schemas/auth.ts","../src/api/schemas/menus.ts","../src/api/schemas/taxonomies.ts","../src/api/schemas/sections.ts","../src/api/schemas/settings.ts","../src/api/schemas/search.ts","../src/api/schemas/import.ts","../src/api/schemas/setup.ts","../src/api/schemas/users.ts","../src/api/schemas/widgets.ts","../src/api/schemas/redirects.ts","../src/api/schemas/bylines.ts","../src/api/schemas/byline-fields.ts","../src/api/schemas/relations.ts"],"mappings":"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"}

package/dist/{request-cache-KCNHp_RJ.mjs → request-cache-BSUptuJR.mjs}

@@ -101,4 +101,4 @@ function clearRequestCacheEntry(key) {
 
 //#endregion
 export { setRequestCacheEntry as i, peekRequestCache as n, requestCached as r, clearRequestCacheEntry as t };
-//# sourceMappingURL=request-cache-KCNHp_RJ.mjs.map
+//# sourceMappingURL=request-cache-BSUptuJR.mjs.map

package/dist/{request-cache-KCNHp_RJ.mjs.map → request-cache-BSUptuJR.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"request-cache-KCNHp_RJ.mjs","names":[],"sources":["../src/request-cache.ts"],"sourcesContent":["/**\n * Per-request query cache\n *\n * Deduplicates identical database queries within a single page render.\n * Uses the ALS request context as a WeakMap key so the cache is\n * automatically GC'd when the request completes.\n *\n * When no request context is available (e.g. local dev without D1\n * replicas), queries bypass the cache — local SQLite is fast enough\n * that deduplication doesn't matter.\n *\n * The WeakMap is stored on globalThis with a Symbol key to guarantee\n * a singleton even when bundlers duplicate this module across chunks\n * (same pattern as request-context.ts).\n */\n\nimport type { EmDashRequestContext } from \"./request-context.js\";\nimport { getRequestContext } from \"./request-context.js\";\n\ntype CacheStore = WeakMap<EmDashRequestContext, Map<string, Promise<unknown>>>;\n\nconst STORE_KEY = Symbol.for(\"emdash:request-cache\");\nconst g = globalThis as Record<symbol, unknown>;\nconst store: CacheStore =\n\t// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern (see request-context.ts)\n\t(g[STORE_KEY] as CacheStore | undefined) ??\n\t(() => {\n\t\tconst wm: CacheStore = new WeakMap();\n\t\tg[STORE_KEY] = wm;\n\t\treturn wm;\n\t})();\n\n/**\n * Return a cached result for `key` if one exists in the current\n * request scope, otherwise call `fn`, cache its promise, and return it.\n *\n * Caches the *promise*, not the resolved value, so concurrent calls\n * with the same key share a single in-flight query.\n */\nexport function requestCached<T>(key: string, fn: () => Promise<T>): Promise<T> {\n\tconst ctx = getRequestContext();\n\tif (!ctx) return fn();\n\n\tlet cache = store.get(ctx);\n\tif (!cache) {\n\t\tcache = new Map();\n\t\tstore.set(ctx, cache);\n\t}\n\n\tconst existing = cache.get(key);\n\tif (existing) {\n\t\tif (ctx.metrics) ctx.metrics.cacheHits += 1;\n\t\t// eslint-disable-next-line typescript/no-unsafe-type-assertion -- heterogeneous cache; key namespacing guarantees the stored promise resolves to T\n\t\treturn existing as Promise<T>;\n\t}\n\tif (ctx.metrics) ctx.metrics.cacheMisses += 1;\n\n\tconst promise = Promise.resolve()\n\t\t.then(fn)\n\t\t.catch((error) => {\n\t\t\tcache.delete(key);\n\t\t\tthrow error;\n\t\t});\n\tcache.set(key, promise);\n\treturn promise;\n}\n\n/**\n * Look up an entry in the request-scoped cache without inserting one.\n *\n * Returns the in-flight or resolved promise if the key exists in the\n * current request, otherwise `undefined`. Callers can use this to\n * opportunistically satisfy a narrower query (e.g. `getSiteSetting(\"seo\")`)\n * from a broader one (`getSiteSettings()`) that's already been loaded\n * by a parent template — avoiding a redundant round-trip.\n *\n * No-ops outside a request context.\n */\nexport function peekRequestCache<T>(key: string): Promise<T> | undefined {\n\tconst ctx = getRequestContext();\n\tif (!ctx) return undefined;\n\tconst cache = store.get(ctx);\n\t// eslint-disable-next-line typescript/no-unsafe-type-assertion -- heterogeneous cache; caller is responsible for using a T-compatible key\n\treturn cache?.get(key) as Promise<T> | undefined;\n}\n\n/**\n * Pre-populate the request-scoped cache with a resolved value.\n *\n * Internal helper shared between hydration paths (taxonomy terms,\n * bylines, etc.) that already have the data in hand and want downstream\n * callers using `requestCached(key, ...)` to skip the database entirely.\n * Not exported from the package entrypoint — keep it internal until we\n * have a documented plugin/extension surface for hydration.\n *\n * No-ops outside a request context (local dev without ALS).\n *\n * Does not overwrite an existing entry — if a query for this key is already\n * in flight, its promise wins.\n */\nexport function setRequestCacheEntry<T>(key: string, value: T): void {\n\tconst ctx = getRequestContext();\n\tif (!ctx) return;\n\n\tlet cache = store.get(ctx);\n\tif (!cache) {\n\t\tcache = new Map();\n\t\tstore.set(ctx, cache);\n\t}\n\n\tif (cache.has(key)) return;\n\tcache.set(key, Promise.resolve(value));\n}\n\n/**\n * Remove a key from the request-scoped cache.\n *\n * Used by write paths that need to invalidate a downstream read cache —\n * `setRequestCacheEntry` deliberately doesn't overwrite, and `requestCached`\n * returns the cached promise even after the underlying data has changed.\n * Without an explicit clear, a `read → write → read` sequence in a single\n * request can return stale data on the second read.\n *\n * Concrete case: `BylineRepository.update` invalidates\n * `byline-field-group-values:${translation_group}` after writing a\n * non-translatable custom-field value, so the post-update `findById`\n * (and any later reads in the same request) see the fresh value.\n *\n * No-ops outside a request context.\n */\nexport function clearRequestCacheEntry(key: string): void {\n\tconst ctx = getRequestContext();\n\tif (!ctx) return;\n\tconst cache = store.get(ctx);\n\tcache?.delete(key);\n}\n"],"mappings":";;;AAqBA,MAAM,YAAY,OAAO,IAAI,uBAAuB;AACpD,MAAM,IAAI;AACV,MAAM,QAEJ,EAAE,qBACI;CACN,MAAM,qBAAiB,IAAI,SAAS;AACpC,GAAE,aAAa;AACf,QAAO;IACJ;;;;;;;;AASL,SAAgB,cAAiB,KAAa,IAAkC;CAC/E,MAAM,MAAM,mBAAmB;AAC/B,KAAI,CAAC,IAAK,QAAO,IAAI;CAErB,IAAI,QAAQ,MAAM,IAAI,IAAI;AAC1B,KAAI,CAAC,OAAO;AACX,0BAAQ,IAAI,KAAK;AACjB,QAAM,IAAI,KAAK,MAAM;;CAGtB,MAAM,WAAW,MAAM,IAAI,IAAI;AAC/B,KAAI,UAAU;AACb,MAAI,IAAI,QAAS,KAAI,QAAQ,aAAa;AAE1C,SAAO;;AAER,KAAI,IAAI,QAAS,KAAI,QAAQ,eAAe;CAE5C,MAAM,UAAU,QAAQ,SAAS,CAC/B,KAAK,GAAG,CACR,OAAO,UAAU;AACjB,QAAM,OAAO,IAAI;AACjB,QAAM;GACL;AACH,OAAM,IAAI,KAAK,QAAQ;AACvB,QAAO;;;;;;;;;;;;;AAcR,SAAgB,iBAAoB,KAAqC;CACxE,MAAM,MAAM,mBAAmB;AAC/B,KAAI,CAAC,IAAK,QAAO;AAGjB,QAFc,MAAM,IAAI,IAAI,EAEd,IAAI,IAAI;;;;;;;;;;;;;;;;AAiBvB,SAAgB,qBAAwB,KAAa,OAAgB;CACpE,MAAM,MAAM,mBAAmB;AAC/B,KAAI,CAAC,IAAK;CAEV,IAAI,QAAQ,MAAM,IAAI,IAAI;AAC1B,KAAI,CAAC,OAAO;AACX,0BAAQ,IAAI,KAAK;AACjB,QAAM,IAAI,KAAK,MAAM;;AAGtB,KAAI,MAAM,IAAI,IAAI,CAAE;AACpB,OAAM,IAAI,KAAK,QAAQ,QAAQ,MAAM,CAAC;;;;;;;;;;;;;;;;;;AAmBvC,SAAgB,uBAAuB,KAAmB;CACzD,MAAM,MAAM,mBAAmB;AAC/B,KAAI,CAAC,IAAK;AAEV,CADc,MAAM,IAAI,IAAI,EACrB,OAAO,IAAI"}
+{"version":3,"file":"request-cache-BSUptuJR.mjs","names":[],"sources":["../src/request-cache.ts"],"sourcesContent":["/**\n * Per-request query cache\n *\n * Deduplicates identical database queries within a single page render.\n * Uses the ALS request context as a WeakMap key so the cache is\n * automatically GC'd when the request completes.\n *\n * When no request context is available (e.g. local dev without D1\n * replicas), queries bypass the cache — local SQLite is fast enough\n * that deduplication doesn't matter.\n *\n * The WeakMap is stored on globalThis with a Symbol key to guarantee\n * a singleton even when bundlers duplicate this module across chunks\n * (same pattern as request-context.ts).\n */\n\nimport type { EmDashRequestContext } from \"./request-context.js\";\nimport { getRequestContext } from \"./request-context.js\";\n\ntype CacheStore = WeakMap<EmDashRequestContext, Map<string, Promise<unknown>>>;\n\nconst STORE_KEY = Symbol.for(\"emdash:request-cache\");\nconst g = globalThis as Record<symbol, unknown>;\nconst store: CacheStore =\n\t// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern (see request-context.ts)\n\t(g[STORE_KEY] as CacheStore | undefined) ??\n\t(() => {\n\t\tconst wm: CacheStore = new WeakMap();\n\t\tg[STORE_KEY] = wm;\n\t\treturn wm;\n\t})();\n\n/**\n * Return a cached result for `key` if one exists in the current\n * request scope, otherwise call `fn`, cache its promise, and return it.\n *\n * Caches the *promise*, not the resolved value, so concurrent calls\n * with the same key share a single in-flight query.\n */\nexport function requestCached<T>(key: string, fn: () => Promise<T>): Promise<T> {\n\tconst ctx = getRequestContext();\n\tif (!ctx) return fn();\n\n\tlet cache = store.get(ctx);\n\tif (!cache) {\n\t\tcache = new Map();\n\t\tstore.set(ctx, cache);\n\t}\n\n\tconst existing = cache.get(key);\n\tif (existing) {\n\t\tif (ctx.metrics) ctx.metrics.cacheHits += 1;\n\t\t// eslint-disable-next-line typescript/no-unsafe-type-assertion -- heterogeneous cache; key namespacing guarantees the stored promise resolves to T\n\t\treturn existing as Promise<T>;\n\t}\n\tif (ctx.metrics) ctx.metrics.cacheMisses += 1;\n\n\tconst promise = Promise.resolve()\n\t\t.then(fn)\n\t\t.catch((error) => {\n\t\t\tcache.delete(key);\n\t\t\tthrow error;\n\t\t});\n\tcache.set(key, promise);\n\treturn promise;\n}\n\n/**\n * Look up an entry in the request-scoped cache without inserting one.\n *\n * Returns the in-flight or resolved promise if the key exists in the\n * current request, otherwise `undefined`. Callers can use this to\n * opportunistically satisfy a narrower query (e.g. `getSiteSetting(\"seo\")`)\n * from a broader one (`getSiteSettings()`) that's already been loaded\n * by a parent template — avoiding a redundant round-trip.\n *\n * No-ops outside a request context.\n */\nexport function peekRequestCache<T>(key: string): Promise<T> | undefined {\n\tconst ctx = getRequestContext();\n\tif (!ctx) return undefined;\n\tconst cache = store.get(ctx);\n\t// eslint-disable-next-line typescript/no-unsafe-type-assertion -- heterogeneous cache; caller is responsible for using a T-compatible key\n\treturn cache?.get(key) as Promise<T> | undefined;\n}\n\n/**\n * Pre-populate the request-scoped cache with a resolved value.\n *\n * Internal helper shared between hydration paths (taxonomy terms,\n * bylines, etc.) that already have the data in hand and want downstream\n * callers using `requestCached(key, ...)` to skip the database entirely.\n * Not exported from the package entrypoint — keep it internal until we\n * have a documented plugin/extension surface for hydration.\n *\n * No-ops outside a request context (local dev without ALS).\n *\n * Does not overwrite an existing entry — if a query for this key is already\n * in flight, its promise wins.\n */\nexport function setRequestCacheEntry<T>(key: string, value: T): void {\n\tconst ctx = getRequestContext();\n\tif (!ctx) return;\n\n\tlet cache = store.get(ctx);\n\tif (!cache) {\n\t\tcache = new Map();\n\t\tstore.set(ctx, cache);\n\t}\n\n\tif (cache.has(key)) return;\n\tcache.set(key, Promise.resolve(value));\n}\n\n/**\n * Remove a key from the request-scoped cache.\n *\n * Used by write paths that need to invalidate a downstream read cache —\n * `setRequestCacheEntry` deliberately doesn't overwrite, and `requestCached`\n * returns the cached promise even after the underlying data has changed.\n * Without an explicit clear, a `read → write → read` sequence in a single\n * request can return stale data on the second read.\n *\n * Concrete case: `BylineRepository.update` invalidates\n * `byline-field-group-values:${translation_group}` after writing a\n * non-translatable custom-field value, so the post-update `findById`\n * (and any later reads in the same request) see the fresh value.\n *\n * No-ops outside a request context.\n */\nexport function clearRequestCacheEntry(key: string): void {\n\tconst ctx = getRequestContext();\n\tif (!ctx) return;\n\tconst cache = store.get(ctx);\n\tcache?.delete(key);\n}\n"],"mappings":";;;AAqBA,MAAM,YAAY,OAAO,IAAI,uBAAuB;AACpD,MAAM,IAAI;AACV,MAAM,QAEJ,EAAE,qBACI;CACN,MAAM,qBAAiB,IAAI,SAAS;AACpC,GAAE,aAAa;AACf,QAAO;IACJ;;;;;;;;AASL,SAAgB,cAAiB,KAAa,IAAkC;CAC/E,MAAM,MAAM,mBAAmB;AAC/B,KAAI,CAAC,IAAK,QAAO,IAAI;CAErB,IAAI,QAAQ,MAAM,IAAI,IAAI;AAC1B,KAAI,CAAC,OAAO;AACX,0BAAQ,IAAI,KAAK;AACjB,QAAM,IAAI,KAAK,MAAM;;CAGtB,MAAM,WAAW,MAAM,IAAI,IAAI;AAC/B,KAAI,UAAU;AACb,MAAI,IAAI,QAAS,KAAI,QAAQ,aAAa;AAE1C,SAAO;;AAER,KAAI,IAAI,QAAS,KAAI,QAAQ,eAAe;CAE5C,MAAM,UAAU,QAAQ,SAAS,CAC/B,KAAK,GAAG,CACR,OAAO,UAAU;AACjB,QAAM,OAAO,IAAI;AACjB,QAAM;GACL;AACH,OAAM,IAAI,KAAK,QAAQ;AACvB,QAAO;;;;;;;;;;;;;AAcR,SAAgB,iBAAoB,KAAqC;CACxE,MAAM,MAAM,mBAAmB;AAC/B,KAAI,CAAC,IAAK,QAAO;AAGjB,QAFc,MAAM,IAAI,IAAI,EAEd,IAAI,IAAI;;;;;;;;;;;;;;;;AAiBvB,SAAgB,qBAAwB,KAAa,OAAgB;CACpE,MAAM,MAAM,mBAAmB;AAC/B,KAAI,CAAC,IAAK;CAEV,IAAI,QAAQ,MAAM,IAAI,IAAI;AAC1B,KAAI,CAAC,OAAO;AACX,0BAAQ,IAAI,KAAK;AACjB,QAAM,IAAI,KAAK,MAAM;;AAGtB,KAAI,MAAM,IAAI,IAAI,CAAE;AACpB,OAAM,IAAI,KAAK,QAAQ,QAAQ,MAAM,CAAC;;;;;;;;;;;;;;;;;;AAmBvC,SAAgB,uBAAuB,KAAmB;CACzD,MAAM,MAAM,mBAAmB;AAC/B,KAAI,CAAC,IAAK;AAEV,CADc,MAAM,IAAI,IAAI,EACrB,OAAO,IAAI"}

package/dist/{request-meta-DbvXaAvU.mjs → request-meta-DCwktC5P.mjs}

@@ -1,4 +1,4 @@
-import { n as normalizeTrustedHeaders, t as getTrustedProxyHeaders } from "./trusted-proxy-VTPRiX2s.mjs";
+import { n as normalizeTrustedHeaders, t as getTrustedProxyHeaders } from "./trusted-proxy-CSgZVESw.mjs";
 
 //#region src/plugins/request-meta.ts
 /**
@@ -137,4 +137,4 @@ function sanitizeHeadersForSandbox(headers) {
 
 //#endregion
 export { sanitizeHeadersForSandbox as n, extractRequestMeta as t };
-//# sourceMappingURL=request-meta-DbvXaAvU.mjs.map
+//# sourceMappingURL=request-meta-DCwktC5P.mjs.map

package/dist/{request-meta-DbvXaAvU.mjs.map → request-meta-DCwktC5P.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"request-meta-DbvXaAvU.mjs","names":[],"sources":["../src/plugins/request-meta.ts"],"sourcesContent":["/**\n * Request Metadata Extraction\n *\n * Extracts normalized metadata (IP, user agent, referer, geo) from\n * incoming requests. Used by plugin route handlers to access request\n * context without touching raw headers.\n *\n */\n\nimport type { EmDashConfig } from \"../astro/integration/runtime.js\";\nimport { getTrustedProxyHeaders, normalizeTrustedHeaders } from \"../auth/trusted-proxy.js\";\nimport type { GeoInfo, RequestMeta } from \"./types.js\";\n\n/**\n * Cloudflare Workers `cf` object shape (subset we use).\n * Present on requests when running on Cloudflare Workers.\n */\ninterface CfProperties {\n\tcountry?: string;\n\tregion?: string;\n\tcity?: string;\n}\n\n/**\n * Loose validation for IPv4 and IPv6 addresses.\n * Accepts digits, hex chars, dots, and colons — rejects anything else\n * (e.g. HTML tags, scripts, or other non-IP garbage in spoofed headers).\n */\nconst IP_PATTERN = /^[\\da-fA-F.:]+$/;\n\n/**\n * Extract the first IP from an X-Forwarded-For header value.\n * The header may contain a comma-separated list of IPs; the first\n * entry is the original client IP.\n *\n * Returns null if the extracted value doesn't look like an IP address.\n */\nfunction parseFirstForwardedIp(header: string): string | null {\n\tconst first = header.split(\",\")[0];\n\tconst trimmed = first?.trim();\n\tif (!trimmed) return null;\n\treturn IP_PATTERN.test(trimmed) ? trimmed : null;\n}\n\n/**\n * Read an IP from an operator-declared trusted header. XFF-style headers\n * (any name ending in `forwarded-for`) are parsed as comma-separated lists\n * and the first entry is used; everything else is treated as a single\n * trimmed value.\n */\nfunction readIpFromHeader(headers: Headers, name: string): string | null {\n\tconst value = headers.get(name);\n\tif (!value) return null;\n\tif (name.endsWith(\"forwarded-for\")) {\n\t\treturn parseFirstForwardedIp(value);\n\t}\n\tconst trimmed = value.trim();\n\tif (!trimmed) return null;\n\treturn IP_PATTERN.test(trimmed) ? trimmed : null;\n}\n\n/**\n * Get the Cloudflare `cf` object from the request, if present.\n * Returns undefined when not running on Cloudflare Workers.\n */\nfunction getCfObject(request: Request): CfProperties | undefined {\n\treturn (request as unknown as { cf?: CfProperties }).cf;\n}\n\n/**\n * Extract geographic information from the Cloudflare `cf` object\n * attached to the request. Returns null when not running on CF Workers.\n */\nfunction extractGeo(cf: CfProperties | undefined): GeoInfo | null {\n\tif (!cf) return null;\n\n\tconst country = cf.country ?? null;\n\tconst region = cf.region ?? null;\n\tconst city = cf.city ?? null;\n\n\t// Only return geo if at least one field is populated\n\tif (country === null && region === null && city === null) return null;\n\n\treturn { country, region, city };\n}\n\n/**\n * Extract normalized request metadata from a Request object.\n *\n * IP resolution order:\n * 1. `CF-Connecting-IP` — trusted only when a `cf` object is present on the\n *    request. CF edge overwrites any client-supplied value, so this is the\n *    cryptographically trustworthy path on Workers. Operator-declared\n *    trusted headers cannot override it.\n * 2. `X-Forwarded-For` first entry — trusted only with a `cf` object.\n * 3. Operator-declared trusted proxy headers (from `config.trustedProxyHeaders`\n *    or the `EMDASH_TRUSTED_PROXY_HEADERS` env var), tried in order. Used as\n *    the primary source off-CF and as a fill-in on CF.\n * 4. `null`\n *\n * The second argument accepts either the EmDash config or a pre-resolved\n * list of trusted headers, so callers that already have the list don't have\n * to round-trip through the config every request.\n */\nexport function extractRequestMeta(\n\trequest: Request,\n\tconfigOrTrustedHeaders?: EmDashConfig | null | { trustedProxyHeaders?: string[] } | string[],\n): RequestMeta {\n\tconst headers = request.headers;\n\tconst cf = getCfObject(request);\n\tconst trusted = resolveTrustedHeaders(configOrTrustedHeaders);\n\n\tlet ip: string | null = null;\n\n\t// On Cloudflare, prefer the cryptographically trustworthy headers first.\n\tif (cf) {\n\t\tconst cfIp = headers.get(\"cf-connecting-ip\")?.trim();\n\t\tif (cfIp && IP_PATTERN.test(cfIp)) {\n\t\t\tip = cfIp;\n\t\t}\n\t\tif (!ip) {\n\t\t\tconst xff = headers.get(\"x-forwarded-for\");\n\t\t\tip = xff ? parseFirstForwardedIp(xff) : null;\n\t\t}\n\t}\n\n\t// Fall through to operator-declared trusted headers. On CF this fills\n\t// in when the CF headers are absent; off-CF it's the primary source.\n\tif (!ip) {\n\t\tfor (const name of trusted) {\n\t\t\tconst value = readIpFromHeader(headers, name);\n\t\t\tif (value) {\n\t\t\t\tip = value;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\tconst userAgent = headers.get(\"user-agent\")?.trim() || null;\n\tconst referer = headers.get(\"referer\")?.trim() || null;\n\tconst geo = extractGeo(cf);\n\n\treturn { ip, userAgent, referer, geo };\n}\n\nfunction resolveTrustedHeaders(\n\tvalue: EmDashConfig | null | { trustedProxyHeaders?: string[] } | string[] | undefined,\n): string[] {\n\tif (Array.isArray(value)) {\n\t\t// Apply the same RFC 7230 validation the config/env path does so a\n\t\t// caller passing a pre-resolved list with bad entries can't crash\n\t\t// `Headers.get()` downstream.\n\t\treturn normalizeTrustedHeaders(value);\n\t}\n\treturn getTrustedProxyHeaders(value);\n}\n\n// =============================================================================\n// Header Sanitization for Sandbox\n// =============================================================================\n\n/**\n * Headers that must never cross the RPC boundary to sandboxed plugins.\n * Session tokens, auth credentials, and infrastructure headers are stripped\n * to prevent malicious plugins from exfiltrating sensitive data.\n */\nconst SANDBOX_STRIPPED_HEADERS = new Set([\n\t\"cookie\",\n\t\"set-cookie\",\n\t\"authorization\",\n\t\"proxy-authorization\",\n\t\"cf-access-jwt-assertion\",\n\t\"cf-access-client-id\",\n\t\"cf-access-client-secret\",\n\t\"x-emdash-request\",\n]);\n\n/**\n * Copy request headers into a plain object, stripping sensitive headers\n * that must not be exposed to sandboxed plugin code.\n */\nexport function sanitizeHeadersForSandbox(headers: Headers): Record<string, string> {\n\tconst safe: Record<string, string> = {};\n\theaders.forEach((value, key) => {\n\t\tif (!SANDBOX_STRIPPED_HEADERS.has(key)) {\n\t\t\tsafe[key] = value;\n\t\t}\n\t});\n\treturn safe;\n}\n"],"mappings":";;;;;;;;AA4BA,MAAM,aAAa;;;;;;;;AASnB,SAAS,sBAAsB,QAA+B;CAE7D,MAAM,UADQ,OAAO,MAAM,IAAI,CAAC,IACT,MAAM;AAC7B,KAAI,CAAC,QAAS,QAAO;AACrB,QAAO,WAAW,KAAK,QAAQ,GAAG,UAAU;;;;;;;;AAS7C,SAAS,iBAAiB,SAAkB,MAA6B;CACxE,MAAM,QAAQ,QAAQ,IAAI,KAAK;AAC/B,KAAI,CAAC,MAAO,QAAO;AACnB,KAAI,KAAK,SAAS,gBAAgB,CACjC,QAAO,sBAAsB,MAAM;CAEpC,MAAM,UAAU,MAAM,MAAM;AAC5B,KAAI,CAAC,QAAS,QAAO;AACrB,QAAO,WAAW,KAAK,QAAQ,GAAG,UAAU;;;;;;AAO7C,SAAS,YAAY,SAA4C;AAChE,QAAQ,QAA6C;;;;;;AAOtD,SAAS,WAAW,IAA8C;AACjE,KAAI,CAAC,GAAI,QAAO;CAEhB,MAAM,UAAU,GAAG,WAAW;CAC9B,MAAM,SAAS,GAAG,UAAU;CAC5B,MAAM,OAAO,GAAG,QAAQ;AAGxB,KAAI,YAAY,QAAQ,WAAW,QAAQ,SAAS,KAAM,QAAO;AAEjE,QAAO;EAAE;EAAS;EAAQ;EAAM;;;;;;;;;;;;;;;;;;;;AAqBjC,SAAgB,mBACf,SACA,wBACc;CACd,MAAM,UAAU,QAAQ;CACxB,MAAM,KAAK,YAAY,QAAQ;CAC/B,MAAM,UAAU,sBAAsB,uBAAuB;CAE7D,IAAI,KAAoB;AAGxB,KAAI,IAAI;EACP,MAAM,OAAO,QAAQ,IAAI,mBAAmB,EAAE,MAAM;AACpD,MAAI,QAAQ,WAAW,KAAK,KAAK,CAChC,MAAK;AAEN,MAAI,CAAC,IAAI;GACR,MAAM,MAAM,QAAQ,IAAI,kBAAkB;AAC1C,QAAK,MAAM,sBAAsB,IAAI,GAAG;;;AAM1C,KAAI,CAAC,GACJ,MAAK,MAAM,QAAQ,SAAS;EAC3B,MAAM,QAAQ,iBAAiB,SAAS,KAAK;AAC7C,MAAI,OAAO;AACV,QAAK;AACL;;;CAKH,MAAM,YAAY,QAAQ,IAAI,aAAa,EAAE,MAAM,IAAI;CACvD,MAAM,UAAU,QAAQ,IAAI,UAAU,EAAE,MAAM,IAAI;CAClD,MAAM,MAAM,WAAW,GAAG;AAE1B,QAAO;EAAE;EAAI;EAAW;EAAS;EAAK;;AAGvC,SAAS,sBACR,OACW;AACX,KAAI,MAAM,QAAQ,MAAM,CAIvB,QAAO,wBAAwB,MAAM;AAEtC,QAAO,uBAAuB,MAAM;;;;;;;AAYrC,MAAM,2BAA2B,IAAI,IAAI;CACxC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA,CAAC;;;;;AAMF,SAAgB,0BAA0B,SAA0C;CACnF,MAAM,OAA+B,EAAE;AACvC,SAAQ,SAAS,OAAO,QAAQ;AAC/B,MAAI,CAAC,yBAAyB,IAAI,IAAI,CACrC,MAAK,OAAO;GAEZ;AACF,QAAO"}
+{"version":3,"file":"request-meta-DCwktC5P.mjs","names":[],"sources":["../src/plugins/request-meta.ts"],"sourcesContent":["/**\n * Request Metadata Extraction\n *\n * Extracts normalized metadata (IP, user agent, referer, geo) from\n * incoming requests. Used by plugin route handlers to access request\n * context without touching raw headers.\n *\n */\n\nimport type { EmDashConfig } from \"../astro/integration/runtime.js\";\nimport { getTrustedProxyHeaders, normalizeTrustedHeaders } from \"../auth/trusted-proxy.js\";\nimport type { GeoInfo, RequestMeta } from \"./types.js\";\n\n/**\n * Cloudflare Workers `cf` object shape (subset we use).\n * Present on requests when running on Cloudflare Workers.\n */\ninterface CfProperties {\n\tcountry?: string;\n\tregion?: string;\n\tcity?: string;\n}\n\n/**\n * Loose validation for IPv4 and IPv6 addresses.\n * Accepts digits, hex chars, dots, and colons — rejects anything else\n * (e.g. HTML tags, scripts, or other non-IP garbage in spoofed headers).\n */\nconst IP_PATTERN = /^[\\da-fA-F.:]+$/;\n\n/**\n * Extract the first IP from an X-Forwarded-For header value.\n * The header may contain a comma-separated list of IPs; the first\n * entry is the original client IP.\n *\n * Returns null if the extracted value doesn't look like an IP address.\n */\nfunction parseFirstForwardedIp(header: string): string | null {\n\tconst first = header.split(\",\")[0];\n\tconst trimmed = first?.trim();\n\tif (!trimmed) return null;\n\treturn IP_PATTERN.test(trimmed) ? trimmed : null;\n}\n\n/**\n * Read an IP from an operator-declared trusted header. XFF-style headers\n * (any name ending in `forwarded-for`) are parsed as comma-separated lists\n * and the first entry is used; everything else is treated as a single\n * trimmed value.\n */\nfunction readIpFromHeader(headers: Headers, name: string): string | null {\n\tconst value = headers.get(name);\n\tif (!value) return null;\n\tif (name.endsWith(\"forwarded-for\")) {\n\t\treturn parseFirstForwardedIp(value);\n\t}\n\tconst trimmed = value.trim();\n\tif (!trimmed) return null;\n\treturn IP_PATTERN.test(trimmed) ? trimmed : null;\n}\n\n/**\n * Get the Cloudflare `cf` object from the request, if present.\n * Returns undefined when not running on Cloudflare Workers.\n */\nfunction getCfObject(request: Request): CfProperties | undefined {\n\treturn (request as unknown as { cf?: CfProperties }).cf;\n}\n\n/**\n * Extract geographic information from the Cloudflare `cf` object\n * attached to the request. Returns null when not running on CF Workers.\n */\nfunction extractGeo(cf: CfProperties | undefined): GeoInfo | null {\n\tif (!cf) return null;\n\n\tconst country = cf.country ?? null;\n\tconst region = cf.region ?? null;\n\tconst city = cf.city ?? null;\n\n\t// Only return geo if at least one field is populated\n\tif (country === null && region === null && city === null) return null;\n\n\treturn { country, region, city };\n}\n\n/**\n * Extract normalized request metadata from a Request object.\n *\n * IP resolution order:\n * 1. `CF-Connecting-IP` — trusted only when a `cf` object is present on the\n *    request. CF edge overwrites any client-supplied value, so this is the\n *    cryptographically trustworthy path on Workers. Operator-declared\n *    trusted headers cannot override it.\n * 2. `X-Forwarded-For` first entry — trusted only with a `cf` object.\n * 3. Operator-declared trusted proxy headers (from `config.trustedProxyHeaders`\n *    or the `EMDASH_TRUSTED_PROXY_HEADERS` env var), tried in order. Used as\n *    the primary source off-CF and as a fill-in on CF.\n * 4. `null`\n *\n * The second argument accepts either the EmDash config or a pre-resolved\n * list of trusted headers, so callers that already have the list don't have\n * to round-trip through the config every request.\n */\nexport function extractRequestMeta(\n\trequest: Request,\n\tconfigOrTrustedHeaders?: EmDashConfig | null | { trustedProxyHeaders?: string[] } | string[],\n): RequestMeta {\n\tconst headers = request.headers;\n\tconst cf = getCfObject(request);\n\tconst trusted = resolveTrustedHeaders(configOrTrustedHeaders);\n\n\tlet ip: string | null = null;\n\n\t// On Cloudflare, prefer the cryptographically trustworthy headers first.\n\tif (cf) {\n\t\tconst cfIp = headers.get(\"cf-connecting-ip\")?.trim();\n\t\tif (cfIp && IP_PATTERN.test(cfIp)) {\n\t\t\tip = cfIp;\n\t\t}\n\t\tif (!ip) {\n\t\t\tconst xff = headers.get(\"x-forwarded-for\");\n\t\t\tip = xff ? parseFirstForwardedIp(xff) : null;\n\t\t}\n\t}\n\n\t// Fall through to operator-declared trusted headers. On CF this fills\n\t// in when the CF headers are absent; off-CF it's the primary source.\n\tif (!ip) {\n\t\tfor (const name of trusted) {\n\t\t\tconst value = readIpFromHeader(headers, name);\n\t\t\tif (value) {\n\t\t\t\tip = value;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\tconst userAgent = headers.get(\"user-agent\")?.trim() || null;\n\tconst referer = headers.get(\"referer\")?.trim() || null;\n\tconst geo = extractGeo(cf);\n\n\treturn { ip, userAgent, referer, geo };\n}\n\nfunction resolveTrustedHeaders(\n\tvalue: EmDashConfig | null | { trustedProxyHeaders?: string[] } | string[] | undefined,\n): string[] {\n\tif (Array.isArray(value)) {\n\t\t// Apply the same RFC 7230 validation the config/env path does so a\n\t\t// caller passing a pre-resolved list with bad entries can't crash\n\t\t// `Headers.get()` downstream.\n\t\treturn normalizeTrustedHeaders(value);\n\t}\n\treturn getTrustedProxyHeaders(value);\n}\n\n// =============================================================================\n// Header Sanitization for Sandbox\n// =============================================================================\n\n/**\n * Headers that must never cross the RPC boundary to sandboxed plugins.\n * Session tokens, auth credentials, and infrastructure headers are stripped\n * to prevent malicious plugins from exfiltrating sensitive data.\n */\nconst SANDBOX_STRIPPED_HEADERS = new Set([\n\t\"cookie\",\n\t\"set-cookie\",\n\t\"authorization\",\n\t\"proxy-authorization\",\n\t\"cf-access-jwt-assertion\",\n\t\"cf-access-client-id\",\n\t\"cf-access-client-secret\",\n\t\"x-emdash-request\",\n]);\n\n/**\n * Copy request headers into a plain object, stripping sensitive headers\n * that must not be exposed to sandboxed plugin code.\n */\nexport function sanitizeHeadersForSandbox(headers: Headers): Record<string, string> {\n\tconst safe: Record<string, string> = {};\n\theaders.forEach((value, key) => {\n\t\tif (!SANDBOX_STRIPPED_HEADERS.has(key)) {\n\t\t\tsafe[key] = value;\n\t\t}\n\t});\n\treturn safe;\n}\n"],"mappings":";;;;;;;;AA4BA,MAAM,aAAa;;;;;;;;AASnB,SAAS,sBAAsB,QAA+B;CAE7D,MAAM,UADQ,OAAO,MAAM,IAAI,CAAC,IACT,MAAM;AAC7B,KAAI,CAAC,QAAS,QAAO;AACrB,QAAO,WAAW,KAAK,QAAQ,GAAG,UAAU;;;;;;;;AAS7C,SAAS,iBAAiB,SAAkB,MAA6B;CACxE,MAAM,QAAQ,QAAQ,IAAI,KAAK;AAC/B,KAAI,CAAC,MAAO,QAAO;AACnB,KAAI,KAAK,SAAS,gBAAgB,CACjC,QAAO,sBAAsB,MAAM;CAEpC,MAAM,UAAU,MAAM,MAAM;AAC5B,KAAI,CAAC,QAAS,QAAO;AACrB,QAAO,WAAW,KAAK,QAAQ,GAAG,UAAU;;;;;;AAO7C,SAAS,YAAY,SAA4C;AAChE,QAAQ,QAA6C;;;;;;AAOtD,SAAS,WAAW,IAA8C;AACjE,KAAI,CAAC,GAAI,QAAO;CAEhB,MAAM,UAAU,GAAG,WAAW;CAC9B,MAAM,SAAS,GAAG,UAAU;CAC5B,MAAM,OAAO,GAAG,QAAQ;AAGxB,KAAI,YAAY,QAAQ,WAAW,QAAQ,SAAS,KAAM,QAAO;AAEjE,QAAO;EAAE;EAAS;EAAQ;EAAM;;;;;;;;;;;;;;;;;;;;AAqBjC,SAAgB,mBACf,SACA,wBACc;CACd,MAAM,UAAU,QAAQ;CACxB,MAAM,KAAK,YAAY,QAAQ;CAC/B,MAAM,UAAU,sBAAsB,uBAAuB;CAE7D,IAAI,KAAoB;AAGxB,KAAI,IAAI;EACP,MAAM,OAAO,QAAQ,IAAI,mBAAmB,EAAE,MAAM;AACpD,MAAI,QAAQ,WAAW,KAAK,KAAK,CAChC,MAAK;AAEN,MAAI,CAAC,IAAI;GACR,MAAM,MAAM,QAAQ,IAAI,kBAAkB;AAC1C,QAAK,MAAM,sBAAsB,IAAI,GAAG;;;AAM1C,KAAI,CAAC,GACJ,MAAK,MAAM,QAAQ,SAAS;EAC3B,MAAM,QAAQ,iBAAiB,SAAS,KAAK;AAC7C,MAAI,OAAO;AACV,QAAK;AACL;;;CAKH,MAAM,YAAY,QAAQ,IAAI,aAAa,EAAE,MAAM,IAAI;CACvD,MAAM,UAAU,QAAQ,IAAI,UAAU,EAAE,MAAM,IAAI;CAClD,MAAM,MAAM,WAAW,GAAG;AAE1B,QAAO;EAAE;EAAI;EAAW;EAAS;EAAK;;AAGvC,SAAS,sBACR,OACW;AACX,KAAI,MAAM,QAAQ,MAAM,CAIvB,QAAO,wBAAwB,MAAM;AAEtC,QAAO,uBAAuB,MAAM;;;;;;;AAYrC,MAAM,2BAA2B,IAAI,IAAI;CACxC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA,CAAC;;;;;AAMF,SAAgB,0BAA0B,SAA0C;CACnF,MAAM,OAA+B,EAAE;AACvC,SAAQ,SAAS,OAAO,QAAQ;AAC/B,MAAI,CAAC,yBAAyB,IAAI,IAAI,CACrC,MAAK,OAAO;GAEZ;AACF,QAAO"}

package/dist/{resolve-DR3wqMTy.mjs → resolve-Cd9dzclN.mjs}

@@ -140,4 +140,4 @@ function normalizePath(path) {
 
 //#endregion
 export { resolveLocaleChain as i, localizePath as n, resolveLocale as r, interpolateUrlPattern as t };
-//# sourceMappingURL=resolve-DR3wqMTy.mjs.map
+//# sourceMappingURL=resolve-Cd9dzclN.mjs.map

package/dist/{resolve-DR3wqMTy.mjs.map → resolve-Cd9dzclN.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"resolve-DR3wqMTy.mjs","names":[],"sources":["../src/i18n/resolve.ts"],"sourcesContent":["/**\n * Shared locale-resolution helpers.\n *\n * Matches the pattern used by `query.ts` for content: an explicit locale wins,\n * otherwise we fall back to the request-context locale, otherwise to\n * `defaultLocale` when i18n is enabled, otherwise to `undefined` (meaning \"do\n * not filter by locale\" — legacy single-locale behaviour).\n */\n\nimport { getRequestContext } from \"../request-context.js\";\nimport { getFallbackChain, getI18nConfig, isI18nEnabled } from \"./config.js\";\n\n/**\n * Resolve the locale to use for a query given an optional explicit value.\n * Returns `undefined` when no locale information is available; callers should\n * treat that as \"do not filter by locale\".\n */\nexport function resolveLocale(explicit?: string): string | undefined {\n\tif (explicit !== undefined) return explicit;\n\tconst ctxLocale = getRequestContext()?.locale;\n\tif (ctxLocale !== undefined) return ctxLocale;\n\tconst cfg = getI18nConfig();\n\tif (cfg && isI18nEnabled()) return cfg.defaultLocale;\n\treturn undefined;\n}\n\n/**\n * Fallback chain to try when looking up a single item. When i18n is disabled\n * or the locale is unspecified, returns a single-element array (or empty when\n * no locale resolves) so callers can iterate uniformly.\n */\nexport function resolveLocaleChain(explicit?: string): string[] {\n\tconst locale = resolveLocale(explicit);\n\tif (locale === undefined) return [];\n\tif (!isI18nEnabled()) return [locale];\n\treturn getFallbackChain(locale);\n}\n\nconst REPEATED_SLASHES = /\\/{2,}/g;\n\n/**\n * Interpolate a collection `url_pattern` with a row's slug and id.\n *\n * Falls back to `/{collection}/{slug}` when no pattern is configured.\n * Does NOT apply any locale prefix — pass the result through\n * Astro's `getRelativeLocaleUrl` / `getAbsoluteLocaleUrl` (or the\n * `localizePath` helper below) to add the locale segment.\n */\nexport function interpolateUrlPattern(options: {\n\tpattern: string | null;\n\tcollection: string;\n\tslug: string;\n\tid: string;\n}): string {\n\tconst { pattern, collection, slug, id } = options;\n\tconst basePattern = pattern ?? `/${encodeURIComponent(collection)}/{slug}`;\n\tlet path = basePattern\n\t\t.replace(\"{slug}\", encodeURIComponent(slug))\n\t\t.replace(\"{id}\", encodeURIComponent(id));\n\tpath = path.replace(REPEATED_SLASHES, \"/\");\n\tif (path.length > 1 && path.endsWith(\"/\")) path = path.slice(0, -1);\n\tif (!path.startsWith(\"/\")) path = `/${path}`;\n\treturn path;\n}\n\n/**\n * Apply a locale prefix to a path, honouring the user's Astro `i18n`\n * routing config (`prefixDefaultLocale`, custom `path`/`codes` mappings).\n *\n * Reads the resolved config from `astro:config/server`, which is always\n * available regardless of whether i18n is enabled -- so this function\n * works in both i18n and non-i18n builds without tripping Astro's\n * `i18nNotEnabled` resolver (the case with importing `astro:i18n`).\n *\n * Returns:\n *   - The original `path` when i18n is not configured.\n *   - The original `path` for the default locale when\n *     `prefixDefaultLocale` is false.\n *   - `/{segment}{path}` for any other configured locale, where\n *     `{segment}` is the locale's custom `path` if one is set,\n *     otherwise the locale code.\n *   - `null` when the row's locale isn't in the configured list.\n *     Callers should drop the entry: a sitemap link to a route the\n *     site can't serve is worse than no link at all (search engines\n *     get a 404 / soft-404 and downrank the page).\n *\n * Falls back to `getI18nConfig()` (EmDash's mirror of the same config,\n * populated at runtime startup) when `astro:config/server` is\n * unavailable -- e.g. running outside an Astro build context, such as\n * in vitest.\n */\nexport async function localizePath(path: string, locale: string): Promise<string | null> {\n\tconst segment = await resolveLocaleSegment(locale);\n\tif (segment === undefined) return null;\n\tif (segment === null || segment === \"\") return normalizePath(path);\n\treturn normalizePath(`/${segment}${path}`);\n}\n\n/**\n * Resolve the URL segment to use for a locale.\n *\n * Returns:\n *   - `null` when i18n isn't configured (caller should not prefix).\n *   - `\"\"` when the locale is the default locale and\n *     `prefixDefaultLocale` is false (caller should not prefix).\n *   - The locale's custom `path` value, or the locale string itself.\n *   - `undefined` when the locale isn't in the configured list --\n *     the row points at a route the site can't serve.\n */\nasync function resolveLocaleSegment(locale: string): Promise<string | null | undefined> {\n\tconst i18n = await readAstroI18nConfig();\n\tif (!i18n || !i18n.locales || i18n.locales.length <= 1) return null;\n\n\tconst isDefault = locale === i18n.defaultLocale;\n\tif (isDefault && !i18n.prefixDefaultLocale) return \"\";\n\n\t// When the locale has a custom `path`/`codes` mapping, use the path\n\t// for the URL segment. Otherwise use the locale code directly.\n\tfor (const entry of i18n.locales) {\n\t\tif (typeof entry === \"string\") {\n\t\t\tif (entry === locale) return entry;\n\t\t} else if (entry.codes.includes(locale)) {\n\t\t\treturn entry.path;\n\t\t}\n\t}\n\n\treturn undefined;\n}\n\ninterface AstroI18nConfig {\n\tdefaultLocale: string;\n\tlocales: Array<string | { codes: readonly string[]; path: string }>;\n\tprefixDefaultLocale?: boolean;\n}\n\nlet astroI18nCache: AstroI18nConfig | null | undefined;\n\nasync function readAstroI18nConfig(): Promise<AstroI18nConfig | null> {\n\tif (astroI18nCache !== undefined) return astroI18nCache;\n\n\ttry {\n\t\tconst mod = (await import(\"astro:config/server\")) as {\n\t\t\ti18n?: {\n\t\t\t\tdefaultLocale: string;\n\t\t\t\tlocales: Array<string | { codes: readonly string[]; path: string }>;\n\t\t\t\trouting?: { prefixDefaultLocale?: boolean } | string;\n\t\t\t};\n\t\t};\n\t\tif (!mod.i18n) {\n\t\t\tastroI18nCache = null;\n\t\t\treturn null;\n\t\t}\n\t\tconst routing = mod.i18n.routing;\n\t\tastroI18nCache = {\n\t\t\tdefaultLocale: mod.i18n.defaultLocale,\n\t\t\tlocales: mod.i18n.locales,\n\t\t\tprefixDefaultLocale:\n\t\t\t\ttypeof routing === \"object\" ? (routing.prefixDefaultLocale ?? false) : false,\n\t\t};\n\t\treturn astroI18nCache;\n\t} catch {\n\t\t// `astro:config/server` isn't resolvable (e.g. running under vitest\n\t\t// outside an Astro build). Fall back to EmDash's runtime config,\n\t\t// which is populated at startup via the same astroConfig object.\n\t\tconst cfg = getI18nConfig();\n\t\tif (!cfg || !isI18nEnabled()) {\n\t\t\tastroI18nCache = null;\n\t\t\treturn null;\n\t\t}\n\t\tastroI18nCache = {\n\t\t\tdefaultLocale: cfg.defaultLocale,\n\t\t\tlocales: cfg.locales,\n\t\t\tprefixDefaultLocale: cfg.prefixDefaultLocale,\n\t\t};\n\t\treturn astroI18nCache;\n\t}\n}\n\n/** @internal -- exposed for tests to reset the module-level cache. */\nexport function _resetAstroI18nCacheForTests(): void {\n\tastroI18nCache = undefined;\n}\n\nfunction normalizePath(path: string): string {\n\tlet p = path.replace(REPEATED_SLASHES, \"/\");\n\tif (p.length > 1 && p.endsWith(\"/\")) p = p.slice(0, -1);\n\tif (!p.startsWith(\"/\")) p = `/${p}`;\n\treturn p;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,SAAgB,cAAc,UAAuC;AACpE,KAAI,aAAa,OAAW,QAAO;CACnC,MAAM,YAAY,mBAAmB,EAAE;AACvC,KAAI,cAAc,OAAW,QAAO;CACpC,MAAM,MAAM,eAAe;AAC3B,KAAI,OAAO,eAAe,CAAE,QAAO,IAAI;;;;;;;AASxC,SAAgB,mBAAmB,UAA6B;CAC/D,MAAM,SAAS,cAAc,SAAS;AACtC,KAAI,WAAW,OAAW,QAAO,EAAE;AACnC,KAAI,CAAC,eAAe,CAAE,QAAO,CAAC,OAAO;AACrC,QAAO,iBAAiB,OAAO;;AAGhC,MAAM,mBAAmB;;;;;;;;;AAUzB,SAAgB,sBAAsB,SAK3B;CACV,MAAM,EAAE,SAAS,YAAY,MAAM,OAAO;CAE1C,IAAI,QADgB,WAAW,IAAI,mBAAmB,WAAW,CAAC,UAEhE,QAAQ,UAAU,mBAAmB,KAAK,CAAC,CAC3C,QAAQ,QAAQ,mBAAmB,GAAG,CAAC;AACzC,QAAO,KAAK,QAAQ,kBAAkB,IAAI;AAC1C,KAAI,KAAK,SAAS,KAAK,KAAK,SAAS,IAAI,CAAE,QAAO,KAAK,MAAM,GAAG,GAAG;AACnE,KAAI,CAAC,KAAK,WAAW,IAAI,CAAE,QAAO,IAAI;AACtC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BR,eAAsB,aAAa,MAAc,QAAwC;CACxF,MAAM,UAAU,MAAM,qBAAqB,OAAO;AAClD,KAAI,YAAY,OAAW,QAAO;AAClC,KAAI,YAAY,QAAQ,YAAY,GAAI,QAAO,cAAc,KAAK;AAClE,QAAO,cAAc,IAAI,UAAU,OAAO;;;;;;;;;;;;;AAc3C,eAAe,qBAAqB,QAAoD;CACvF,MAAM,OAAO,MAAM,qBAAqB;AACxC,KAAI,CAAC,QAAQ,CAAC,KAAK,WAAW,KAAK,QAAQ,UAAU,EAAG,QAAO;AAG/D,KADkB,WAAW,KAAK,iBACjB,CAAC,KAAK,oBAAqB,QAAO;AAInD,MAAK,MAAM,SAAS,KAAK,QACxB,KAAI,OAAO,UAAU,UACpB;MAAI,UAAU,OAAQ,QAAO;YACnB,MAAM,MAAM,SAAS,OAAO,CACtC,QAAO,MAAM;;AAahB,IAAI;AAEJ,eAAe,sBAAuD;AACrE,KAAI,mBAAmB,OAAW,QAAO;AAEzC,KAAI;EACH,MAAM,MAAO,MAAM,OAAO;AAO1B,MAAI,CAAC,IAAI,MAAM;AACd,oBAAiB;AACjB,UAAO;;EAER,MAAM,UAAU,IAAI,KAAK;AACzB,mBAAiB;GAChB,eAAe,IAAI,KAAK;GACxB,SAAS,IAAI,KAAK;GAClB,qBACC,OAAO,YAAY,WAAY,QAAQ,uBAAuB,QAAS;GACxE;AACD,SAAO;SACA;EAIP,MAAM,MAAM,eAAe;AAC3B,MAAI,CAAC,OAAO,CAAC,eAAe,EAAE;AAC7B,oBAAiB;AACjB,UAAO;;AAER,mBAAiB;GAChB,eAAe,IAAI;GACnB,SAAS,IAAI;GACb,qBAAqB,IAAI;GACzB;AACD,SAAO;;;AAST,SAAS,cAAc,MAAsB;CAC5C,IAAI,IAAI,KAAK,QAAQ,kBAAkB,IAAI;AAC3C,KAAI,EAAE,SAAS,KAAK,EAAE,SAAS,IAAI,CAAE,KAAI,EAAE,MAAM,GAAG,GAAG;AACvD,KAAI,CAAC,EAAE,WAAW,IAAI,CAAE,KAAI,IAAI;AAChC,QAAO"}
+{"version":3,"file":"resolve-Cd9dzclN.mjs","names":[],"sources":["../src/i18n/resolve.ts"],"sourcesContent":["/**\n * Shared locale-resolution helpers.\n *\n * Matches the pattern used by `query.ts` for content: an explicit locale wins,\n * otherwise we fall back to the request-context locale, otherwise to\n * `defaultLocale` when i18n is enabled, otherwise to `undefined` (meaning \"do\n * not filter by locale\" — legacy single-locale behaviour).\n */\n\nimport { getRequestContext } from \"../request-context.js\";\nimport { getFallbackChain, getI18nConfig, isI18nEnabled } from \"./config.js\";\n\n/**\n * Resolve the locale to use for a query given an optional explicit value.\n * Returns `undefined` when no locale information is available; callers should\n * treat that as \"do not filter by locale\".\n */\nexport function resolveLocale(explicit?: string): string | undefined {\n\tif (explicit !== undefined) return explicit;\n\tconst ctxLocale = getRequestContext()?.locale;\n\tif (ctxLocale !== undefined) return ctxLocale;\n\tconst cfg = getI18nConfig();\n\tif (cfg && isI18nEnabled()) return cfg.defaultLocale;\n\treturn undefined;\n}\n\n/**\n * Fallback chain to try when looking up a single item. When i18n is disabled\n * or the locale is unspecified, returns a single-element array (or empty when\n * no locale resolves) so callers can iterate uniformly.\n */\nexport function resolveLocaleChain(explicit?: string): string[] {\n\tconst locale = resolveLocale(explicit);\n\tif (locale === undefined) return [];\n\tif (!isI18nEnabled()) return [locale];\n\treturn getFallbackChain(locale);\n}\n\nconst REPEATED_SLASHES = /\\/{2,}/g;\n\n/**\n * Interpolate a collection `url_pattern` with a row's slug and id.\n *\n * Falls back to `/{collection}/{slug}` when no pattern is configured.\n * Does NOT apply any locale prefix — pass the result through\n * Astro's `getRelativeLocaleUrl` / `getAbsoluteLocaleUrl` (or the\n * `localizePath` helper below) to add the locale segment.\n */\nexport function interpolateUrlPattern(options: {\n\tpattern: string | null;\n\tcollection: string;\n\tslug: string;\n\tid: string;\n}): string {\n\tconst { pattern, collection, slug, id } = options;\n\tconst basePattern = pattern ?? `/${encodeURIComponent(collection)}/{slug}`;\n\tlet path = basePattern\n\t\t.replace(\"{slug}\", encodeURIComponent(slug))\n\t\t.replace(\"{id}\", encodeURIComponent(id));\n\tpath = path.replace(REPEATED_SLASHES, \"/\");\n\tif (path.length > 1 && path.endsWith(\"/\")) path = path.slice(0, -1);\n\tif (!path.startsWith(\"/\")) path = `/${path}`;\n\treturn path;\n}\n\n/**\n * Apply a locale prefix to a path, honouring the user's Astro `i18n`\n * routing config (`prefixDefaultLocale`, custom `path`/`codes` mappings).\n *\n * Reads the resolved config from `astro:config/server`, which is always\n * available regardless of whether i18n is enabled -- so this function\n * works in both i18n and non-i18n builds without tripping Astro's\n * `i18nNotEnabled` resolver (the case with importing `astro:i18n`).\n *\n * Returns:\n *   - The original `path` when i18n is not configured.\n *   - The original `path` for the default locale when\n *     `prefixDefaultLocale` is false.\n *   - `/{segment}{path}` for any other configured locale, where\n *     `{segment}` is the locale's custom `path` if one is set,\n *     otherwise the locale code.\n *   - `null` when the row's locale isn't in the configured list.\n *     Callers should drop the entry: a sitemap link to a route the\n *     site can't serve is worse than no link at all (search engines\n *     get a 404 / soft-404 and downrank the page).\n *\n * Falls back to `getI18nConfig()` (EmDash's mirror of the same config,\n * populated at runtime startup) when `astro:config/server` is\n * unavailable -- e.g. running outside an Astro build context, such as\n * in vitest.\n */\nexport async function localizePath(path: string, locale: string): Promise<string | null> {\n\tconst segment = await resolveLocaleSegment(locale);\n\tif (segment === undefined) return null;\n\tif (segment === null || segment === \"\") return normalizePath(path);\n\treturn normalizePath(`/${segment}${path}`);\n}\n\n/**\n * Resolve the URL segment to use for a locale.\n *\n * Returns:\n *   - `null` when i18n isn't configured (caller should not prefix).\n *   - `\"\"` when the locale is the default locale and\n *     `prefixDefaultLocale` is false (caller should not prefix).\n *   - The locale's custom `path` value, or the locale string itself.\n *   - `undefined` when the locale isn't in the configured list --\n *     the row points at a route the site can't serve.\n */\nasync function resolveLocaleSegment(locale: string): Promise<string | null | undefined> {\n\tconst i18n = await readAstroI18nConfig();\n\tif (!i18n || !i18n.locales || i18n.locales.length <= 1) return null;\n\n\tconst isDefault = locale === i18n.defaultLocale;\n\tif (isDefault && !i18n.prefixDefaultLocale) return \"\";\n\n\t// When the locale has a custom `path`/`codes` mapping, use the path\n\t// for the URL segment. Otherwise use the locale code directly.\n\tfor (const entry of i18n.locales) {\n\t\tif (typeof entry === \"string\") {\n\t\t\tif (entry === locale) return entry;\n\t\t} else if (entry.codes.includes(locale)) {\n\t\t\treturn entry.path;\n\t\t}\n\t}\n\n\treturn undefined;\n}\n\ninterface AstroI18nConfig {\n\tdefaultLocale: string;\n\tlocales: Array<string | { codes: readonly string[]; path: string }>;\n\tprefixDefaultLocale?: boolean;\n}\n\nlet astroI18nCache: AstroI18nConfig | null | undefined;\n\nasync function readAstroI18nConfig(): Promise<AstroI18nConfig | null> {\n\tif (astroI18nCache !== undefined) return astroI18nCache;\n\n\ttry {\n\t\tconst mod = (await import(\"astro:config/server\")) as {\n\t\t\ti18n?: {\n\t\t\t\tdefaultLocale: string;\n\t\t\t\tlocales: Array<string | { codes: readonly string[]; path: string }>;\n\t\t\t\trouting?: { prefixDefaultLocale?: boolean } | string;\n\t\t\t};\n\t\t};\n\t\tif (!mod.i18n) {\n\t\t\tastroI18nCache = null;\n\t\t\treturn null;\n\t\t}\n\t\tconst routing = mod.i18n.routing;\n\t\tastroI18nCache = {\n\t\t\tdefaultLocale: mod.i18n.defaultLocale,\n\t\t\tlocales: mod.i18n.locales,\n\t\t\tprefixDefaultLocale:\n\t\t\t\ttypeof routing === \"object\" ? (routing.prefixDefaultLocale ?? false) : false,\n\t\t};\n\t\treturn astroI18nCache;\n\t} catch {\n\t\t// `astro:config/server` isn't resolvable (e.g. running under vitest\n\t\t// outside an Astro build). Fall back to EmDash's runtime config,\n\t\t// which is populated at startup via the same astroConfig object.\n\t\tconst cfg = getI18nConfig();\n\t\tif (!cfg || !isI18nEnabled()) {\n\t\t\tastroI18nCache = null;\n\t\t\treturn null;\n\t\t}\n\t\tastroI18nCache = {\n\t\t\tdefaultLocale: cfg.defaultLocale,\n\t\t\tlocales: cfg.locales,\n\t\t\tprefixDefaultLocale: cfg.prefixDefaultLocale,\n\t\t};\n\t\treturn astroI18nCache;\n\t}\n}\n\n/** @internal -- exposed for tests to reset the module-level cache. */\nexport function _resetAstroI18nCacheForTests(): void {\n\tastroI18nCache = undefined;\n}\n\nfunction normalizePath(path: string): string {\n\tlet p = path.replace(REPEATED_SLASHES, \"/\");\n\tif (p.length > 1 && p.endsWith(\"/\")) p = p.slice(0, -1);\n\tif (!p.startsWith(\"/\")) p = `/${p}`;\n\treturn p;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,SAAgB,cAAc,UAAuC;AACpE,KAAI,aAAa,OAAW,QAAO;CACnC,MAAM,YAAY,mBAAmB,EAAE;AACvC,KAAI,cAAc,OAAW,QAAO;CACpC,MAAM,MAAM,eAAe;AAC3B,KAAI,OAAO,eAAe,CAAE,QAAO,IAAI;;;;;;;AASxC,SAAgB,mBAAmB,UAA6B;CAC/D,MAAM,SAAS,cAAc,SAAS;AACtC,KAAI,WAAW,OAAW,QAAO,EAAE;AACnC,KAAI,CAAC,eAAe,CAAE,QAAO,CAAC,OAAO;AACrC,QAAO,iBAAiB,OAAO;;AAGhC,MAAM,mBAAmB;;;;;;;;;AAUzB,SAAgB,sBAAsB,SAK3B;CACV,MAAM,EAAE,SAAS,YAAY,MAAM,OAAO;CAE1C,IAAI,QADgB,WAAW,IAAI,mBAAmB,WAAW,CAAC,UAEhE,QAAQ,UAAU,mBAAmB,KAAK,CAAC,CAC3C,QAAQ,QAAQ,mBAAmB,GAAG,CAAC;AACzC,QAAO,KAAK,QAAQ,kBAAkB,IAAI;AAC1C,KAAI,KAAK,SAAS,KAAK,KAAK,SAAS,IAAI,CAAE,QAAO,KAAK,MAAM,GAAG,GAAG;AACnE,KAAI,CAAC,KAAK,WAAW,IAAI,CAAE,QAAO,IAAI;AACtC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BR,eAAsB,aAAa,MAAc,QAAwC;CACxF,MAAM,UAAU,MAAM,qBAAqB,OAAO;AAClD,KAAI,YAAY,OAAW,QAAO;AAClC,KAAI,YAAY,QAAQ,YAAY,GAAI,QAAO,cAAc,KAAK;AAClE,QAAO,cAAc,IAAI,UAAU,OAAO;;;;;;;;;;;;;AAc3C,eAAe,qBAAqB,QAAoD;CACvF,MAAM,OAAO,MAAM,qBAAqB;AACxC,KAAI,CAAC,QAAQ,CAAC,KAAK,WAAW,KAAK,QAAQ,UAAU,EAAG,QAAO;AAG/D,KADkB,WAAW,KAAK,iBACjB,CAAC,KAAK,oBAAqB,QAAO;AAInD,MAAK,MAAM,SAAS,KAAK,QACxB,KAAI,OAAO,UAAU,UACpB;MAAI,UAAU,OAAQ,QAAO;YACnB,MAAM,MAAM,SAAS,OAAO,CACtC,QAAO,MAAM;;AAahB,IAAI;AAEJ,eAAe,sBAAuD;AACrE,KAAI,mBAAmB,OAAW,QAAO;AAEzC,KAAI;EACH,MAAM,MAAO,MAAM,OAAO;AAO1B,MAAI,CAAC,IAAI,MAAM;AACd,oBAAiB;AACjB,UAAO;;EAER,MAAM,UAAU,IAAI,KAAK;AACzB,mBAAiB;GAChB,eAAe,IAAI,KAAK;GACxB,SAAS,IAAI,KAAK;GAClB,qBACC,OAAO,YAAY,WAAY,QAAQ,uBAAuB,QAAS;GACxE;AACD,SAAO;SACA;EAIP,MAAM,MAAM,eAAe;AAC3B,MAAI,CAAC,OAAO,CAAC,eAAe,EAAE;AAC7B,oBAAiB;AACjB,UAAO;;AAER,mBAAiB;GAChB,eAAe,IAAI;GACnB,SAAS,IAAI;GACb,qBAAqB,IAAI;GACzB;AACD,SAAO;;;AAST,SAAS,cAAc,MAAsB;CAC5C,IAAI,IAAI,KAAK,QAAQ,kBAAkB,IAAI;AAC3C,KAAI,EAAE,SAAS,KAAK,EAAE,SAAS,IAAI,CAAE,KAAI,EAAE,MAAM,GAAG,GAAG;AACvD,KAAI,CAAC,EAAE,WAAW,IAAI,CAAE,KAAI,IAAI;AAChC,QAAO"}

package/dist/{runner-DvFWoz8-.d.mts → runner-CiNdIk3y.d.mts}

@@ -1,4 +1,4 @@
-import { t as Database } from "./types-_HFLRzTn.mjs";
+import { t as Database } from "./types-momGysZk.mjs";
 import { Kysely } from "kysely";
 
 //#region src/database/migrations/runner.d.ts
@@ -8,6 +8,12 @@ interface MigrationStatus {
 }
 interface MigrationOptions {
   migrationTableSchema?: string;
+  /**
+   * Override how long to wait for a concurrent migrator to finish before
+   * giving up. Defaults to MIGRATION_RACE_WAIT_MS; tests shorten it so the
+   * give-up path doesn't take 10 seconds per case.
+   */
+  raceWaitMs?: number;
 }
 /**
  * Get migration status
@@ -44,4 +50,4 @@ declare function rollbackMigration(db: Kysely<Database>, options?: MigrationOpti
 }>;
 //#endregion
 export { runMigrations as i, getMigrationStatus as n, rollbackMigration as r, MigrationStatus as t };
-//# sourceMappingURL=runner-DvFWoz8-.d.mts.map
+//# sourceMappingURL=runner-CiNdIk3y.d.mts.map

package/dist/runner-CiNdIk3y.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-CiNdIk3y.d.mts","names":[],"sources":["../src/database/migrations/runner.ts"],"mappings":";;;;UAyHiB,eAAA;EAChB,OAAA;EACA,OAAA;AAAA;AAAA,UAyBgB,gBAAA;EAChB,oBAAA;EAyBE;;;;;EAnBF,UAAA;AAAA;;;;iBAgBqB,kBAAA,CACrB,EAAA,EAAI,MAAA,CAAO,QAAA,GACX,OAAA,GAAU,gBAAA,GACR,OAAA,CAAQ,eAAA;;;;;;;;;;;;;AAoOX;;;;;;;;iBA7DsB,aAAA,CACrB,EAAA,EAAI,MAAA,CAAO,QAAA,GACX,OAAA,GAAU,gBAAA,GACR,OAAA;EAAU,OAAA;AAAA;;;;iBA0DS,iBAAA,CACrB,EAAA,EAAI,MAAA,CAAO,QAAA,GACX,OAAA,GAAU,gBAAA,GACR,OAAA;EAAU,UAAA;AAAA"}

package/dist/{runner-K8XK101B.mjs → runner-jt65bF7F.mjs}

@@ -1,5 +1,6 @@
+import { MIGRATION_LOCK_BUSY_MESSAGE } from "./database/pg-migration-lock.mjs";
 import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
-import { c as listTablesLike, i as currentTimestampValue, n as columnExists, o as isSqlite, r as currentTimestamp, t as binaryType } from "./dialect-helpers-DRI5pyY3.mjs";
+import { a as currentTimestampValue, i as currentTimestamp, l as listTablesLike, r as columnExists, s as isSqlite, t as binaryType } from "./dialect-helpers-Cue7QQOR.mjs";
 import { n as getI18nConfig } from "./config-CVssduLe.mjs";
 import { createRequire } from "node:module";
 import { sql } from "kysely";
@@ -2939,6 +2940,20 @@ var StaticMigrationProvider = class {
 		return MIGRATIONS;
 	}
 };
+/**
+* Thrown when another instance held the migration lock for the whole wait
+* window. This is NOT a migration failure — the holder may simply be slow
+* (e.g. many pending migrations over a remote Postgres connection) — so
+* callers with failure-backoff logic (`getDatabase` in emdash-runtime.ts)
+* exempt it: the next request waits again instead of backing off, and init
+* recovers as soon as the holder finishes.
+*/
+var ConcurrentMigrationTimeoutError = class extends Error {
+	constructor(waitMs) {
+		super(`Timed out waiting for another instance's migrations: the migration lock was still held after ${waitMs}ms. It may still be applying migrations, or its migration may be failing repeatedly.`);
+		this.name = "ConcurrentMigrationTimeoutError";
+	}
+};
 /** Custom migration table name */
 const MIGRATION_TABLE = "_emdash_migrations";
 const MIGRATION_LOCK_TABLE = "_emdash_migrations_lock";
@@ -3044,8 +3059,8 @@ async function getAppliedMigrationCount(db) {
 * been migrated by a newer build still treats the wait as settled instead
 * of timing out.
 */
-async function waitForConcurrentMigrator(db) {
-	const deadline = Date.now() + MIGRATION_RACE_WAIT_MS;
+async function waitForConcurrentMigrator(db, waitMs = MIGRATION_RACE_WAIT_MS) {
+	const deadline = Date.now() + waitMs;
 	while (Date.now() < deadline) {
 		const count = await getAppliedMigrationCount(db);
 		if (count !== null && count >= MIGRATION_COUNT) return true;
@@ -3101,8 +3116,10 @@ async function runMigrations(db, options) {
 	if (error) {
 		const msg = deepErrorMessage(error);
 		const failedMigration = results?.find((r) => r.status === "Error");
-		if (MIGRATION_RACE_PATTERN.test(msg)) {
-			if (await waitForConcurrentMigrator(db)) return { applied };
+		const lockBusy = msg.includes(MIGRATION_LOCK_BUSY_MESSAGE);
+		if (MIGRATION_RACE_PATTERN.test(msg) || lockBusy) {
+			if (await waitForConcurrentMigrator(db, options?.raceWaitMs)) return { applied };
+			if (lockBusy) throw new ConcurrentMigrationTimeoutError(options?.raceWaitMs ?? MIGRATION_RACE_WAIT_MS);
 		}
 		const failedSuffix = failedMigration ? ` (migration: ${failedMigration.migrationName})` : "";
 		throw new Error(`Migration failed: ${msg || "unknown error"}${failedSuffix}`);
@@ -3123,5 +3140,5 @@ async function rollbackMigration(db, options) {
 }
 
 //#endregion
-export { __exportAll as a, runMigrations as i, getMigrationStatus as n, rollbackMigration as r, MIGRATION_RACE_WAIT_MS as t };
-//# sourceMappingURL=runner-K8XK101B.mjs.map
+export { runMigrations as a, rollbackMigration as i, MIGRATION_RACE_WAIT_MS as n, __exportAll as o, getMigrationStatus as r, ConcurrentMigrationTimeoutError as t };
+//# sourceMappingURL=runner-jt65bF7F.mjs.map