@notionx/core 0.1.0

package/dist/bootstrap-CN2g76M6.d.ts

@@ -0,0 +1,67 @@
+import { NextionMiddlewareOptions } from './middleware.js';
+import { AdminNavItem, AuthConfig } from './types.js';
+import { ContentSource } from './content/models.js';
+
+/**
+ * Public surface for the bootstrap options. Mirrors the placeholder
+ * `WorkerOptions` type in `src/types.ts`; Phase 6 normalizes the
+ * shape once the content abstraction lands.
+ */
+interface FoundationWorkerOptions {
+    sources: ContentSource[];
+    adminNav: AdminNavItem[];
+    authConfig: AuthConfig;
+    /**
+     * Placeholder for the future site config. Kept on the options
+     * surface so consumers can wire it today; the bootstrap itself
+     * does not yet consume it.
+     */
+    siteConfig: {
+        name: string;
+        description: string;
+        defaultLocale: string;
+        locales: string[];
+        navigation: unknown[];
+    };
+    /**
+     * Optional session resolver passed straight through to
+     * `nextionMiddleware`. When omitted the middleware still runs
+     * the admin gate but always reports no viewer.
+     */
+    sessionLookup?: NextionMiddlewareOptions["sessionLookup"];
+    /**
+     * Project-injected routes. Each entry maps a pathname to a
+     * dynamic loader. The loader returns a module whose `default`
+     * export is a `(request, options) => Promise<Response>` handler.
+     *
+     * Loaders are invoked lazily on the first matching request so
+     * the route module can pull in heavy dependencies (e.g. the
+     * starter's content models) only when needed.
+     */
+    extraRoutes?: Record<string, () => Promise<{
+        default: FoundationExtraRouteHandler;
+    }>>;
+}
+type FoundationExtraRouteHandler = (request: Request, options: FoundationWorkerOptions, sources: ContentSource[], auth: {
+    databaseBinding: string;
+}) => Promise<Response>;
+interface FoundationWorker {
+    /**
+     * Worker-style fetch. Returns `Response` when foundation handled
+     * the request, `null` to let the caller fall through to vinext.
+     */
+    fetch: (request: Request, env: unknown, ctx: unknown) => Promise<Response | null>;
+}
+/**
+ * Build a foundation Cloudflare Worker.
+ *
+ * The returned object exposes a `fetch` method that:
+ *   1. Runs `nextionMiddleware` (admin gate + viewer attachment).
+ *   2. Tries the first-party route table.
+ *   3. Tries any project-injected `extraRoutes`.
+ *   4. Returns `null` if nothing matched, so the starter wrapper can
+ *      delegate to vinext.
+ */
+declare function createNextionWorker(options: FoundationWorkerOptions): FoundationWorker;
+
+export { type FoundationExtraRouteHandler as F, type FoundationWorker as a, type FoundationWorkerOptions as b, createNextionWorker as c };

package/dist/cache/index.d.ts

@@ -0,0 +1,6 @@
+type PublicMediaVariant = "avif" | "webp" | "source";
+declare function publicMediaVariantForAccept(accept: string): PublicMediaVariant;
+declare function publicMediaCacheKeyForUrl(input: URL, variant: PublicMediaVariant): string;
+declare function notionMediaR2KeyForUrl(input: URL, variant: PublicMediaVariant): string | null;
+
+export { type PublicMediaVariant, notionMediaR2KeyForUrl, publicMediaCacheKeyForUrl, publicMediaVariantForAccept };

package/dist/cache/index.js

@@ -0,0 +1,47 @@
+// src/cache/cache-keys.ts
+var CACHE_ORIGIN = "https://cache.local";
+var CACHE_NAMESPACE = "/__public-cache/v20260609a";
+var NOTION_MEDIA_R2_PREFIX = "notion-media/v1";
+function normalizePath(pathname) {
+  if (pathname === "/") return "/";
+  return pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+}
+function publicMediaVariantForAccept(accept) {
+  if (accept.includes("image/avif")) return "avif";
+  if (accept.includes("image/webp")) return "webp";
+  return "source";
+}
+function publicMediaCacheKeyForUrl(input, variant) {
+  const url = new URL(
+    `${CACHE_NAMESPACE}${normalizePath(input.pathname)}${input.search}`,
+    CACHE_ORIGIN
+  );
+  url.searchParams.set("__variant", variant);
+  url.searchParams.sort();
+  return url.toString();
+}
+function keySegment(value) {
+  return encodeURIComponent(value || "none");
+}
+function notionMediaR2KeyForUrl(input, variant) {
+  if (variant === "source") return null;
+  const version = input.searchParams.get("v");
+  if (!version) return null;
+  const path = normalizePath(input.pathname).split("/").filter(Boolean).map(keySegment).join("/");
+  const width = input.searchParams.get("w") ?? "source";
+  const quality = input.searchParams.get("q") ?? "source";
+  return [
+    NOTION_MEDIA_R2_PREFIX,
+    variant,
+    path,
+    `v-${keySegment(version)}`,
+    `w-${keySegment(width)}`,
+    `q-${keySegment(quality)}.${variant}`
+  ].join("/");
+}
+export {
+  notionMediaR2KeyForUrl,
+  publicMediaCacheKeyForUrl,
+  publicMediaVariantForAccept
+};
+//# sourceMappingURL=index.js.map

