@getquick/content 0.0.0-stage → 0.2.0

package/dist/wordpress-CUFb6YZZ.d.ts

@@ -0,0 +1,384 @@
+import { r as ConsentConfiguration, t as AnalyticsSettings } from "./configuration-C_JGygQI.js";
+import { r as LegalLanguage } from "./legal-C5Xiq59W.js";
+//#endregion
+//#region frontend/src/site-language.d.ts
+/**
+ * The `<html lang>` for a WordPress locale: its language and region as a
+ * BCP 47 tag (pt_PT_ao90 → pt-PT). WordPress's variants (ao90, formal) aren't
+ * BCP 47 subtags, so they are left out; no locale means English.
+ */
+declare function htmlLang(locale: string | undefined): string;
+/** A language the site serves. */
+interface SiteLanguage {
+  /** Its WordPress locale (pt_PT_ao90); empty when configuration names none. */
+  locale: string;
+  /** Polylang's slug, its URL directory: the default language's is its language code. */
+  slug: string;
+  /** Its GraphQL LanguageCodeEnum value: the slug in upper case (pt-br → PT_BR). */
+  code: string;
+  /** Its `<html lang>`. */
+  lang: string;
+  isDefault: boolean;
+  /** Its home route: / for the default language, /<slug>/ for the others. */
+  home: string;
+}
+interface WordPressLanguages {
+  locale?: string;
+  languages?: readonly {
+    locale: string;
+    slug: string;
+  }[];
+}
+/**
+ * configuration's languages: wordpress.locale, the default, served at /, then
+ * each of wordpress.languages under its slug. A monolingual Site has one.
+ */
+declare function siteLanguages(wordpress: WordPressLanguages | undefined): SiteLanguage[];
+/**
+ * A route's language: the one whose slug is its first segment, else the
+ * default language, which has no directory.
+ */
+declare function routeLanguage(route: string, among: readonly SiteLanguage[]): SiteLanguage;
+/**
+ * How logs and reports name something a language has: "the front page" for
+ * the default language's, "the en front page" for another's.
+ */
+declare function languageSubject(language: SiteLanguage, what: string): string;
+/** Whether a route is a language's home (/, /en/): served as a home, never as an entry. */
+declare function isLanguageHome(route: string, among: readonly SiteLanguage[]): boolean;
+declare namespace content_types_d_exports {
+  export { CmsFailure, CmsFailureReason, Delivery, DesignPresets, EntryContent, Extended, Found, HomeContent, Missing, PublishedEntry, SiteChrome, Translation, Unavailable, WordPressImage, WordPressMenuItem, WordPressPost, WordPressSettings };
+}
+interface WordPressImage {
+  sourceUrl: string;
+  altText: string;
+}
+interface WordPressPost {
+  id: string;
+  title: string;
+  excerpt: string;
+  content: string;
+  uri: string;
+  date: string;
+  featuredImage: WordPressImage | null;
+  hasVideoHero: boolean;
+}
+interface WordPressMenuItem {
+  id: string;
+  label: string;
+  href: string;
+  target: string | null;
+  children: WordPressMenuItem[];
+}
+interface WordPressSettings {
+  title: string;
+  description: string;
+}
+interface DesignPresets {
+  spacingSizes: Array<{
+    slug: string;
+    size: string;
+  }>;
+  colors: Array<{
+    slug: string;
+    color: string;
+  }>;
+}
+/**
+ * A page or post's own content as the Site's extension read it
+ * (ContentConfig's `extension`): present only when the Site declares one and
+ * its read returned a value for that page or post.
+ */
+interface Extended<X = unknown> {
+  extension?: X;
+}
+interface HomeContent<X = unknown> extends DesignPresets {
+  /** The front page's WordPress entry (WPGraphQL's global id), if WordPress gave it. */
+  nodeId: string | null;
+  settings: WordPressSettings;
+  page: {
+    title: string;
+    content: string;
+    hasVideoHero: boolean;
+  } & Extended<X>;
+  /** WordPress failed on the blocks, so this is the page without them. */
+  blocksOmitted: boolean;
+}
+/** A published translation of an entry: its URI and its language's slug. */
+interface Translation {
+  uri: string;
+  language: string;
+}
+interface EntryContent<X = unknown> extends WordPressPost, DesignPresets, Extended<X> {
+  /** Its language's slug, on a multilingual Site. */
+  language?: string;
+  /** Its published translations into the site's other languages, on a multilingual Site. */
+  translations?: Translation[];
+  /** WordPress failed on the blocks, so this is the entry without them. */
+  blocksOmitted: boolean;
+  /** When WordPress last modified it (ms, the CMS's clock), if it said. */
+  modifiedAt: number | null;
+}
+/** A published page or post as WordPress lists it: its id, URI and last modification. */
+interface PublishedEntry {
+  /** WPGraphQL's global id, when WordPress gives it. */
+  id: string | null;
+  uri: string;
+  /** When WordPress last modified it (ms, the CMS's clock), if it said. */
+  modifiedAt: number | null;
+}
+interface SiteChrome {
+  menuItems: WordPressMenuItem[];
+  siteIcon: WordPressImage | null;
+  siteLogo: WordPressImage | null;
+  /**
+   * This language's LEGAL-1 Contract from gq-config, on a Site with consent
+   * CMS settings enabled (null when gq-config has none for it).
+   */
+  legal?: LegalLanguage | null;
+  /** gq-config's GA4 settings, on a Site with consent CMS settings enabled. */
+  analytics?: AnalyticsSettings;
+}
+/**
+ * Why WordPress couldn't deliver: it didn't answer in time (`timeout`), couldn't
+ * be reached (`network`), answered with an HTTP error (`http`) or GraphQL errors
+ * (`graphql`), or answered with data missing the fields the Frontend requires
+ * (`schema`).
+ */
+type CmsFailureReason = "timeout" | "network" | "http" | "graphql" | "schema";
+interface CmsFailure {
+  reason: CmsFailureReason;
+  message: string;
+  httpStatus?: number;
+}
+interface Found<T> {
+  kind: "found";
+  content: T;
+}
+/** WordPress answered with valid data, and has nothing published there. */
+interface Missing {
+  kind: "missing";
+}
+/** The content couldn't be read. This says nothing about whether it exists. */
+interface Unavailable {
+  kind: "unavailable";
+  failure: CmsFailure;
+}
+type Delivery<T> = Found<T> | Missing | Unavailable;
+//#endregion
+//#region frontend/src/bindings.d.ts
+interface SqlStatement {
+  bind(...values: unknown[]): SqlStatement;
+  first<T = Record<string, unknown>>(): Promise<T | null>;
+  all<T = Record<string, unknown>>(): Promise<{
+    results: T[];
+  }>;
+  run(): Promise<{
+    meta: {
+      changes: number;
+    };
+  }>;
+}
+interface SqlDatabase {
+  prepare(query: string): SqlStatement;
+  /** Runs the statements in order as one transaction: all of them apply, or none. */
+  batch<T = Record<string, unknown>>(statements: SqlStatement[]): Promise<Array<{
+    results: T[];
+  }>>;
+}
+interface ContentBindings {
+  /** The publication store (D1). */
+  PUBLICATION_DB?: SqlDatabase;
+  /** The trusted refresh's bearer token (a Worker secret). */
+  FRONTEND_REFRESH_TOKEN?: string;
+  /** The key the CMS signs its publication events with (a Worker secret). */
+  PUBLICATION_EVENT_SECRET?: string;
+  /** Read-only CMS edge identity; never the automation service or public env. */
+  GQ_AUTH_GRAPHQL_CLIENT_ID?: string;
+  GQ_AUTH_GRAPHQL_CLIENT_SECRET?: string;
+}
+//#endregion
+//#region frontend/src/page-types.d.ts
+/** The front page as stored: what WordPress delivered, without read details. */
+type HomePublication<X = unknown> = Omit<HomeContent<X>, "blocksOmitted" | "nodeId">;
+/** A published page or post as stored, with the design presets it was read with. */
+type EntryPublication<X = unknown> = Omit<EntryContent<X>, "blocksOmitted" | "modifiedAt">;
+/**
+ * A page in another language that a visitor of this one may switch to: its
+ * published translation (`translation`), or else that language's home.
+ */
+interface Alternate {
+  language: SiteLanguage;
+  route: string;
+  translation: boolean;
+}
+interface HomePage<X = unknown> {
+  home: HomePublication<X>;
+  chrome: SiteChrome;
+  /** The other languages' homes that are served; none on a monolingual Site. */
+  alternates: Alternate[];
+}
+interface EntryPage<X = unknown> {
+  entry: EntryPublication<X>;
+  chrome: SiteChrome;
+  /** Where its readers may switch language; none on a monolingual Site. */
+  alternates: Alternate[];
+}
+/** The entry a route served is published at another URI now: the route redirects there. */
+interface Moved {
+  kind: "moved";
+  uri: string;
+}
+/**
+ * Why there is nothing to serve: the CMS failed (live reads, in explicit development),
+ * the store couldn't be read (`store`), or the Site has never been refreshed,
+ * or holds only state this Frontend can't read (`not-ready`).
+ */
+type DeliveryFailureReason = CmsFailureReason | "store" | "not-ready";
+interface NotServed {
+  kind: "unavailable";
+  failure: {
+    reason: DeliveryFailureReason;
+    message: string;
+  };
+}
+type HomeDelivery<X = unknown> = Found<HomePage<X>> | (Missing & {
+  chrome: SiteChrome | null;
+}) | NotServed;
+type EntryDelivery<X = unknown> = Found<EntryPage<X>> | (Missing & {
+  chrome: SiteChrome | null;
+}) | Moved | NotServed;
+//#endregion
+//#region frontend/src/server.d.ts
+interface ContentConfig<X = never> {
+  site: string;
+  graphqlEndpoint: string;
+  cmsOrigin: string;
+  wordpress?: WordPressLanguages;
+  /** Live delivery without a publication store is opt-in; false by default. */
+  development?: boolean;
+  isServer: () => boolean;
+  bindings: () => ContentBindings | Promise<ContentBindings>;
+  fetch?: typeof globalThis.fetch;
+  /**
+   * CONSENT-1 for this Site. Present, every published body's third-party
+   * embeds are rewritten into consent placeholders (unknown hosts blocked) on
+   * delivery; absent, bodies are delivered as published.
+   */
+  consent?: ContentConsentConfig;
+  /**
+   * The Site's own content on its pages and posts: GraphQL fields the runtime
+   * reads with each of them, and the value the Site makes of them, stored with
+   * the publication and served as its `extension`.
+   */
+  extension?: ContentExtension<X>;
+}
+/**
+ * A Site's own content on its pages and posts, beyond what the runtime reads:
+ * fields a plugin adds to WPGraphQL (a block tree, a page setting), read with
+ * every front page, page and post, stored with it, and served with it through
+ * outages, as the rest of it is.
+ */
+interface ContentExtension<X> {
+  /**
+   * GraphQL selections added to each kind of node the runtime reads: `page`
+   * to front pages and pages, `post` to posts (e.g. `wpBlocksJson`). They are
+   * read with the blocks: a read WordPress can only complete without its
+   * blocks leaves them out too, and isn't stored. A kind without fields has
+   * no extension.
+   */
+  fields: {
+    page?: string;
+    post?: string;
+  };
+  /**
+   * The Site's value for a node WordPress returned (its fields, the runtime's
+   * among them), or undefined when it has none (`extension` is then left
+   * out). It is stored as JSON, so it must survive JSON. Throwing fails the
+   * read as WordPress answering with the wrong schema: what is stored stays
+   * served.
+   */
+  read(node: ExtensionNode): X | undefined;
+  /**
+   * The value read back from the store, or from a read about to be stored
+   * (JSON), or undefined when the Site can't serve it. A stored row whose
+   * extension doesn't parse is unusable, as any body that doesn't; one stored
+   * without an extension (before the Site declared it) still serves, without.
+   * Return a valid value as it is: reconciliation compares it with new reads.
+   */
+  parse(stored: unknown): X | undefined;
+}
+/** A front page, page or post as WordPress returned it, for a Site's extension. */
+interface ExtensionNode {
+  kind: "page" | "post";
+  fields: Readonly<Record<string, unknown>>;
+}
+interface ContentConsentConfig {
+  /** The catalog services the Site declares in code (e.g. "youtube", "google_maps"). */
+  services?: readonly string[];
+  /**
+   * Hosts that are the Site itself besides relative URLs: its Frontend and its
+   * CMS/media origin. The CMS origin is included by default.
+   */
+  firstPartyHosts?: readonly string[];
+  /**
+   * Read gq-config's Legal Contract and GA4 settings into each language's
+   * chrome (requires gq-config with the `getquickLegal` field). Their changes
+   * arrive as `legal` and `analytics` settings events.
+   */
+  cmsSettings?: boolean;
+}
+declare function createContentRuntime<X = never>(input: ContentConfig<X>): {
+  languages: SiteLanguage[];
+  defaultLanguage: SiteLanguage;
+  multilingual: boolean;
+  routeLanguage: (route: string) => SiteLanguage;
+  isLanguageHome: (route: string) => boolean;
+  wordpress: WordPressClient<X>;
+  handleEvent: (request: Request, context?: {
+    siteOrigin?: string;
+  }) => Promise<Response>;
+  handleRefresh: (request: Request, context?: {
+    siteOrigin?: string;
+  }) => Promise<Response>;
+  publishedHome: (siteOrigin?: string, language?: SiteLanguage) => Promise<HomeDelivery<X>>;
+  publishedEntry: (path: string, siteOrigin?: string) => Promise<EntryDelivery<X>>;
+  pageChrome: (siteOrigin?: string) => Promise<SiteChrome | null>;
+  /**
+   * The design presets every page shares (GQ Design's spacing sizes and
+   * colors), for a page that isn't a publication: the stored ones when there
+   * is a store, else (in explicit development) a live read. Null when
+   * neither has them.
+   */
+  designPresets: () => Promise<DesignPresets | null>;
+  /**
+   * The origins a link into this Site may use: WordPress's, and the
+   * Frontend's when given. `menuItemHref` turns links at them into paths.
+   */
+  internalOrigins: (siteOrigin?: string) => string[];
+  /**
+   * The Site's consent configuration for a page served with this chrome:
+   * declared services, GA4 when gq-config's toggle is on, and the
+   * controller from the Legal Contract. Null when consent isn't configured.
+   */
+  consentConfiguration: (chrome?: SiteChrome | null) => ConsentConfiguration | null;
+};
+type ContentRuntime<X = never> = ReturnType<typeof createContentRuntime<X>>;
+//#endregion
+//#region frontend/src/wordpress.d.ts
+interface WordPressClient<X = unknown> {
+  getHomeContent(this: void, language?: SiteLanguage): Promise<Delivery<HomeContent<X>>>;
+  getEntryByUri(this: void, uri: string): Promise<Delivery<EntryContent<X>>>;
+  getDesignPresets(this: void): Promise<Found<DesignPresets> | Unavailable>;
+  getPublishedEntries(this: void): Promise<Found<{
+    entries: PublishedEntry[];
+    requests: number;
+  }> | Unavailable>;
+  getPublishedRoutes(this: void): Promise<Found<string[]> | Unavailable>;
+  getSiteChrome(this: void, siteOrigin?: string, options?: {
+    location?: string;
+    language?: SiteLanguage;
+  }): Promise<Found<SiteChrome> | Unavailable>;
+}
+//#endregion
+export { PublishedEntry as A, htmlLang as B, Delivery as C, Found as D, Extended as E, WordPressMenuItem as F, languageSubject as H, WordPressPost as I, WordPressSettings as L, Translation as M, Unavailable as N, HomeContent as O, WordPressImage as P, SiteLanguage as R, CmsFailureReason as S, EntryContent as T, routeLanguage as U, isLanguageHome as V, siteLanguages as W, NotServed as _, ContentRuntime as a, SqlStatement as b, Alternate as c, EntryPage as d, EntryPublication as f, Moved as g, HomePublication as h, ContentExtension as i, SiteChrome as j, Missing as k, DeliveryFailureReason as l, HomePage as m, ContentConfig as n, ExtensionNode as o, HomeDelivery as p, ContentConsentConfig as r, createContentRuntime as s, WordPressClient as t, EntryDelivery as u, ContentBindings as v, DesignPresets as w, CmsFailure as x, SqlDatabase as y, WordPressLanguages as z };

