dineway 0.2.40 → 0.2.42

package/dist/{types-RFzE_V1M.mjs → types-BI3ULB3A.mjs}

@@ -1,5 +1,5 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
-import { r as encodeBase64, t as decodeBase64 } from "./base64-Cz-aU0X1.mjs";
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
+import { r as encodeBase64, t as decodeBase64 } from "./base64-qvSs0Gxy.mjs";
 
 //#region src/database/repositories/types.ts
 var types_exports = /* @__PURE__ */ __exportAll({

package/dist/{types-B--VyN3n.d.mts → types-Dpv_MvwZ.d.mts}

@@ -2993,4 +2993,4 @@ interface RestaurantMenuOverrideTable {
   updated_at: Generated<string>;
 }
 //#endregion
-export { RestaurantReservationExperienceTable as $, VenuePaymentRecordStatus as $t, RestaurantOperatingSettingsTable as A, VenueAvailabilityBlockTable as At, RestaurantPaymentFlow as B, VenueLocationMembershipTable as Bt, RestaurantMenuOverrideTable as C, RestaurantSpecialHoursTable as Ct, RestaurantModifierGroupTable as D, RestaurantZoneTable as Dt, RestaurantMenuTable as E, RestaurantTaxMode as Et, RestaurantOrderSource as F, VenueCancellationPolicyTable as Ft, RestaurantPriorityAlertTable as G, VenueOrderStatus as Gt, RestaurantPaymentTable as H, VenueMessageTable as Ht, RestaurantOrderStatus as I, VenueCancellationPolicyTierTable as It, RestaurantReservationAddonTable as J, VenueOutboxEventTable as Jt, RestaurantRefundTable as K, VenueOrderStatusHistoryTable as Kt, RestaurantOrderStatusHistoryTable as L, VenueConversationReadTable as Lt, RestaurantOrderItemTable as M, VenueBookingHoldTable as Mt, RestaurantOrderSequenceTable as N, VenueBookingMode as Nt, RestaurantModifierOptionTable as O, ReviewJobTable as Ot, RestaurantOrderSnapshotTable as P, VenueBookingPolicyTable as Pt, RestaurantReservationExperienceIncludedAddonTable as Q, VenuePaymentEventTable as Qt, RestaurantOrderTable as R, VenueConversationTable as Rt, RestaurantMenuLocationAssignmentTable as S, RestaurantServiceScope as St, RestaurantMenuSectionTable as T, RestaurantTableTable as Tt, RestaurantPriorityAlertDeliveryTable as U, VenueNotificationSettingsTable as Ut, RestaurantPaymentStatus as V, VenueLocationTable as Vt, RestaurantPriorityAlertOpportunityTable as W, VenueOrderCancellationSnapshotTable as Wt, RestaurantReservationDemandSettingsTable as X, VenuePaymentAllocationTable as Xt, RestaurantReservationBlockTable as Y, VenuePaymentAllocationStatus as Yt, RestaurantReservationExperienceAddonCategoryTable as Z, VenuePaymentCollection as Zt, RestaurantLocationMembershipTable as _, RestaurantReservationRequestTableAssignmentTable as _t, RestaurantCartHoldTable as a, VenueQuoteTable as an, RestaurantReservationHoldTable as at, RestaurantMenuItemTable as b, RestaurantReservationTable as bt, RestaurantDeliveryZoneTable as c, VenueRefundTable as cn, RestaurantReservationOfferTable as ct, RestaurantFulfilmentType as d, VenueReviewTable as dn, RestaurantReservationPromotionOperationTable as dt, VenuePaymentStatus as en, RestaurantReservationGiftCardAllocationTable as et, RestaurantGiftCardLedgerEntryTable as f, VenueSpaceLayoutTable as fn, RestaurantReservationPromotionTable as ft, RestaurantHoursTable as g, RestaurantReservationRequestTable as gt, RestaurantHoursOverrideTable as h, RestaurantReservationQuoteTable as ht, RestaurantCapacityOverrideTable as i, VenueQuoteStatus as in, RestaurantReservationHoldCommercialSelectionTable as it, RestaurantOrderItemModifierTable as j, VenueAvailabilityRuleTable as jt, RestaurantNotificationSettingsTable as k, UserTable as kt, RestaurantDineInSessionTable as l, VenueReviewInvitationTable as ln, RestaurantReservationPaymentPolicyTable as lt, RestaurantGuestAccessTable as m, VenueTable as mn, RestaurantReservationQuoteLineTable as mt, MediaTable as n, VenueQuoteLineTable as nn, RestaurantReservationHoldAddonOperationTable as nt, RestaurantClosureTable as o, VenueRatePlanTable as on, RestaurantReservationLanguageSettingsTable as ot, RestaurantGiftCardTable as p, VenueSpaceTable as pn, RestaurantReservationQuoteCheckoutTable as pt, RestaurantReservationAddonCategoryTable as q, VenueOrderTable as qt, RestaurantCapacityCounterTable as r, VenueQuoteRecordStatus as rn, RestaurantReservationHoldAddonTable as rt, RestaurantDeliverySettingsTable as s, VenueRecordStatus as sn, RestaurantReservationOfferLinkDeliveryTable as st, Database as t, VenuePaymentTable as tn, RestaurantReservationGiftCardOperationTable as tt, RestaurantDineInSettingsTable as u, VenueReviewResponseTable as un, RestaurantReservationPromotionAllocationTable as ut, RestaurantLocationTable as v, RestaurantReservationSettingsTable as vt, RestaurantMenuSectionItemTable as w, RestaurantTabRoundTable as wt, RestaurantMenuItemTranslationTable as x, RestaurantReservationTableAssignmentTable as xt, RestaurantMenuItemModifierGroupTable as y, RestaurantReservationStatus as yt, RestaurantOutboxDeliveryTable as z, VenueGuestAccessTable as zt };
+export { RestaurantReservationExperienceIncludedAddonTable as $, VenuePaymentEventTable as $t, RestaurantNotificationSettingsTable as A, UserTable as At, RestaurantOutboxDeliveryTable as B, VenueGuestAccessTable as Bt, RestaurantMenuLocationAssignmentTable as C, RestaurantServiceScope as Ct, RestaurantMenuTable as D, RestaurantTaxMode as Dt, RestaurantMenuSectionTable as E, RestaurantTableTable as Et, RestaurantOrderSnapshotTable as F, VenueBookingPolicyTable as Ft, RestaurantPriorityAlertOpportunityTable as G, VenueOrderCancellationSnapshotTable as Gt, RestaurantPaymentStatus as H, VenueLocationTable as Ht, RestaurantOrderSource as I, VenueCancellationPolicyTable as It, RestaurantReservationAddonCategoryTable as J, VenueOrderTable as Jt, RestaurantPriorityAlertTable as K, VenueOrderStatus as Kt, RestaurantOrderStatus as L, VenueCancellationPolicyTierTable as Lt, RestaurantOrderItemModifierTable as M, VenueAvailabilityRuleTable as Mt, RestaurantOrderItemTable as N, VenueBookingHoldTable as Nt, RestaurantModifierGroupTable as O, RestaurantZoneTable as Ot, RestaurantOrderSequenceTable as P, VenueBookingMode as Pt, RestaurantReservationExperienceAddonCategoryTable as Q, VenuePaymentCollection as Qt, RestaurantOrderStatusHistoryTable as R, VenueConversationReadTable as Rt, RestaurantMenuItemTranslationTable as S, RestaurantReservationTableAssignmentTable as St, RestaurantMenuSectionItemTable as T, RestaurantTabRoundTable as Tt, RestaurantPaymentTable as U, VenueMessageTable as Ut, RestaurantPaymentFlow as V, VenueLocationMembershipTable as Vt, RestaurantPriorityAlertDeliveryTable as W, VenueNotificationSettingsTable as Wt, RestaurantReservationBlockTable as X, VenuePaymentAllocationStatus as Xt, RestaurantReservationAddonTable as Y, VenueOutboxEventTable as Yt, RestaurantReservationDemandSettingsTable as Z, VenuePaymentAllocationTable as Zt, RestaurantHoursTable as _, RestaurantReservationRequestTable as _t, RestaurantCapacityOverrideTable as a, VenueQuoteStatus as an, RestaurantReservationHoldCommercialSelectionTable as at, RestaurantMenuItemModifierGroupTable as b, RestaurantReservationStatus as bt, RestaurantDeliverySettingsTable as c, VenueRecordStatus as cn, RestaurantReservationOfferLinkDeliveryTable as ct, RestaurantDineInSettingsTable as d, VenueReviewResponseTable as dn, RestaurantReservationPromotionAllocationTable as dt, VenuePaymentRecordStatus as en, RestaurantReservationExperienceTable as et, RestaurantFulfilmentType as f, VenueReviewTable as fn, RestaurantReservationPromotionOperationTable as ft, RestaurantHoursOverrideTable as g, RestaurantReservationQuoteTable as gt, RestaurantGuestAccessTable as h, VenueTable as hn, RestaurantReservationQuoteLineTable as ht, RestaurantCapacityCounterTable as i, VenueQuoteRecordStatus as in, RestaurantReservationHoldAddonTable as it, RestaurantOperatingSettingsTable as j, VenueAvailabilityBlockTable as jt, RestaurantModifierOptionTable as k, ReviewJobTable as kt, RestaurantDeliveryZoneTable as l, VenueRefundTable as ln, RestaurantReservationOfferTable as lt, RestaurantGiftCardTable as m, VenueSpaceTable as mn, RestaurantReservationQuoteCheckoutTable as mt, Database as n, VenuePaymentTable as nn, RestaurantReservationGiftCardOperationTable as nt, RestaurantCartHoldTable as o, VenueQuoteTable as on, RestaurantReservationHoldTable as ot, RestaurantGiftCardLedgerEntryTable as p, VenueSpaceLayoutTable as pn, RestaurantReservationPromotionTable as pt, RestaurantRefundTable as q, VenueOrderStatusHistoryTable as qt, MediaTable as r, VenueQuoteLineTable as rn, RestaurantReservationHoldAddonOperationTable as rt, RestaurantClosureTable as s, VenueRatePlanTable as sn, RestaurantReservationLanguageSettingsTable as st, ContentBylineTable as t, VenuePaymentStatus as tn, RestaurantReservationGiftCardAllocationTable as tt, RestaurantDineInSessionTable as u, VenueReviewInvitationTable as un, RestaurantReservationPaymentPolicyTable as ut, RestaurantLocationMembershipTable as v, RestaurantReservationRequestTableAssignmentTable as vt, RestaurantMenuOverrideTable as w, RestaurantSpecialHoursTable as wt, RestaurantMenuItemTable as x, RestaurantReservationTable as xt, RestaurantLocationTable as y, RestaurantReservationSettingsTable as yt, RestaurantOrderTable as z, VenueConversationTable as zt };

package/dist/{types-CgcOeaiQ.d.mts → types-ex-UrNlz.d.mts}

@@ -1,4 +1,4 @@
-import { c as CustomFieldValue } from "./types-SlLXjRpg.mjs";
+import { c as CustomFieldValue } from "./types-I5LHzk_M.mjs";
 
 //#region src/database/repositories/types.d.ts
 interface CreateContentInput {

package/dist/types-qOEot0UQ.d.mts

@@ -0,0 +1,83 @@
+import { AtomicBatch } from "./database/batch.mjs";
+import { RawBuilder } from "kysely";
+
+//#region src/content-storage/types.d.ts
+type ContentStorageValue = null | boolean | number | string | ContentStorageValue[] | {
+  [key: string]: ContentStorageValue;
+};
+interface ContentStoreDescriptor {
+  provider: "d1";
+  entrypoint: string;
+  config: Record<string, ContentStorageValue>;
+  /** Stable physical identity; changing it requires a storage migration. */
+  identity: string;
+}
+interface ContentPartitionContext {
+  collection: string;
+  id: string;
+  data: Readonly<Record<string, ContentStorageValue>>;
+  /** Immutable, server-loaded snapshots declared by the partition rule. */
+  dependencies?: Readonly<Record<string, ContentStorageValue>>;
+}
+interface ContentPartitionRule {
+  partitionBy: {
+    field: string;
+  } | {
+    entrypoint: string;
+    config?: ContentStorageValue;
+    taxonomies?: readonly string[];
+    references?: Record<string, {
+      collection: string;
+      taxonomies?: readonly string[];
+    }>;
+  };
+  stores: Record<string, string>;
+}
+interface ContentStorageConfig {
+  version: string;
+  stores: Record<string, ContentStoreDescriptor>;
+  rules: Record<string, ContentPartitionRule>;
+}
+interface ContentLocation {
+  collection: string;
+  entryId: string;
+  store: string;
+  partition: string;
+  routingVersion: string;
+  version: string;
+  digest: string;
+}
+interface ContentStorageCommand extends ContentLocation {
+  partitionEpoch?: number;
+  kind?: "content" | "revision";
+  /** Stable across retries, including after an unknown commit outcome. */
+  operationId: string;
+  principalId: string;
+  expectedVersion: string | null;
+}
+interface PreparedContentVersion {
+  command: ContentStorageCommand;
+  data: Record<string, ContentStorageValue>;
+}
+interface ContentStore {
+  /** Persist an immutable version. Repeating an identical request is safe. */
+  prepare(version: PreparedContentVersion): Promise<void>;
+  read(locations: readonly ContentLocation[], fields?: readonly string[]): Promise<PreparedContentVersion[]>;
+}
+interface ContentStorageActivation {
+  authorize(command: ContentStorageCommand): Promise<readonly RawBuilder<boolean>[]>;
+  /** Rebuild current authority and index checks on every attempt. */
+  prepare(command: ContentStorageCommand): Promise<AtomicBatch>;
+}
+type ContentPartitionResolver = (context: ContentPartitionContext, config: ContentStorageValue | undefined) => Promise<string> | string;
+/** Prepared writes must not replay other business statements after this operation committed. */
+declare class ContentStorageReplay extends Error {
+  readonly location: ContentLocation;
+  constructor(location: ContentLocation);
+}
+declare class ContentStorageError extends Error {
+  readonly code: "INVALID_CONFIG" | "INVALID_PARTITION" | "ROUTE_CHANGED" | "CONFLICT" | "UNAVAILABLE" | "FROZEN";
+  constructor(code: "INVALID_CONFIG" | "INVALID_PARTITION" | "ROUTE_CHANGED" | "CONFLICT" | "UNAVAILABLE" | "FROZEN", message: string);
+}
+//#endregion
+export { ContentStorageActivation as a, ContentStorageError as c, ContentStore as d, ContentStoreDescriptor as f, ContentPartitionRule as i, ContentStorageReplay as l, ContentPartitionContext as n, ContentStorageCommand as o, PreparedContentVersion as p, ContentPartitionResolver as r, ContentStorageConfig as s, ContentLocation as t, ContentStorageValue as u };

package/dist/ui/server-runtime.d.mts

@@ -1,19 +1,22 @@
-import { F as PageMetadataContribution, Ha as getCollectionInfo, Nn as getTaxonomyTerms, Tn as Widget, Tt as PublicPageContext, Vs as PublicComment, Wn as getMenu, Yi as getDinewayCollection, Zi as getEditMeta, _n as getWidgetArea, rr as getComments, sr as getSiteSettings, va as sanitizeHref } from "../types-D5JfvPvx.mjs";
-import "../types-B--VyN3n.mjs";
-import { _ as MediaValue, c as EmbedResult, l as ImageEmbed, s as EmbedOptions } from "../placeholder-DJLP_HY7.mjs";
-import "../runner-SoP1rphP.mjs";
-import "../index-BVGe04wF.mjs";
-import "../types-B03h5jt_.mjs";
-import "../adapters-C8nRpUuj.mjs";
-import "../scheduled-publish-BxdShRGs.mjs";
-import "../public-url-Ccv0Xmue.mjs";
-import { x as MediaReference } from "../validate-kmN2lS8H.mjs";
-import "../byline-fields-D-b9CWux.mjs";
-import "../types-DsJTXStN.mjs";
-import { t as getPublicOrigin } from "../public-url-CG5YbNqB.mjs";
-import { a as generateSiteSeoContributions, c as ResolvedPageMetadata, d as renderPageMetadata, f as resolvePageMetadata, i as generateBaseSeoContributions, l as createSha256CspHash, o as renderFragments } from "../jsonld-wRF85RXo.mjs";
+import { F as PageMetadataContribution, Ha as getCollectionInfo, Nn as getTaxonomyTerms, Tn as Widget, Tt as PublicPageContext, Vs as PublicComment, Wn as getMenu, Yi as getDinewayCollection, Zi as getEditMeta, _n as getWidgetArea, rr as getComments, sr as getSiteSettings, va as sanitizeHref } from "../types-0gRlZbhN.mjs";
+import "../types-Dpv_MvwZ.mjs";
+import { _ as MediaValue, c as EmbedResult, l as ImageEmbed, s as EmbedOptions } from "../placeholder-DdZV3I8x.mjs";
+import "../runner-DXQkyPeX.mjs";
+import "../index-CLj17kW9.mjs";
+import "../types-qOEot0UQ.mjs";
+import "../types-DheoByey.mjs";
+import "../adapters-lDnJjNDz.mjs";
+import "../runtime-Bs2JMbb2.mjs";
+import "../hook-events-BQw73jc7.mjs";
+import "../scheduled-publish-eCNGpvNm.mjs";
+import "../public-url-CEC1vj02.mjs";
+import { x as MediaReference } from "../validate-DUscf6VG.mjs";
+import "../byline-fields-B7pQ3LMi.mjs";
+import "../types-BJztoTbF.mjs";
+import { t as getPublicOrigin } from "../public-url-cMnsBUZB.mjs";
+import { a as generateSiteSeoContributions, c as ResolvedPageMetadata, d as renderPageMetadata, f as resolvePageMetadata, i as generateBaseSeoContributions, l as createSha256CspHash, o as renderFragments } from "../jsonld-CPijKSUe.mjs";
 import { getPageRuntime } from "../page/index.mjs";
-import { t as getMediaProvider } from "../provider-loader-DT7vQ5FI.mjs";
+import { t as getMediaProvider } from "../provider-loader-oLKm1AU8.mjs";
 
 //#region src/utils/sanitize.d.ts
 /**

package/dist/ui/server-runtime.mjs

@@ -1,30 +1,34 @@
 import "../d1-binding-DrLMBUxu.mjs";
 import "../dialect-helpers-C6xtO-Ui.mjs";
-import "../base64-Cz-aU0X1.mjs";
-import "../types-RFzE_V1M.mjs";
-import "../loader-Dp6zLmQm.mjs";
-import "../object-cache-mxCW-Rpt.mjs";
-import "../media-C5ba8fvI.mjs";
-import "../comment-DAQfUjqt.mjs";
-import "../options-JiLWB6Bt.mjs";
-import "../request-cache-8_ifFzVw.mjs";
-import "../content-refresh-BilzqcLt.mjs";
-import "../fts-manager-BrPpYtK0.mjs";
-import "../public-discovery-BGyhuD5U.mjs";
-import "../registry-Dclv9iHv.mjs";
-import { n as buildRenderMediaUrl } from "../url-DUz3LbCs.mjs";
-import { i as getSiteSettings } from "../settings-DsBzKeUQ.mjs";
-import { t as getCollectionInfo } from "../query-DLeahg3x.mjs";
-import "../resolve-DEKC4qVa.mjs";
-import { a as getTaxonomyTerms } from "../taxonomies-lWGNLKgn.mjs";
-import { n as sanitizeHref } from "../url-DGG3hw_h.mjs";
-import { r as getEditMeta, t as getDinewayCollection } from "../query-xspvw7Ui.mjs";
-import "../comment-reaction-Dp3G7UZc.mjs";
-import { i as getComments, t as getMenu } from "../menus-w5xwT-f5.mjs";
-import { t as getWidgetArea } from "../widgets-BOrDZdQ3.mjs";
-import { t as getMediaProvider } from "../provider-loader-DERzBMUz.mjs";
-import { n as getPublicOrigin } from "../public-url-sR8SVmTt.mjs";
-import { a as createSha256CspHash, c as resolvePageMetadata, g as absolutizeMediaUrl, n as generateSiteSeoContributions, o as escapeHtmlAttr, r as renderFragments, s as renderPageMetadata, t as generateBaseSeoContributions } from "../seo-contributions-LEFs1d7w.mjs";
+import "../config-6R0bchVE.mjs";
+import "../runtime-Ch5G-tnG.mjs";
+import "../revisions-qNkae-Dq.mjs";
+import "../runtime-env-DpYGy4pT.mjs";
+import "../base64-qvSs0Gxy.mjs";
+import "../types-BI3ULB3A.mjs";
+import "../loader-Bq1aW12P.mjs";
+import "../request-cache-CizvDoxV.mjs";
+import "../object-cache-DyI1SOBK.mjs";
+import "../media-BjH5OD-A.mjs";
+import "../comment-BWDG1nQm.mjs";
+import "../options-yFkLUuTw.mjs";
+import "../content-refresh-D7wpVFJ_.mjs";
+import "../fts-manager-Zu5ITic0.mjs";
+import "../public-discovery-BnqYofSK.mjs";
+import "../registry-B-HULaJI.mjs";
+import { n as buildRenderMediaUrl } from "../url-dn4mFfCI.mjs";
+import { i as getSiteSettings } from "../settings-DDOB3gW1.mjs";
+import { t as getCollectionInfo } from "../query-CP9M8xxX.mjs";
+import "../resolve-BxFGSKYu.mjs";
+import { a as getTaxonomyTerms } from "../taxonomies-BI26Bk-M.mjs";
+import { n as sanitizeHref } from "../url-Coamqvs4.mjs";
+import { r as getEditMeta, t as getDinewayCollection } from "../query-CLWTwcTr.mjs";
+import "../comment-reaction-B7pLTlQ7.mjs";
+import { i as getComments, t as getMenu } from "../menus-BXkfzNR1.mjs";
+import { t as getWidgetArea } from "../widgets-B99mnftw.mjs";
+import { t as getMediaProvider } from "../provider-loader-DlaT1usE.mjs";
+import { n as getPublicOrigin } from "../public-url-GQygrYmg.mjs";
+import { a as createSha256CspHash, c as resolvePageMetadata, g as absolutizeMediaUrl, n as generateSiteSeoContributions, o as escapeHtmlAttr, r as renderFragments, s as renderPageMetadata, t as generateBaseSeoContributions } from "../seo-contributions-ZKqrqsdT.mjs";
 import { getPageRuntime } from "../page/index.mjs";
 import sanitizeHtml from "sanitize-html";
 

package/dist/{user-Btai9rl3.mjs → user-Bl2_8rhJ.mjs}

@@ -1,5 +1,5 @@
-import { i as encodeCursor, r as decodeCursor } from "./types-RFzE_V1M.mjs";
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-C8vSD_5L.mjs";
+import { i as encodeCursor, r as decodeCursor } from "./types-BI3ULB3A.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-Bb56aCtB.mjs";
 import { ulid } from "ulidx";
 
 //#region src/database/repositories/user.ts

package/dist/{utils-CYxGuO_P.mjs → utils-CklSLz9F.mjs}

@@ -1,5 +1,5 @@
-import { n as slugify } from "./slugify-kD31VIv2.mjs";
-import { o as RESERVED_FIELD_SLUGS } from "./types-COvyXIp7.mjs";
+import { o as RESERVED_FIELD_SLUGS } from "./types-BgUxCuwu.mjs";
+import { n as slugify } from "./slugify-DvoaEPtL.mjs";
 import mime from "mime/lite";
 
 //#region src/import/utils.ts

package/dist/{validate-C05z0m7M.mjs → validate-C-yk7mmX.mjs}

@@ -1,6 +1,6 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
-import { n as FIELD_TYPES } from "./types-COvyXIp7.mjs";
-import { r as publicDiscoveryRulesSchema } from "./public-discovery-BGyhuD5U.mjs";
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
+import { n as FIELD_TYPES } from "./types-BgUxCuwu.mjs";
+import { r as publicDiscoveryRulesSchema } from "./public-discovery-BnqYofSK.mjs";
 
 //#region src/seed/validate.ts
 /**

package/dist/{validate-kmN2lS8H.d.mts → validate-DUscf6VG.d.mts}

@@ -1,6 +1,6 @@
-import { d as FieldType, m as PublicDiscoveryRules } from "./types-SlLXjRpg.mjs";
-import { t as Database } from "./types-B--VyN3n.mjs";
-import { d as Storage } from "./types-KFzuijKE.mjs";
+import { d as FieldType, m as PublicDiscoveryRules } from "./types-I5LHzk_M.mjs";
+import { n as Database } from "./types-Dpv_MvwZ.mjs";
+import { d as Storage } from "./types-C0heD9oI.mjs";
 import { Kysely } from "kysely";
 
 //#region src/settings/types.d.ts

package/dist/version-Co258u70.mjs

@@ -0,0 +1,6 @@
+//#region src/version.ts
+const VERSION = "0.2.42";
+const COMMIT = "255366038";
+
+//#endregion
+export { VERSION as n, COMMIT as t };

package/dist/version-store-BXv2D0de.mjs

@@ -0,0 +1,208 @@
+import { atomicBatch, ensureAtomicBatchSchema, rowUnchanged } from "./database/batch.mjs";
+import { n as contentDigest, o as ContentStorageError, t as canonicalContentJson } from "./config-6R0bchVE.mjs";
+import { sql } from "kysely";
+import { z } from "zod";
+
+//#region src/content-storage/version-store.ts
+const CONTENT_NAME = /^[a-z][a-z0-9_]{0,62}$/;
+const locationSchema = z.object({
+	collection: z.string().regex(CONTENT_NAME),
+	entryId: z.string().min(1).max(128),
+	store: z.string().min(1).max(63),
+	partition: z.string().min(1).max(256),
+	routingVersion: z.string().min(1).max(128),
+	version: z.string().min(1).max(128),
+	digest: z.string().regex(/^[a-f0-9]{64}$/)
+});
+const contentStoreCollectionSchema = z.object({ fields: z.record(z.string().regex(/^[a-z][a-z0-9_]{0,62}$/).refine((name) => name !== "id"), z.enum([
+	"text",
+	"integer",
+	"real",
+	"json"
+])).refine((fields) => Object.keys(fields).length <= 98, "Content stores support at most 98 data columns.") }).strict();
+const storedMetadata = z.object({
+	fields: z.record(z.string(), z.enum([
+		"text",
+		"integer",
+		"real",
+		"json",
+		"boolean"
+	])),
+	extra: z.record(z.string(), z.json())
+}).strict();
+const contentVersionSchema = z.object({
+	command: locationSchema.extend({
+		partitionEpoch: z.number().int().positive().optional(),
+		kind: z.enum(["content", "revision"]).optional(),
+		operationId: z.string().min(1).max(128),
+		principalId: z.string().min(1).max(128),
+		expectedVersion: z.string().min(1).max(128).nullable()
+	}).strict(),
+	data: z.record(z.string(), z.json())
+}).strict();
+const contentStoreRequestSchema = z.discriminatedUnion("action", [z.object({
+	action: z.literal("prepare"),
+	value: contentVersionSchema
+}).strict(), z.object({
+	action: z.literal("read"),
+	locations: z.array(locationSchema.strict()).min(1).max(16),
+	fields: z.array(z.string().regex(CONTENT_NAME)).max(98).optional()
+}).strict()]);
+/** Install on content databases explicitly; never called from a content request. */
+async function installContentVersionStore(db, identity, collections, options = {}) {
+	if (!identity || identity.length > 128) throw new ContentStorageError("INVALID_CONFIG", "A physical content database identity is required.");
+	await ensureAtomicBatchSchema(db);
+	await db.schema.createTable("_dineway_content_store_identity").ifNotExists().addColumn("id", "integer", (c) => c.primaryKey()).addColumn("identity", "text", (c) => c.notNull()).addColumn("schema_version", "integer", (c) => c.notNull()).execute();
+	await atomicBatch(db, {
+		checks: [sql`NOT EXISTS (SELECT 1 FROM _dineway_content_store_identity WHERE id = 1 AND (identity <> ${identity} OR schema_version <> 1))`],
+		statements: [sql`INSERT INTO _dineway_content_store_identity (id, identity, schema_version) VALUES (1, ${identity}, 1) ON CONFLICT (id) DO NOTHING`.compile(db)]
+	});
+	await db.schema.createTable("_dineway_content_versions").ifNotExists().addColumn("collection", "text", (c) => c.notNull()).addColumn("entry_id", "text", (c) => c.notNull()).addColumn("version", "text", (c) => c.notNull()).addColumn("operation_id", "text", (c) => c.notNull().unique()).addColumn("digest", "text", (c) => c.notNull()).addColumn("command", "text", (c) => c.notNull()).addColumn("data", "text", (c) => c.notNull()).addColumn("created_at", "text", (c) => c.notNull()).addPrimaryKeyConstraint("pk_content_versions", [
+		"collection",
+		"entry_id",
+		"version"
+	]).execute();
+	await db.schema.createIndex("idx_content_versions_created_at").ifNotExists().on("_dineway_content_versions").column("created_at").execute();
+	await db.schema.createTable("_dineway_content_store_collections").ifNotExists().addColumn("collection", "text", (c) => c.primaryKey()).addColumn("schema", "text", (c) => c.notNull()).addColumn("physical_schema", "text", (c) => c.notNull()).addColumn("digest", "text", (c) => c.notNull()).execute();
+	await db.schema.createTable("_dineway_content_store_schema_history").ifNotExists().addColumn("collection", "text", (c) => c.notNull()).addColumn("digest", "text", (c) => c.notNull()).addColumn("schema", "text", (c) => c.notNull()).addColumn("installed_at", "text", (c) => c.notNull()).addPrimaryKeyConstraint("pk_content_store_schema_history", ["collection", "digest"]).execute();
+	for (const [collection, input] of Object.entries(collections)) {
+		if (!CONTENT_NAME.test(collection)) throw new ContentStorageError("INVALID_CONFIG", "Invalid content type name.");
+		const definition = contentStoreCollectionSchema.parse(input);
+		const serialized = canonicalContentJson(definition);
+		const digest = await contentDigest(definition);
+		const previous = (await sql`SELECT collection,schema,physical_schema,digest FROM _dineway_content_store_collections WHERE collection=${collection}`.execute(db)).rows[0];
+		if (previous && previous.digest !== digest && !options.upgrade) throw new ContentStorageError("INVALID_CONFIG", "Content store schema changes require the explicit schema upgrade command.");
+		const physical = previous ? contentStoreCollectionSchema.parse(JSON.parse(previous.physical_schema)) : { fields: {} };
+		const added = Object.entries(definition.fields).filter(([field]) => !Object.hasOwn(physical.fields, field));
+		for (const [field, type] of Object.entries(definition.fields)) if (Object.hasOwn(physical.fields, field) && physical.fields[field] !== type) throw new ContentStorageError("INVALID_CONFIG", `Changing the stored type of ${collection}.${field} requires a separate data migration. Use a new field name.`);
+		const nextPhysical = contentStoreCollectionSchema.parse({ fields: {
+			...physical.fields,
+			...definition.fields
+		} });
+		const statements = [];
+		if (previous) for (const [field, type] of added) statements.push(db.schema.alterTable(`ec_${collection}`).addColumn(field, type === "json" ? "text" : type).compile());
+		else {
+			let table = db.schema.createTable(`ec_${collection}`).addColumn("id", "text", (c) => c.notNull()).addColumn("_dineway_storage_version", "text", (c) => c.notNull());
+			for (const [field, type] of Object.entries(definition.fields)) table = table.addColumn(field, type === "json" ? "text" : type);
+			statements.push(table.addPrimaryKeyConstraint(`pk_ec_${collection}_version`, ["id", "_dineway_storage_version"]).compile());
+		}
+		statements.push(sql`INSERT INTO _dineway_content_store_collections (collection,schema,physical_schema,digest) VALUES (${collection},${serialized},${canonicalContentJson(nextPhysical)},${digest}) ON CONFLICT (collection) DO UPDATE SET schema=excluded.schema,physical_schema=excluded.physical_schema,digest=excluded.digest`.compile(db), sql`INSERT INTO _dineway_content_store_schema_history (collection,digest,schema,installed_at) VALUES (${collection},${digest},${serialized},${(/* @__PURE__ */ new Date()).toISOString()}) ON CONFLICT (collection,digest) DO NOTHING`.compile(db));
+		await atomicBatch(db, {
+			checks: [previous ? rowUnchanged("_dineway_content_store_collections", previous) : sql`NOT EXISTS (SELECT 1 FROM _dineway_content_store_collections WHERE collection=${collection})`],
+			statements
+		});
+	}
+}
+/** Validate the physical binding and deployed schema once at request entry. */
+async function assertContentVersionStore(db, identity) {
+	const result = await sql`SELECT identity, schema_version FROM _dineway_content_store_identity WHERE id = 1`.execute(db);
+	if (result.rows[0]?.identity !== identity || result.rows[0]?.schema_version !== 1) throw new ContentStorageError("UNAVAILABLE", "Content database identity or schema does not match the deployed content service.");
+}
+/** Immutable staging versions; only the primary directory can make one visible. */
+var ContentVersionStore = class {
+	schemas = /* @__PURE__ */ new Map();
+	constructor(db, name, routingVersion) {
+		this.db = db;
+		this.name = name;
+		this.routingVersion = routingVersion;
+	}
+	async prepare(input) {
+		const { command, data } = contentVersionSchema.parse(input);
+		this.assertTarget(command, true);
+		const serialized = canonicalContentJson(command);
+		const payload = canonicalContentJson(data);
+		const definition = await this.schema(command.collection);
+		const fields = {};
+		const extra = {};
+		const columns = ["id", "_dineway_storage_version"];
+		const values = [command.entryId, command.version];
+		for (const [field, value] of Object.entries(data)) {
+			if (field.startsWith("_")) {
+				extra[field] = value;
+				continue;
+			}
+			const type = definition.fields[field];
+			if (!type && command.kind === "revision") {
+				extra[field] = value;
+				continue;
+			}
+			if (!type) throw new ContentStorageError("INVALID_CONFIG", `Content field ${field} is absent from the deployed store schema.`);
+			let encoded = value;
+			let codec = type;
+			if (value !== null) {
+				if (type === "json") encoded = canonicalContentJson(value);
+				else if (type === "integer" && typeof value === "boolean") {
+					encoded = Number(value);
+					codec = "boolean";
+				} else if (type === "text" ? typeof value !== "string" : typeof value !== "number" || !Number.isFinite(value) || type === "integer" && !Number.isSafeInteger(value)) throw new ContentStorageError("CONFLICT", `Content field ${field} does not match its deployed column type.`);
+			}
+			fields[field] = codec;
+			columns.push(field);
+			values.push(encoded);
+		}
+		const metadata = canonicalContentJson({
+			fields,
+			extra
+		});
+		if (await contentDigest(data) !== command.digest) throw new ContentStorageError("CONFLICT", "The prepared content digest does not match.");
+		if (new TextEncoder().encode(payload + serialized + command.collection + command.entryId + command.version + command.operationId + command.digest).length > 1999e3) throw new ContentStorageError("CONFLICT", "The content version exceeds the D1 row size limit; no data was truncated.");
+		await atomicBatch(this.db, {
+			checks: [sql`NOT EXISTS (SELECT 1 FROM _dineway_content_versions WHERE operation_id = ${command.operationId} AND command <> ${serialized})`, sql`NOT EXISTS (SELECT 1 FROM _dineway_content_versions WHERE collection = ${command.collection} AND entry_id = ${command.entryId} AND version = ${command.version} AND (command <> ${serialized} OR data <> ${metadata}))`],
+			statements: [sql`INSERT INTO ${sql.table(`ec_${command.collection}`)} (${sql.join(columns.map((column) => sql.ref(column)))}) VALUES (${sql.join(values)}) ON CONFLICT (id, _dineway_storage_version) DO NOTHING`.compile(this.db), sql`INSERT INTO _dineway_content_versions (collection, entry_id, version, operation_id, digest, command, data, created_at) VALUES (${command.collection}, ${command.entryId}, ${command.version}, ${command.operationId}, ${command.digest}, ${serialized}, ${metadata}, ${(/* @__PURE__ */ new Date()).toISOString()}) ON CONFLICT (collection, entry_id, version) DO NOTHING`.compile(this.db)]
+		});
+	}
+	async read(locations, fields) {
+		if (!locations.length) return [];
+		if (locations.length > 16) throw new ContentStorageError("CONFLICT", "Content reads must be split into batches of at most 16 versions.");
+		for (const location of locations) this.assertTarget(locationSchema.parse(location));
+		const versions = [];
+		for (const collection of new Set(locations.map((location) => location.collection))) {
+			const schema = await this.schema(collection);
+			const columns = fields?.filter((field) => Object.hasOwn(schema.physicalFields, field));
+			const clauses = locations.filter((location) => location.collection === collection).map((location) => sql`(v.entry_id = ${location.entryId} AND v.version = ${location.version} AND v.digest = ${location.digest})`);
+			const result = await sql`SELECT ${columns ? sql.join([
+				...columns.map((field) => sql.ref(`c.${field}`)),
+				sql`v.command AS _command`,
+				sql`v.data AS _metadata`
+			]) : sql`c.*, v.command AS _command, v.data AS _metadata`} FROM _dineway_content_versions v JOIN ${sql.table(`ec_${collection}`)} c ON c.id = v.entry_id AND c._dineway_storage_version = v.version WHERE v.collection = ${collection} AND (${sql.join(clauses, sql` OR `)})`.execute(this.db);
+			for (const row of result.rows) {
+				const metadata = storedMetadata.parse(JSON.parse(row._metadata));
+				const data = fields ? Object.fromEntries(Object.entries(metadata.extra).filter(([field]) => fields.includes(field))) : { ...metadata.extra };
+				for (const [field, type] of Object.entries(metadata.fields)) {
+					if (fields && !fields.includes(field)) continue;
+					if (!Object.hasOwn(row, field)) throw new ContentStorageError("UNAVAILABLE", "A stored content field is missing from its physical table.");
+					const value = row[field];
+					data[field] = value === null ? null : type === "json" ? JSON.parse(z.string().parse(value)) : type === "boolean" ? value === 1 : value;
+				}
+				versions.push(contentVersionSchema.parse({
+					command: JSON.parse(row._command),
+					data
+				}));
+			}
+		}
+		return versions;
+	}
+	schema(collection) {
+		let pending = this.schemas.get(collection);
+		if (!pending) {
+			pending = sql`SELECT schema,physical_schema, digest FROM _dineway_content_store_collections WHERE collection = ${collection}`.execute(this.db).then(async (result) => {
+				const row = result.rows[0];
+				if (!row) throw new ContentStorageError("INVALID_CONFIG", "Content type schema is not installed in this store.");
+				const definition = contentStoreCollectionSchema.parse(JSON.parse(row.schema));
+				if (await contentDigest(definition) !== row.digest) throw new ContentStorageError("UNAVAILABLE", "Content store schema fingerprint does not match.");
+				return {
+					...definition,
+					physicalFields: contentStoreCollectionSchema.parse(JSON.parse(row.physical_schema)).fields
+				};
+			});
+			this.schemas.set(collection, pending);
+		}
+		return pending;
+	}
+	assertTarget(location, write = false) {
+		if (location.store !== this.name || write && location.routingVersion !== this.routingVersion) throw new ContentStorageError("ROUTE_CHANGED", "The content request targets a different store or routing version.");
+	}
+};
+
+//#endregion
+export { contentVersionSchema as a, contentStoreRequestSchema as i, assertContentVersionStore as n, installContentVersionStore as o, contentStoreCollectionSchema as r, ContentVersionStore as t };

package/dist/version-store-B_THJCc0.d.mts

@@ -0,0 +1,98 @@
+import { d as ContentStore, n as ContentPartitionContext, p as PreparedContentVersion, r as ContentPartitionResolver, s as ContentStorageConfig, t as ContentLocation } from "./types-qOEot0UQ.mjs";
+import { Kysely } from "kysely";
+import { z } from "zod";
+
+//#region src/content-storage/config.d.ts
+declare function canonicalContentJson(value: unknown): string;
+declare function contentDigest(value: unknown): Promise<string>;
+declare function validateContentStorage(config: ContentStorageConfig): void;
+declare function resolveContentPartition(config: ContentStorageConfig, context: ContentPartitionContext, resolvers?: Readonly<Record<string, ContentPartitionResolver>>): Promise<{
+  store: string;
+  partition: string;
+} | null>;
+//#endregion
+//#region src/content-storage/version-store.d.ts
+declare const contentStoreCollectionSchema: z.ZodObject<{
+  fields: z.ZodRecord<z.ZodString, z.ZodEnum<{
+    json: "json";
+    text: "text";
+    integer: "integer";
+    real: "real";
+  }>>;
+}, z.core.$strict>;
+type ContentStoreCollection = z.infer<typeof contentStoreCollectionSchema>;
+declare const contentVersionSchema: z.ZodObject<{
+  command: z.ZodObject<{
+    collection: z.ZodString;
+    entryId: z.ZodString;
+    store: z.ZodString;
+    partition: z.ZodString;
+    routingVersion: z.ZodString;
+    version: z.ZodString;
+    digest: z.ZodString;
+    partitionEpoch: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodOptional<z.ZodEnum<{
+      content: "content";
+      revision: "revision";
+    }>>;
+    operationId: z.ZodString;
+    principalId: z.ZodString;
+    expectedVersion: z.ZodNullable<z.ZodString>;
+  }, z.core.$strict>;
+  data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strict>;
+declare const contentStoreRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  action: z.ZodLiteral<"prepare">;
+  value: z.ZodObject<{
+    command: z.ZodObject<{
+      collection: z.ZodString;
+      entryId: z.ZodString;
+      store: z.ZodString;
+      partition: z.ZodString;
+      routingVersion: z.ZodString;
+      version: z.ZodString;
+      digest: z.ZodString;
+      partitionEpoch: z.ZodOptional<z.ZodNumber>;
+      kind: z.ZodOptional<z.ZodEnum<{
+        content: "content";
+        revision: "revision";
+      }>>;
+      operationId: z.ZodString;
+      principalId: z.ZodString;
+      expectedVersion: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+  }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+  action: z.ZodLiteral<"read">;
+  locations: z.ZodArray<z.ZodObject<{
+    collection: z.ZodString;
+    entryId: z.ZodString;
+    store: z.ZodString;
+    partition: z.ZodString;
+    routingVersion: z.ZodString;
+    version: z.ZodString;
+    digest: z.ZodString;
+  }, z.core.$strict>>;
+  fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>], "action">;
+/** Install on content databases explicitly; never called from a content request. */
+declare function installContentVersionStore<DB>(db: Kysely<DB>, identity: string, collections: Record<string, ContentStoreCollection>, options?: {
+  upgrade?: boolean;
+}): Promise<void>;
+/** Validate the physical binding and deployed schema once at request entry. */
+declare function assertContentVersionStore<DB>(db: Kysely<DB>, identity: string): Promise<void>;
+/** Immutable staging versions; only the primary directory can make one visible. */
+declare class ContentVersionStore<DB> implements ContentStore {
+  private readonly db;
+  private readonly name;
+  private readonly routingVersion;
+  private readonly schemas;
+  constructor(db: Kysely<DB>, name: string, routingVersion: string);
+  prepare(input: PreparedContentVersion): Promise<void>;
+  read(locations: readonly ContentLocation[], fields?: readonly string[]): Promise<PreparedContentVersion[]>;
+  private schema;
+  private assertTarget;
+}
+//#endregion
+export { contentStoreRequestSchema as a, canonicalContentJson as c, validateContentStorage as d, contentStoreCollectionSchema as i, contentDigest as l, ContentVersionStore as n, contentVersionSchema as o, assertContentVersionStore as r, installContentVersionStore as s, ContentStoreCollection as t, resolveContentPartition as u };

package/dist/{widgets-BOrDZdQ3.mjs → widgets-B99mnftw.mjs}

@@ -1,6 +1,6 @@
-import { r as getDb } from "./loader-Dp6zLmQm.mjs";
-import { r as requestCached } from "./request-cache-8_ifFzVw.mjs";
-import { t as getWidgetComponents$1 } from "./components-rFN8NH3N.mjs";
+import { r as getDb } from "./loader-Bq1aW12P.mjs";
+import { r as requestCached } from "./request-cache-CizvDoxV.mjs";
+import { t as getWidgetComponents$1 } from "./components-JA6tFHmE.mjs";
 
 //#region src/widgets/index.ts
 /**

package/dist/{wordpress-slugs-ROzITIBK.mjs → wordpress-slugs-yaeD7cxn.mjs}

@@ -1,4 +1,4 @@
-import { a as RESERVED_COLLECTION_SLUGS } from "./types-COvyXIp7.mjs";
+import { a as RESERVED_COLLECTION_SLUGS } from "./types-BgUxCuwu.mjs";
 
 //#region src/import/wordpress-slugs.ts
 const INVALID_SLUG_CHARS = /[^a-z0-9_]/g;