package/dist/cache/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cache/cache-keys.ts"],"sourcesContent":["// Edge cache keys for transformed Notion media responses.\n//\n// Page and API route caching is handled by vinext's CDN cache adapter\n// (vite.config.ts). These helpers remain for the media proxy route.\n\nconst CACHE_ORIGIN = \"https://cache.local\";\nconst CACHE_NAMESPACE = \"/__public-cache/v20260609a\";\nconst NOTION_MEDIA_R2_PREFIX = \"notion-media/v1\";\n\nexport type PublicMediaVariant = \"avif\" | \"webp\" | \"source\";\n\nfunction normalizePath(pathname: string) {\n  if (pathname === \"/\") return \"/\";\n  return pathname.endsWith(\"/\") ? pathname.slice(0, -1) : pathname;\n}\n\nexport function publicMediaVariantForAccept(accept: string): PublicMediaVariant {\n  if (accept.includes(\"image/avif\")) return \"avif\";\n  if (accept.includes(\"image/webp\")) return \"webp\";\n  return \"source\";\n}\n\nexport function publicMediaCacheKeyForUrl(\n  input: URL,\n  variant: PublicMediaVariant\n) {\n  const url = new URL(\n    `${CACHE_NAMESPACE}${normalizePath(input.pathname)}${input.search}`,\n    CACHE_ORIGIN\n  );\n  url.searchParams.set(\"__variant\", variant);\n  url.searchParams.sort();\n  return url.toString();\n}\n\nfunction keySegment(value: string) {\n  return encodeURIComponent(value || \"none\");\n}\n\nexport function notionMediaR2KeyForUrl(\n  input: URL,\n  variant: PublicMediaVariant\n) {\n  if (variant === \"source\") return null;\n\n  const version = input.searchParams.get(\"v\");\n  if (!version) return null;\n\n  const path = normalizePath(input.pathname)\n    .split(\"/\")\n    .filter(Boolean)\n    .map(keySegment)\n    .join(\"/\");\n  const width = input.searchParams.get(\"w\") ?? \"source\";\n  const quality = input.searchParams.get(\"q\") ?? \"source\";\n\n  return [\n    NOTION_MEDIA_R2_PREFIX,\n    variant,\n    path,\n    `v-${keySegment(version)}`,\n    `w-${keySegment(width)}`,\n    `q-${keySegment(quality)}.${variant}`,\n  ].join(\"/\");\n}\n"],"mappings":";AAKA,IAAM,eAAe;AACrB,IAAM,kBAAkB;AACxB,IAAM,yBAAyB;AAI/B,SAAS,cAAc,UAAkB;AACvC,MAAI,aAAa,IAAK,QAAO;AAC7B,SAAO,SAAS,SAAS,GAAG,IAAI,SAAS,MAAM,GAAG,EAAE,IAAI;AAC1D;AAEO,SAAS,4BAA4B,QAAoC;AAC9E,MAAI,OAAO,SAAS,YAAY,EAAG,QAAO;AAC1C,MAAI,OAAO,SAAS,YAAY,EAAG,QAAO;AAC1C,SAAO;AACT;AAEO,SAAS,0BACd,OACA,SACA;AACA,QAAM,MAAM,IAAI;AAAA,IACd,GAAG,eAAe,GAAG,cAAc,MAAM,QAAQ,CAAC,GAAG,MAAM,MAAM;AAAA,IACjE;AAAA,EACF;AACA,MAAI,aAAa,IAAI,aAAa,OAAO;AACzC,MAAI,aAAa,KAAK;AACtB,SAAO,IAAI,SAAS;AACtB;AAEA,SAAS,WAAW,OAAe;AACjC,SAAO,mBAAmB,SAAS,MAAM;AAC3C;AAEO,SAAS,uBACd,OACA,SACA;AACA,MAAI,YAAY,SAAU,QAAO;AAEjC,QAAM,UAAU,MAAM,aAAa,IAAI,GAAG;AAC1C,MAAI,CAAC,QAAS,QAAO;AAErB,QAAM,OAAO,cAAc,MAAM,QAAQ,EACtC,MAAM,GAAG,EACT,OAAO,OAAO,EACd,IAAI,UAAU,EACd,KAAK,GAAG;AACX,QAAM,QAAQ,MAAM,aAAa,IAAI,GAAG,KAAK;AAC7C,QAAM,UAAU,MAAM,aAAa,IAAI,GAAG,KAAK;AAE/C,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,KAAK,WAAW,OAAO,CAAC;AAAA,IACxB,KAAK,WAAW,KAAK,CAAC;AAAA,IACtB,KAAK,WAAW,OAAO,CAAC,IAAI,OAAO;AAAA,EACrC,EAAE,KAAK,GAAG;AACZ;","names":[]}