package/migrations/0001_publications.sql

@@ -0,0 +1,31 @@
+-- The Frontend's durable published content: the last-known-good public
+-- representation of each published thing ("home", "chrome"), and the outcome
+-- of the last refresh of each. Alchemy applies these files in order on deploy
+-- (infra/frontend.run.ts), before the Worker is updated, so a migration must
+-- keep working with the Worker version it replaces: add, never rewrite.
+
+CREATE TABLE publications (
+  -- What the row is: "home" (the front page), "chrome" (menu, logo, icon).
+  key TEXT PRIMARY KEY,
+  -- "published" (body holds it) or "missing" (the CMS confirmed nothing is
+  -- published there).
+  state TEXT NOT NULL,
+  -- The version of body's shape. A Worker only serves the formats it knows.
+  format INTEGER NOT NULL,
+  body TEXT,
+  -- When the CMS read behind this row started (ms since the epoch). A
+  -- promotion only replaces a row whose read started earlier, so a slow or
+  -- delayed refresh can't overwrite a newer one.
+  read_started_at INTEGER NOT NULL,
+  promoted_at INTEGER NOT NULL
+);
+
+CREATE TABLE refresh_attempts (
+  key TEXT PRIMARY KEY,
+  attempted_at INTEGER NOT NULL,
+  -- "promoted", "superseded" (a newer read was already promoted) or "kept"
+  -- (the read failed, so the stored row was left as it was).
+  outcome TEXT NOT NULL,
+  reason TEXT,
+  message TEXT
+);