package/dist/content/admin-summary.d.ts

@@ -0,0 +1,24 @@
+import { ContentModelDefinition } from './models.js';
+import { NotionFieldMap } from '../notion/types.js';
+
+type ContentModelAdminSummary = {
+    id: string;
+    name: string;
+    kind: ContentModelDefinition["kind"];
+    visibility: "public" | "admin" | "public+admin" | "private";
+    listPath: string;
+    detailPath: string;
+    publicApiPath?: string;
+    dataSourceEnv: string;
+    hasDefaultDataSource: boolean;
+    fieldCount: number;
+    capabilities: {
+        richBlocks: boolean;
+        coverImages: boolean;
+        gatedAssets: boolean;
+    };
+};
+declare function summarizeContentModelForAdmin(model: ContentModelDefinition<NotionFieldMap>): ContentModelAdminSummary;
+declare function getContentModelAdminSummaries(models?: readonly ContentModelDefinition<NotionFieldMap>[]): ContentModelAdminSummary[];
+
+export { type ContentModelAdminSummary, getContentModelAdminSummaries, summarizeContentModelForAdmin };

package/dist/content/admin-summary.js

@@ -0,0 +1,36 @@
+// src/content/models.ts
+var registry = [];
+function getRegisteredSources() {
+  return registry;
+}
+
+// src/content/admin-summary.ts
+function visibilityFor(model) {
+  if (model.visibility.public && model.visibility.admin) return "public+admin";
+  if (model.visibility.public) return "public";
+  if (model.visibility.admin) return "admin";
+  return "private";
+}
+function summarizeContentModelForAdmin(model) {
+  return {
+    id: model.id,
+    name: model.ui.name,
+    kind: model.kind,
+    visibility: visibilityFor(model),
+    listPath: model.routes.listPath,
+    detailPath: model.routes.detailPath,
+    publicApiPath: model.routes.publicApiPath,
+    dataSourceEnv: model.source.dataSourceEnv,
+    hasDefaultDataSource: Boolean(model.source.defaultDataSourceId),
+    fieldCount: Object.keys(model.source.fields).length,
+    capabilities: model.capabilities
+  };
+}
+function getContentModelAdminSummaries(models = getRegisteredSources()) {
+  return models.map(summarizeContentModelForAdmin);
+}
+export {
+  getContentModelAdminSummaries,
+  summarizeContentModelForAdmin
+};
+//# sourceMappingURL=admin-summary.js.map

package/dist/content/admin-summary.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/content/models.ts","../../src/content/admin-summary.ts"],"sourcesContent":["// packages/nextion/src/content/models.ts\n//\n// Canonical content-source shape and a module-level registry.\n//\n// The starter's `defineContentModel` returns the same value passed in.\n// The foundation's `defineContentSource` adds a side effect: it stores\n// the value in a process-wide registry so other packages (admin pages,\n// search index, revalidation) can discover content sources without\n// reaching back into the starter.\n//\n// Existing values from the starter pass through unchanged: `ContentSource`\n// is a structural alias of the prior `ContentModelDefinition<TFields>` so\n// source field-maps stay narrowly typed through the boundary.\n\nimport type {\n  NotionFieldMap,\n  NotionSort,\n  NotionSortDirection,\n} from \"../notion/types\";\n\nexport type { NotionFieldMap, NotionSort, NotionSortDirection };\n\n/**\n * Canonical content-source shape. The shape mirrors the starter's\n * prior `ContentModelDefinition` exactly so that registered sources\n * remain type-compatible across the package boundary.\n */\nexport type ContentModelDefinition<\n  TFields extends NotionFieldMap = NotionFieldMap,\n> = {\n  id: string;\n  kind: \"article\" | \"catalog\" | \"directory\";\n  visibility: {\n    public: boolean;\n    admin: boolean;\n  };\n  source: {\n    type: \"notion\";\n    tokenEnv: \"NOTION_TOKEN\";\n    dataSourceEnv: string;\n    defaultDataSourceId?: string;\n    fields: TFields;\n    query: {\n      pageSize: number;\n      sorts?: readonly NotionSort[];\n      filterProperties?: readonly string[];\n    };\n  };\n  routes: {\n    listPath: string;\n    detailPath: string;\n    detailParam: string;\n    publicApiPath?: string;\n  };\n  ui: {\n    name: string;\n    pluralName: string;\n    navLabel: string;\n    listTitle: string;\n    listDescription: string;\n    emptyState: string;\n  };\n  capabilities: {\n    richBlocks: boolean;\n    coverImages: boolean;\n    gatedAssets: boolean;\n  };\n};\n\n/**\n * Public alias for `ContentModelDefinition`. External consumers import\n * this name from `@notionx/core/content`; the internal\n * `ContentModelDefinition` name remains available for the starter's\n * `model.ts`.\n */\nexport type ContentSource<\n  TFields extends NotionFieldMap = NotionFieldMap,\n> = ContentModelDefinition<TFields>;\n\nconst registry: ContentSource[] = [];\n\n/**\n * Register a content source. Returns the value unchanged. Re-registering\n * the same `id` replaces the prior value (idempotent on the id, useful\n * for HMR + tests).\n */\nexport function defineContentSource<const TFields extends NotionFieldMap>(\n  model: ContentModelDefinition<TFields>\n): ContentModelDefinition<TFields> {\n  const existing = registry.findIndex((s) => s.id === model.id);\n  if (existing >= 0) registry[existing] = model;\n  else registry.push(model);\n  return model;\n}\n\nexport function getRegisteredSources(): readonly ContentSource[] {\n  return registry;\n}\n\nexport function getRegisteredSource(id: string): ContentSource | undefined {\n  return registry.find((s) => s.id === id);\n}\n\n/**\n * Test-only escape hatch: empties the registry so vitest cases do not\n * leak state between files. Not for production use.\n */\nexport function clearRegistryForTests(): void {\n  registry.length = 0;\n}\n","// packages/nextion/src/content/admin-summary.ts\n//\n// Generic admin summary helpers for content sources.\n\nimport type {\n  ContentModelDefinition,\n  NotionFieldMap,\n} from \"./models\";\nimport { getRegisteredSources } from \"./models\";\n\nexport type ContentModelAdminSummary = {\n  id: string;\n  name: string;\n  kind: ContentModelDefinition[\"kind\"];\n  visibility: \"public\" | \"admin\" | \"public+admin\" | \"private\";\n  listPath: string;\n  detailPath: string;\n  publicApiPath?: string;\n  dataSourceEnv: string;\n  hasDefaultDataSource: boolean;\n  fieldCount: number;\n  capabilities: {\n    richBlocks: boolean;\n    coverImages: boolean;\n    gatedAssets: boolean;\n  };\n};\n\nfunction visibilityFor(model: ContentModelDefinition<NotionFieldMap>) {\n  if (model.visibility.public && model.visibility.admin) return \"public+admin\";\n  if (model.visibility.public) return \"public\";\n  if (model.visibility.admin) return \"admin\";\n  return \"private\";\n}\n\nexport function summarizeContentModelForAdmin(\n  model: ContentModelDefinition<NotionFieldMap>\n): ContentModelAdminSummary {\n  return {\n    id: model.id,\n    name: model.ui.name,\n    kind: model.kind,\n    visibility: visibilityFor(model),\n    listPath: model.routes.listPath,\n    detailPath: model.routes.detailPath,\n    publicApiPath: model.routes.publicApiPath,\n    dataSourceEnv: model.source.dataSourceEnv,\n    hasDefaultDataSource: Boolean(model.source.defaultDataSourceId),\n    fieldCount: Object.keys(model.source.fields).length,\n    capabilities: model.capabilities,\n  };\n}\n\nexport function getContentModelAdminSummaries(\n  models: readonly ContentModelDefinition<NotionFieldMap>[] = getRegisteredSources()\n) {\n  return models.map(summarizeContentModelForAdmin);\n}\n"],"mappings":";AA+EA,IAAM,WAA4B,CAAC;AAgB5B,SAAS,uBAAiD;AAC/D,SAAO;AACT;;;ACrEA,SAAS,cAAc,OAA+C;AACpE,MAAI,MAAM,WAAW,UAAU,MAAM,WAAW,MAAO,QAAO;AAC9D,MAAI,MAAM,WAAW,OAAQ,QAAO;AACpC,MAAI,MAAM,WAAW,MAAO,QAAO;AACnC,SAAO;AACT;AAEO,SAAS,8BACd,OAC0B;AAC1B,SAAO;AAAA,IACL,IAAI,MAAM;AAAA,IACV,MAAM,MAAM,GAAG;AAAA,IACf,MAAM,MAAM;AAAA,IACZ,YAAY,cAAc,KAAK;AAAA,IAC/B,UAAU,MAAM,OAAO;AAAA,IACvB,YAAY,MAAM,OAAO;AAAA,IACzB,eAAe,MAAM,OAAO;AAAA,IAC5B,eAAe,MAAM,OAAO;AAAA,IAC5B,sBAAsB,QAAQ,MAAM,OAAO,mBAAmB;AAAA,IAC9D,YAAY,OAAO,KAAK,MAAM,OAAO,MAAM,EAAE;AAAA,IAC7C,cAAc,MAAM;AAAA,EACtB;AACF;AAEO,SAAS,8BACd,SAA4D,qBAAqB,GACjF;AACA,SAAO,OAAO,IAAI,6BAA6B;AACjD;","names":[]}