package/migrations/0002_entries.sql

@@ -0,0 +1,14 @@
+-- Published entries (pages and posts), one row each in publications, keyed
+-- "entry:<uri>". Added for them, and harmless to the Worker version before:
+-- it never names node_id, so its writes leave it NULL.
+
+-- Which WordPress post or page a row holds (WPGraphQL's global id), so a
+-- refresh that finds it at another URI can reconcile the route it left, and
+-- a later withdrawal can find every route that served it.
+ALTER TABLE publications ADD COLUMN node_id TEXT;
+
+CREATE INDEX publications_node_id ON publications (node_id);
+
+-- publications.state gains "moved": the entry the row held is published at
+-- another URI now (body: {"uri": "<its URI>"}), so the route redirects there
+-- instead of presenting its superseded copy as current.

package/migrations/0003_publication_events.sql

@@ -0,0 +1,36 @@
+-- The CMS's publication events (POST /gq/events): one row per event the
+-- Frontend accepted, so a duplicate is recognised, a delayed one can't undo a
+-- newer one, and one whose refresh failed stays on record for a retry. Added
+-- for them, and harmless to the Worker version before: it never reads it.
+
+CREATE TABLE publication_events (
+  -- The event's identity, chosen by the CMS (a UUID). A delivery of an id
+  -- already recorded is a duplicate, or a retry of one that failed.
+  id TEXT PRIMARY KEY,
+  -- What happened: "publish" (a page or post was published or updated).
+  action TEXT NOT NULL,
+  -- The WordPress entry it is about (WPGraphQL's global id), as in
+  -- publications.node_id.
+  node_id TEXT NOT NULL,
+  -- The entry's URI when the event happened, and the one it had before, if it
+  -- moved.
+  uri TEXT NOT NULL,
+  previous_uri TEXT,
+  -- When it happened in the CMS (ms since the epoch): the order of one
+  -- entry's events. An event older than one already refreshed for the same
+  -- entry is superseded, never processed.
+  occurred_at INTEGER NOT NULL,
+  received_at INTEGER NOT NULL,
+  -- "received" (not processed yet, or interrupted), "refreshed", "failed"
+  -- (its refresh kept the stored versions; a retry may process it again) or
+  -- "superseded" (a newer event for the entry was refreshed).
+  status TEXT NOT NULL,
+  attempts INTEGER NOT NULL DEFAULT 0,
+  processed_at INTEGER,
+  -- Why it failed, when it did (a refresh failure reason and its message).
+  reason TEXT,
+  message TEXT
+);
+
+CREATE INDEX publication_events_node ON publication_events (node_id, occurred_at);
+CREATE INDEX publication_events_status ON publication_events (status, received_at);

package/migrations/0004_withdrawals.sql

@@ -0,0 +1,30 @@
+-- The CMS's withdrawals (a page or post unpublished, made private or
+-- password-protected, trashed or deleted): one row per WordPress entry whose
+-- last accepted lifecycle event withdrew it. While a withdrawal is in force,
+-- nothing promotes that entry's content again, whatever a read returns; only a
+-- publication event that happened after it lifts it. Added for them, and
+-- harmless to the Worker version before: it never reads this table, and a
+-- "withdrawn" row is a state it doesn't know, so it serves it as a 503, never
+-- as content.
+
+CREATE TABLE withdrawals (
+  -- The WordPress entry (WPGraphQL's global id), as in publications.node_id.
+  node_id TEXT PRIMARY KEY,
+  -- The withdraw event in force (publication_events.id) and the URI the entry
+  -- had while it was published.
+  event_id TEXT NOT NULL,
+  uri TEXT NOT NULL,
+  -- When it happened in the CMS (ms since the epoch), and when the Frontend
+  -- accepted it (ms, the Frontend's clock).
+  withdrawn_at INTEGER NOT NULL,
+  accepted_at INTEGER NOT NULL,
+  -- The newer publication event that lifted it, and when that happened in the
+  -- CMS. NULL while the withdrawal is in force.
+  republished_by TEXT,
+  republished_at INTEGER
+);
+
+-- publications.state gains "withdrawn": the entry the row held was withdrawn
+-- (body NULL). It is a 404, and nothing older than the withdrawal replaces it.
+-- publication_events.action gains "withdraw"; one that was applied is
+-- recorded "refreshed", like a publication: the store is up to date with it.

package/migrations/0005_reconciliation.sql

@@ -0,0 +1,45 @@
+-- Reconciliation (ADR 0009): the CMS's scheduler asks the Frontend, every
+-- minute, to compare its publication store with what WordPress publishes and
+-- to refresh what differs, so a change whose event never arrived still
+-- reaches visitors. Added for it, and harmless to the Worker version before:
+-- it never names these columns or this table.
+
+-- When WordPress last modified the entry a row holds (ms since the epoch, the
+-- CMS's clock: WPGraphQL's modifiedGmt), as the read that promoted it saw it.
+-- NULL for rows promoted before this column, or by a read without it: a
+-- reconciliation reads those again.
+ALTER TABLE publications ADD COLUMN modified_at INTEGER;
+
+-- The Site's reconciliation: one row, holding the lease that keeps two runs
+-- from overlapping and the outcome of the last run, for diagnostics.
+CREATE TABLE reconciliation (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  -- The run holding the lease (the reconcile event's id), and until when (ms).
+  -- A run that was interrupted leaves it to expire.
+  run_id TEXT,
+  lease_until INTEGER NOT NULL DEFAULT 0,
+  started_at INTEGER,
+  finished_at INTEGER,
+  -- "reconciled" (nothing differs any more), "behind" (changes left for the
+  -- next run) or "failed" (a read or a refresh failed; what was stored is
+  -- kept).
+  outcome TEXT,
+  -- What the last run found: the published entries it compared, the changes it
+  -- refreshed, those it left for the next run, and those whose refresh failed.
+  checked INTEGER,
+  changed INTEGER,
+  pending INTEGER,
+  failed INTEGER,
+  -- The first failure's reason and message (no content, no secret).
+  reason TEXT,
+  message TEXT,
+  -- When the last run that left nothing behind started: the store matched
+  -- WordPress as of then.
+  reconciled_at INTEGER
+);
+
+-- Reconciliation records the change it found in an entry, when WordPress
+-- gives its id and modification time, as a publication event in
+-- publication_events (an id starting "reconcile-", the same for the same
+-- change, and occurred_at its modification time), so it is processed, ordered
+-- and retried by the same rules as one the CMS sent.

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "@getquick/content",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "migrations",
+    "consent-migrations"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./migrations": {
+      "types": "./dist/migrations.d.ts",
+      "import": "./dist/migrations.js"
+    },
+    "./consent": {
+      "types": "./dist/consent.d.ts",
+      "import": "./dist/consent.js"
+    },
+    "./consent/client": {
+      "types": "./dist/consent-client.d.ts",
+      "import": "./dist/consent-client.js"
+    },
+    "./consent/server": {
+      "types": "./dist/consent-server.d.ts",
+      "import": "./dist/consent-server.js"
+    },
+    "./consent/migrations": {
+      "types": "./dist/consent-migrations.d.ts",
+      "import": "./dist/consent-migrations.js"
+    },
+    "./consent/astro": {
+      "types": "./dist/consent-astro.d.ts",
+      "import": "./dist/consent-astro.js"
+    },
+    "./consent/testing": {
+      "types": "./dist/consent-testing.d.ts",
+      "import": "./dist/consent-testing.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "zod": "3.25.76"
+  },
+  "engines": {
+    "node": ">=22"
+  }
 }