package/dist/content/index.d.ts

@@ -0,0 +1,9 @@
+export { ContentModelDefinition, ContentSource, clearRegistryForTests, defineContentSource, getRegisteredSource, getRegisteredSources } from './models.js';
+export { ContentRevalidateRequest, InvalidationKind, RevalidatePathFn, authorizeContentRevalidate, buildContentRevalidationPaths, previewContentModelInvalidation, readContentRevalidateRequest, readContentRevalidateRequestFromUrl } from './revalidate.js';
+export { SearchIndexDocument, SearchIndexedItem, deleteSearchIndexDocument, deleteSearchIndexForModel, filterItemsBySearchIndex, getMissingSearchIndexRouteIds, matchesIndexedItem, querySearchIndexRouteIds, upsertSearchIndexDocument } from './search-index.js';
+export { filterMoviesBySearch, filterPostsBySearch, matchesSearchQuery, normalizeSearchQuery } from './search.js';
+export { ContentPrewarmModelResult, ContentPrewarmResult, PrewarmTarget, prewarmPublicContentSearchIndex } from './prewarm.js';
+export { ContentModelAdminSummary, getContentModelAdminSummaries, summarizeContentModelForAdmin } from './admin-summary.js';
+export { NotionFieldMap, NotionSort, NotionSortDirection } from '../notion/types.js';
+import '../platform/runtime.js';
+import '../env-C5qu-0R-.js';

package/dist/content/index.js

@@ -0,0 +1,473 @@
+// src/content/models.ts
+var registry = [];
+function defineContentSource(model) {
+  const existing = registry.findIndex((s) => s.id === model.id);
+  if (existing >= 0) registry[existing] = model;
+  else registry.push(model);
+  return model;
+}
+function getRegisteredSources() {
+  return registry;
+}
+function getRegisteredSource(id) {
+  return registry.find((s) => s.id === id);
+}
+function clearRegistryForTests() {
+  registry.length = 0;
+}
+
+// src/i18n/config.ts
+var supportedLocales = ["zh-CN", "en-US"];
+function isAppLocale(value) {
+  return supportedLocales.includes(value);
+}
+function expandLocalizedMoviePaths(paths, locale) {
+  const locales = locale && isAppLocale(locale) ? [locale] : [...supportedLocales];
+  const expanded = [];
+  for (const path of paths) {
+    if (path === "/movies" || path.startsWith("/movies/")) {
+      for (const currentLocale of locales) {
+        expanded.push(`/${currentLocale}${path}`);
+      }
+      continue;
+    }
+    expanded.push(path);
+  }
+  return Array.from(new Set(expanded));
+}
+
+// src/content/revalidate.ts
+function asObject(input) {
+  return input && typeof input === "object" && !Array.isArray(input) ? input : null;
+}
+function readString(input, key) {
+  const value = input[key];
+  return typeof value === "string" ? value.trim() : "";
+}
+function readKind(input) {
+  const value = readString(input, "kind");
+  if (value === "publish" || value === "delete" || value === "update") {
+    return value;
+  }
+  return "update";
+}
+function detailPathForRouteId(detailPath, routeId) {
+  return detailPath.replace(/\[[^\]]+\]/g, routeId);
+}
+function publicApiDetailPathForRouteId(publicApiPath, routeId) {
+  return `${publicApiPath.replace(/\/+$/, "")}/${routeId.replace(/^\/+/, "")}`;
+}
+function bearerToken(request) {
+  const authorization = request.headers.get("authorization") ?? "";
+  const match = authorization.match(/^Bearer\s+(.+)$/i);
+  return match?.[1]?.trim() ?? "";
+}
+function timingSafeEqualString(a, b) {
+  const encoder = new TextEncoder();
+  const left = encoder.encode(a);
+  const right = encoder.encode(b);
+  if (left.byteLength !== right.byteLength) return false;
+  let diff = 0;
+  for (let index = 0; index < left.byteLength; index += 1) {
+    diff |= (left[index] ?? 0) ^ (right[index] ?? 0);
+  }
+  return diff === 0;
+}
+function shouldLocalizeMoviePaths(modelId) {
+  return modelId === "movies" || modelId === "movie-translations";
+}
+function buildContentRevalidationPaths(input) {
+  const pagePaths = [input.model.routes.listPath];
+  const routePaths = [];
+  if (input.routeId) {
+    pagePaths.push(
+      detailPathForRouteId(input.model.routes.detailPath, input.routeId)
+    );
+  }
+  if (input.previousRouteId) {
+    pagePaths.push(
+      detailPathForRouteId(
+        input.model.routes.detailPath,
+        input.previousRouteId
+      )
+    );
+  }
+  if (input.localizedMovieDetailPaths?.length) {
+    pagePaths.push(...input.localizedMovieDetailPaths);
+  }
+  if (input.includeApi !== false && input.model.routes.publicApiPath) {
+    routePaths.push(input.model.routes.publicApiPath);
+    if (input.routeId) {
+      routePaths.push(
+        publicApiDetailPathForRouteId(
+          input.model.routes.publicApiPath,
+          input.routeId
+        )
+      );
+    }
+    if (input.previousRouteId) {
+      routePaths.push(
+        publicApiDetailPathForRouteId(
+          input.model.routes.publicApiPath,
+          input.previousRouteId
+        )
+      );
+    }
+  }
+  const localizedPagePaths = shouldLocalizeMoviePaths(input.model.id) ? expandLocalizedMoviePaths(pagePaths, input.locale) : pagePaths;
+  return {
+    pagePaths: Array.from(new Set(localizedPagePaths)),
+    routePaths: Array.from(new Set(routePaths)),
+    all: Array.from(/* @__PURE__ */ new Set([...localizedPagePaths, ...routePaths]))
+  };
+}
+function authorizeContentRevalidate(request, token) {
+  const expected = String(token ?? "").trim();
+  if (!expected) return false;
+  const actual = bearerToken(request);
+  return Boolean(actual && timingSafeEqualString(actual, expected));
+}
+async function readContentRevalidateRequest(request) {
+  const body = asObject(await request.json().catch(() => null));
+  if (!body) return null;
+  const modelId = readString(body, "modelId");
+  const pageId = readString(body, "pageId");
+  const routeId = readString(body, "routeId");
+  const previousRouteId = readString(body, "previousRouteId");
+  const locale = readString(body, "locale");
+  return {
+    modelId,
+    pageId: pageId || void 0,
+    routeId: routeId || void 0,
+    previousRouteId: previousRouteId || void 0,
+    locale: locale || void 0,
+    kind: readKind(body),
+    includeApi: body.includeApi !== false
+  };
+}
+function readContentRevalidateRequestFromUrl(url) {
+  const modelId = url.searchParams.get("modelId")?.trim() ?? "";
+  if (!modelId) return null;
+  const kind = url.searchParams.get("kind")?.trim() ?? "";
+  const includeApi = url.searchParams.get("includeApi");
+  return {
+    modelId,
+    pageId: url.searchParams.get("pageId")?.trim() || void 0,
+    routeId: url.searchParams.get("routeId")?.trim() || void 0,
+    previousRouteId: url.searchParams.get("previousRouteId")?.trim() || void 0,
+    locale: url.searchParams.get("locale")?.trim() || void 0,
+    kind: kind === "publish" || kind === "delete" || kind === "update" ? kind : "update",
+    includeApi: includeApi !== "false"
+  };
+}
+function previewContentModelInvalidation(input) {
+  const model = getRegisteredSource(input.modelId);
+  if (!model) {
+    throw new Error(`Unknown content model: ${input.modelId}`);
+  }
+  return buildContentRevalidationPaths({
+    model,
+    routeId: input.routeId,
+    previousRouteId: input.previousRouteId,
+    includeApi: input.includeApi
+  });
+}
+
+// src/content/search.ts
+function normalizeSearchQuery(query) {
+  return String(query ?? "").normalize("NFKC").trim().replace(/\s+/g, " ").toLowerCase();
+}
+function searchTerms(query) {
+  const normalized = normalizeSearchQuery(query);
+  return normalized ? normalized.split(" ") : [];
+}
+function searchableText(values) {
+  return values.flatMap((value) => Array.isArray(value) ? value : [value]).filter(
+    (value) => ["string", "number", "boolean"].includes(typeof value)
+  ).map((value) => String(value)).join(" ").normalize("NFKC").toLowerCase();
+}
+function matchesSearchQuery(values, query) {
+  const terms = searchTerms(query);
+  if (terms.length === 0) return true;
+  const haystack = searchableText(values);
+  return terms.every((term) => haystack.includes(term));
+}
+function filterPostsBySearch(posts, query) {
+  return posts.filter(
+    (post) => matchesSearchQuery(
+      [
+        post.title,
+        post.description,
+        post.author,
+        post.tags,
+        post.slug,
+        post.date
+      ],
+      query
+    )
+  );
+}
+function filterMoviesBySearch(movies, query) {
+  return movies.filter(
+    (movie) => matchesSearchQuery(
+      [
+        movie.title,
+        movie.summary,
+        movie.director,
+        movie.actors,
+        movie.genres,
+        movie.releaseDate,
+        movie.routeId
+      ],
+      query
+    )
+  );
+}
+
+// src/content/search-index.ts
+function indexValuesForItem(item) {
+  return [
+    item.title,
+    item.description,
+    item.author,
+    item.tags,
+    item.slug,
+    item.date,
+    item.summary,
+    item.director,
+    item.actors,
+    item.genres,
+    item.routeId,
+    item.releaseDate
+  ];
+}
+function routeIdForItem(item) {
+  return item.routeId ?? item.slug ?? "";
+}
+function routeOrder(items) {
+  const order = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    const routeId = routeIdForItem(item);
+    if (routeId) order.set(routeId, index);
+  });
+  return order;
+}
+function uniqueValues(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+}
+async function upsertSearchIndexDocument(db, document) {
+  const normalizedText = [
+    document.title,
+    document.summary,
+    document.bodyText,
+    ...document.facets
+  ].join(" ").normalize("NFKC").replace(/\s+/g, " ").toLowerCase();
+  await db.prepare(
+    `INSERT INTO content_search_index (
+        model_id,
+        page_id,
+        route_id,
+        title,
+        summary,
+        body_text,
+        facets,
+        normalized_text,
+        source_updated_at,
+        indexed_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(model_id, route_id) DO UPDATE SET
+        page_id = excluded.page_id,
+        title = excluded.title,
+        summary = excluded.summary,
+        body_text = excluded.body_text,
+        facets = excluded.facets,
+        normalized_text = excluded.normalized_text,
+        source_updated_at = excluded.source_updated_at,
+        indexed_at = excluded.indexed_at`
+  ).bind(
+    document.modelId,
+    document.pageId,
+    document.routeId,
+    document.title,
+    document.summary,
+    document.bodyText,
+    JSON.stringify(uniqueValues([...document.facets])),
+    normalizedText,
+    document.sourceUpdatedAt ?? null
+  ).run();
+}
+async function deleteSearchIndexDocument(db, input) {
+  await db.prepare(
+    "DELETE FROM content_search_index WHERE model_id = ? AND route_id = ?"
+  ).bind(input.modelId, input.routeId).run();
+}
+async function deleteSearchIndexForModel(db, input) {
+  await db.prepare("DELETE FROM content_search_index WHERE model_id = ?").bind(input.modelId).run();
+}
+async function getMissingSearchIndexRouteIds(db, input) {
+  const routeIds = uniqueValues([...input.routeIds]);
+  if (routeIds.length === 0) return [];
+  const placeholders = routeIds.map(() => "?").join(", ");
+  const result = await db.prepare(
+    `SELECT route_id
+       FROM content_search_index
+       WHERE model_id = ? AND route_id IN (${placeholders})`
+  ).bind(input.modelId, ...routeIds).all();
+  const present = new Set((result.results ?? []).map((row) => row.route_id));
+  return routeIds.filter((routeId) => !present.has(routeId));
+}
+async function querySearchIndexRouteIds(db, input) {
+  const query = normalizeSearchQuery(input.query);
+  if (!query) return [];
+  const terms = query.split(" ").map((term) => `%${term}%`);
+  const clauses = terms.map(
+    () => "(normalized_text LIKE ? OR title LIKE ? OR summary LIKE ? OR facets LIKE ?)"
+  ).join(" AND ");
+  const values = terms.flatMap((term) => [term, term, term, term]);
+  const result = await db.prepare(
+    `SELECT route_id
+       FROM content_search_index
+       WHERE model_id = ? AND ${clauses}
+       ORDER BY indexed_at DESC
+       LIMIT ?`
+  ).bind(input.modelId, ...values, input.limit ?? 200).all();
+  return (result.results ?? []).map((row) => row.route_id).filter((routeId) => typeof routeId === "string");
+}
+async function filterItemsBySearchIndex(items, query, input) {
+  const normalized = normalizeSearchQuery(query);
+  if (!normalized) return [...items];
+  if (!input.getDatabase) return input.filterFallback(items, normalized);
+  try {
+    const db = await input.getDatabase();
+    if (!db) return input.filterFallback(items, normalized);
+    const routeIds = await querySearchIndexRouteIds(db, {
+      modelId: input.modelId,
+      query: normalized,
+      limit: Math.max(items.length, 200)
+    });
+    if (routeIds.length === 0) return input.filterFallback(items, normalized);
+    const order = routeOrder(items);
+    const matched = new Set(routeIds);
+    return items.filter((item) => matched.has(routeIdForItem(item))).sort(
+      (a, b) => (order.get(routeIdForItem(a)) ?? 0) - (order.get(routeIdForItem(b)) ?? 0)
+    );
+  } catch (error) {
+    console.warn(
+      JSON.stringify({
+        tag: "content_search_index_error",
+        modelId: input.modelId,
+        message: error instanceof Error ? error.message : String(error)
+      })
+    );
+    return input.filterFallback(items, normalized);
+  }
+}
+function matchesIndexedItem(item, query) {
+  return matchesSearchQuery(indexValuesForItem(item), query);
+}
+
+// src/content/prewarm.ts
+function logContentPrewarm(fields) {
+  try {
+    console.log(JSON.stringify({ tag: "content_prewarm", ...fields }));
+  } catch {
+  }
+}
+async function prewarmPublicContentSearchIndex(targets, options) {
+  const startedAtDate = /* @__PURE__ */ new Date();
+  const startedAt = startedAtDate.toISOString();
+  const t0 = performance.now();
+  const requestedModels = new Set(options?.models?.filter(Boolean));
+  const selected = requestedModels.size > 0 ? targets.filter((target) => requestedModels.has(target.modelId)) : targets;
+  const models = [];
+  for (const target of selected) {
+    try {
+      const result = await target.run();
+      models.push({
+        modelId: target.modelId,
+        ok: true,
+        total: result.total,
+        indexed: result.indexed,
+        skipped: result.skipped
+      });
+    } catch (error) {
+      models.push({
+        modelId: target.modelId,
+        ok: false,
+        total: 0,
+        indexed: 0,
+        skipped: true,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const output = {
+    ok: models.every((model) => model.ok),
+    startedAt,
+    finishedAt,
+    durationMs: Math.round((performance.now() - t0) * 100) / 100,
+    models
+  };
+  logContentPrewarm({
+    ok: output.ok,
+    started_at: output.startedAt,
+    finished_at: output.finishedAt,
+    duration_ms: output.durationMs,
+    models: output.models
+  });
+  return output;
+}
+
+// src/content/admin-summary.ts
+function visibilityFor(model) {
+  if (model.visibility.public && model.visibility.admin) return "public+admin";
+  if (model.visibility.public) return "public";
+  if (model.visibility.admin) return "admin";
+  return "private";
+}
+function summarizeContentModelForAdmin(model) {
+  return {
+    id: model.id,
+    name: model.ui.name,
+    kind: model.kind,
+    visibility: visibilityFor(model),
+    listPath: model.routes.listPath,
+    detailPath: model.routes.detailPath,
+    publicApiPath: model.routes.publicApiPath,
+    dataSourceEnv: model.source.dataSourceEnv,
+    hasDefaultDataSource: Boolean(model.source.defaultDataSourceId),
+    fieldCount: Object.keys(model.source.fields).length,
+    capabilities: model.capabilities
+  };
+}
+function getContentModelAdminSummaries(models = getRegisteredSources()) {
+  return models.map(summarizeContentModelForAdmin);
+}
+export {
+  authorizeContentRevalidate,
+  buildContentRevalidationPaths,
+  clearRegistryForTests,
+  defineContentSource,
+  deleteSearchIndexDocument,
+  deleteSearchIndexForModel,
+  filterItemsBySearchIndex,
+  filterMoviesBySearch,
+  filterPostsBySearch,
+  getContentModelAdminSummaries,
+  getMissingSearchIndexRouteIds,
+  getRegisteredSource,
+  getRegisteredSources,
+  matchesIndexedItem,
+  matchesSearchQuery,
+  normalizeSearchQuery,
+  previewContentModelInvalidation,
+  prewarmPublicContentSearchIndex,
+  querySearchIndexRouteIds,
+  readContentRevalidateRequest,
+  readContentRevalidateRequestFromUrl,
+  summarizeContentModelForAdmin,
+  upsertSearchIndexDocument
+};
+//# sourceMappingURL=index.js.map