@murumets-ee/content 0.95.0 → 0.97.0

package/dist/{schema-IML1rRU_.mjs.map → schema-LlK6EkOJ.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"schema-IML1rRU_.mjs","names":[],"sources":["../src/paths/errors.ts","../src/paths/generate-path.ts","../src/paths/redirect-target.ts","../src/paths/resolve.ts","../src/redirects/schema.ts"],"sourcesContent":["/**\n * Domain errors thrown by the pre-commit `pathConflictGuard` (plan/routing PR03,\n * F010). Distinct classes so the admin-ui API handler can map them to a 4xx\n * (caller-actionable) rather than a generic 500, and so callers can branch on\n * `instanceof`.\n */\n\n/**\n * A document's candidate canonical URL is already claimed by a DIFFERENT\n * document in the same locale, and it can't be auto-resolved: either the slug\n * is manually pinned (`slug_mode = 'manual'`), or the auto-suffix ladder was\n * exhausted / there is no slug to suffix. The write is aborted before commit.\n */\nexport class PathConflictError extends Error {\n  readonly entityName: string\n  readonly locale: string\n  readonly path: string\n  /** The id of the document already holding `(locale, path)`, when known. */\n  readonly conflictingEntityId: string | undefined\n\n  constructor(\n    entityName: string,\n    locale: string,\n    path: string,\n    conflictingEntityId?: string,\n    message?: string,\n  ) {\n    super(\n      message ??\n        `Path \"${path}\" (locale \"${locale}\") is already used by another ${entityName} document. ` +\n          `Choose a different slug, or set this document's slug manually.`,\n    )\n    this.name = 'PathConflictError'\n    this.entityName = entityName\n    this.locale = locale\n    this.path = path\n    this.conflictingEntityId = conflictingEntityId\n  }\n}\n\n/**\n * A document's resolved canonical URL falls under a reserved path prefix\n * (`reservedPathPrefixes`, e.g. `/admin` or `/api`). Allowing it would make the\n * document reachable under a route the framework owns, so the write is aborted\n * before commit — for the WRITE's OWN locale only (F010's one-locale-per-write\n * scope; the boot-time lint only WARNs, and only on statically-analysable\n * patterns). A reserved-prefix hit in a DIFFERENT locale than the one being\n * written (e.g. a base-row reparent that only collides for a non-default\n * locale) isn't caught here — `pathIndexWriter`'s post-commit pass screens\n * every other locale too and refuses to persist a reserved path, but by then\n * the entity write has already committed (F013).\n */\nexport class PathReservedPrefixError extends Error {\n  readonly entityName: string\n  readonly path: string\n  readonly prefix: string\n\n  constructor(entityName: string, path: string, prefix: string) {\n    super(\n      `Path \"${path}\" falls under the reserved prefix \"${prefix}\" and cannot be used as a ` +\n        `public URL for a ${entityName} document.`,\n    )\n    this.name = 'PathReservedPrefixError'\n    this.entityName = entityName\n    this.path = path\n    this.prefix = prefix\n  }\n}\n","/**\n * Shared path-generation + conflict logic (plan/routing PR03, Part 3).\n *\n * `computeCanonicalPath` resolves a routable row to its locale-relative\n * canonical URL — reusing `buildEntityHref` (the PR02-shipped token engine) and\n * expanding the `[parent.path]` token against the parent's own indexed path\n * (F004's PR03 payoff). Used by BOTH seams:\n *   - `pathIndexWriter` (post-commit) — compute + upsert.\n *   - `pathConflictGuard` (pre-commit, via `ensurePathAvailable`) — compute +\n *     check + maybe-mutate-and-rethrow.\n *\n * so the pattern-resolution + parent-expansion logic exists exactly once.\n *\n * NOTE on the signature vs. the task brief: the brief typed\n * `computeCanonicalPath` as synchronous (`: string | null`), but the\n * `[parent.path]` expansion requires a `toolkit_paths` lookup, which is async —\n * so both functions are `Promise`-returning and take the `ToolkitPathsClient`.\n * (Same shape of necessary deviation as Task 1's `defineTable` `where`\n * predicate, which the brief typed as `SQL` but had to widen to a callback.)\n */\n\nimport {\n  buildEntityHref,\n  type Entity,\n  matchReservedPrefix,\n  resolvePattern,\n} from '@murumets-ee/entity'\nimport type { PathSkipReason } from './apply-path.js'\nimport { PathConflictError, PathReservedPrefixError } from './errors.js'\nimport type { ToolkitPathsClient } from './schema.js'\n\n/** Hard cap on auto-suffix attempts — a pathological run of taken slugs throws\n *  rather than looping forever (matches the repo's no-unbounded-work posture,\n *  even though this is a single-document loop, not a fan-out). */\nconst MAX_SUFFIX_ATTEMPTS = 50\n\n/** {@link computeCanonicalPath}'s result — a computed path, or `null` plus WHY (F075). */\nexport type ComputeCanonicalPathResult =\n  | { path: string; skipReason?: undefined }\n  | { path: null; skipReason: PathSkipReason }\n\n/**\n * Compute a row's locale-relative canonical path for `locale`, or `{ path:\n * null, skipReason }` when it can't be built — the same typed-BROKEN-link\n * contract as {@link buildEntityHref}, plus a reason a caller can log or\n * ignore (F075; see {@link PathSkipReason} for what each reason means and\n * which ones are worth surfacing).\n *\n * `[parent.path]` expansion: when `row.parent` is a set self-reference\n * (`pathParent()`), the parent's OWN canonical `toolkit_paths` path for the\n * SAME `(entityType, locale, isCanonical)` is substituted directly into the\n * PATTERN STRING (not via `buildEntityHref`'s row-based token substitution —\n * see below for why). If the parent isn't indexed yet in this locale, the\n * whole path is unresolved (`skipReason: 'parent-not-indexed'` — usually a\n * transient/ordering condition, not a permanent error). A ROOT document\n * (`row.parent` null/absent) substitutes `''` — per Phase 01 §3's settled\n * design, \"root documents expand `[parent.path]` to nothing\", so a root under\n * `/[parent.path]/[slug]` still resolves (to `/[slug]` after\n * {@link normalizePath} collapses the doubled separator).\n *\n * This can't go through `buildEntityHref`'s normal `row[token]` substitution:\n * that function treats ANY empty-string token value as a broken link\n * (`missing = true`) — correct for ordinary content tokens (an empty slug\n * really is broken), wrong for `parent.path`'s root case (empty there is\n * intentional, not missing). So `[parent.path]` is resolved against the raw\n * PATTERN STRING first (via `resolvePattern`, the same per-locale/map\n * resolution `buildEntityHref` uses internally), and the already-substituted\n * string is then handed to `buildEntityHref` for the REMAINING tokens (e.g.\n * `[slug]`), which keep the normal missing-is-broken rule.\n */\nexport async function computeCanonicalPath(args: {\n  entity: Entity\n  /** Locale-merged row for the target locale. */\n  row: Record<string, unknown>\n  locale: string\n  defaultLocale: string\n  pathsClient: ToolkitPathsClient\n}): Promise<ComputeCanonicalPathResult> {\n  const declaredPath = args.entity.frontend?.path\n  if (declaredPath === undefined) return { path: null, skipReason: 'not-routable' }\n\n  const pattern = resolvePattern(declaredPath, args.locale, args.defaultLocale)\n  if (pattern === null) return { path: null, skipReason: 'no-pattern-for-locale' }\n\n  let effectivePattern = pattern\n  if (typeof pattern === 'string' && pattern.includes('[parent.path]')) {\n    const parentId = args.row.parent\n    if (typeof parentId === 'string' && parentId.length > 0) {\n      // Same-entity self-reference, so the parent lives in this entity's own\n      // path rows — no cross-entity-type registry needed.\n      const parentRow = await args.pathsClient.findOne({\n        entityType: args.entity.name,\n        entityId: parentId,\n        locale: args.locale,\n        isCanonical: true,\n      })\n      // parent not indexed in this locale yet — broken, not root\n      if (!parentRow) return { path: null, skipReason: 'parent-not-indexed' }\n      effectivePattern = pattern.replaceAll('[parent.path]', parentRow.path)\n    } else {\n      // Root document — expands to nothing (Phase 01 §3), not \"missing\".\n      effectivePattern = pattern.replaceAll('[parent.path]', '')\n    }\n  }\n\n  const href = buildEntityHref(effectivePattern, args.row, args.locale, args.defaultLocale)\n  return href === null\n    ? { path: null, skipReason: 'unresolved-token' }\n    : { path: normalizePath(href) }\n}\n\n/**\n * Canonicalize a path for storage/comparison: collapse duplicate slashes and\n * strip a trailing slash (except the bare root `/`). This makes the\n * `[parent.path]` composition robust — `/[parent.path]/[slug]` with a\n * `parent.path` of `/handbook` yields `//handbook/intro`, which normalizes to\n * `/handbook/intro` — and guarantees the guard and writer compute byte-identical\n * paths for the same row (so a re-save is correctly seen as \"no change\").\n */\nexport function normalizePath(path: string): string {\n  const collapsed = path.replace(/\\/{2,}/g, '/')\n  return collapsed.length > 1 && collapsed.endsWith('/') ? collapsed.slice(0, -1) : collapsed\n}\n\n/**\n * Pre-commit conflict check + auto-suffix for a SINGLE locale's write. Called by\n * `pathConflictGuard`. Computes the candidate path from `data` merged onto\n * `currentRow`, rejects reserved-prefix hits and manual-slug conflicts, and —\n * for auto slugs — mutates `data.slug` in place with an incrementing suffix\n * (`hello` → `hello-2` → `hello-3`) until the path is free (bounded).\n *\n * `data.slug` mutations are persisted by the SAME entity write (the guard fires\n * before the INSERT/UPDATE and `data` is the in-flight payload), so no\n * follow-up write is needed.\n */\nexport async function ensurePathAvailable(args: {\n  entity: Entity\n  /** Mutable in-flight write payload — may get `data.slug` rewritten. */\n  data: Record<string, unknown>\n  /** Pre-write locale-merged row for `update`/`updateForLocale`; `null` on create. */\n  currentRow: Record<string, unknown> | null\n  /** The row id, or `undefined` on create (nothing to self-exclude). */\n  id: string | undefined\n  locale: string\n  defaultLocale: string\n  slugMode: 'auto' | 'manual'\n  reservedPathPrefixes: readonly string[]\n  pathsClient: ToolkitPathsClient\n}): Promise<void> {\n  const {\n    entity,\n    data,\n    currentRow,\n    id,\n    locale,\n    defaultLocale,\n    slugMode,\n    reservedPathPrefixes,\n    pathsClient,\n  } = args\n\n  let lastPath = ''\n  for (let attempt = 0; attempt < MAX_SUFFIX_ATTEMPTS; attempt++) {\n    // Working row = current row overlaid with the in-flight write (create:\n    // `data` IS the full row, `currentRow` is null).\n    const row = { ...(currentRow ?? {}), ...data }\n    const computed = await computeCanonicalPath({ entity, row, locale, defaultLocale, pathsClient })\n    // Typed broken link — nothing to conflict-check for this locale. Pre-commit\n    // silence is correct here (unlike the post-commit writer, F075): the write\n    // hasn't happened yet, so there is nothing yet to be missing a path.\n    if (computed.path === null) return\n    const path = computed.path\n    lastPath = path\n\n    // Reserved-prefix boundary — the real enforcement point (Part 2 write-time).\n    const reserved = matchReservedPrefix(path, reservedPathPrefixes)\n    if (reserved !== undefined) {\n      throw new PathReservedPrefixError(entity.name, path, reserved)\n    }\n\n    // The partial-unique index guarantees at most ONE canonical row per\n    // (locale, path). A hit that ISN'T this document's own row is a conflict\n    // (self-match excluded — a routine re-save keeping its own path is fine;\n    // on create `id` is undefined so nothing is excluded).\n    const existing = await pathsClient.findOne({ locale, path, isCanonical: true })\n    const isSelf =\n      existing != null && existing.entityType === entity.name && existing.entityId === id\n    if (existing == null || isSelf) return\n\n    // Real conflict with another document.\n    if (slugMode === 'manual') {\n      throw new PathConflictError(entity.name, locale, path, existing.entityId)\n    }\n    const currentSlug = row.slug\n    if (typeof currentSlug !== 'string' || currentSlug.length === 0) {\n      // Auto mode but nothing to suffix — can't resolve automatically.\n      throw new PathConflictError(entity.name, locale, path, existing.entityId)\n    }\n    // Persisted by the same write (the guard runs before the SQL is built).\n    data.slug = incrementSlugSuffix(currentSlug)\n  }\n\n  // Exhausted the suffix ladder — pathological (50 taken slugs in a row).\n  throw new PathConflictError(\n    entity.name,\n    locale,\n    lastPath,\n    undefined,\n    `Could not find a free path for a ${entity.name} document near \"${lastPath}\" (locale \"${locale}\") ` +\n      `after ${MAX_SUFFIX_ATTEMPTS} attempts — choose a different slug manually.`,\n  )\n}\n\n/**\n * Increment a numeric slug suffix, WordPress/pathauto-style:\n * `hello` → `hello-2`, `hello-2` → `hello-3`, `hello-9` → `hello-10`.\n * A slug with no trailing `-<n>` gets `-2` appended.\n */\nexport function incrementSlugSuffix(slug: string): string {\n  const match = /^(.*)-(\\d+)$/.exec(slug)\n  if (match) {\n    const base = match[1] ?? slug\n    const n = Number.parseInt(match[2] ?? '1', 10)\n    return `${base}-${n + 1}`\n  }\n  return `${slug}-2`\n}\n","/**\n * Internal redirect-resolution helper (plan/routing PR04, Part 4).\n *\n * Given a `(locale, path)` that may be a HISTORICAL (demoted) URL, resolve the\n * CURRENT canonical path of the document that once lived there — the \"301 to\n * wherever this document now lives\" lookup that backs automatic redirect\n * history (D005 / the change-matrix in `04-path-lifecycle-and-redirects.md`).\n *\n * **Chain-free by construction.** Every historical row is keyed to the OWNING\n * DOCUMENT (`entity_type`, `entity_id`), never to \"the next URL in the rename\n * sequence\". So a document renamed A → B → C leaves historical rows at A and B\n * both pointing at the same document, and this helper resolves EITHER of them\n * straight to C in one hop — it never walks A → B → C. (WP `_wp_old_slug` /\n * Drupal redirect both use this keyed-to-target model — R01.)\n *\n * NOT the public resolution API. Phase 05 / PR06 owns `resolvePath` and the\n * canonical → manual → historical → 404 precedence contract (§2, §4 of Phase\n * 04); this phase ships only the underlying historical-row → current-canonical\n * mechanism. PR06 imports and wraps this. (Scope split filed as a Finding in\n * `plan/routing/progress.md`, mirroring F004's PR02/03 precedent.)\n */\n\nimport type { Logger } from '@murumets-ee/core'\nimport type { PathIndexReader } from './index-reader.js'\n\n/**\n * How many `(locale, path)` candidates a single redirect lookup will consider\n * before giving up and answering 404.\n *\n * Several documents can hold a historical row at one URL, and one whose owner\n * has no current canonical (trashed, or that locale unpublished) must not\n * shadow one that does — so the lookup walks candidates rather than trusting\n * the newest. This is the ceiling on that walk: it runs on the miss path of\n * every unmatched URL, which is where crawlers and scanners spend their time,\n * and CLAUDE.md's no-unbounded-fan-out rule applies to a per-request loop as\n * much as to a server one.\n */\nconst MAX_REDIRECT_CANDIDATES = 10\n\n/** The current canonical location a historical/canonical `(locale, path)` resolves to. */\nexport interface RedirectTarget {\n  entityType: string\n  entityId: string\n  /** The owning document's CURRENT canonical path for this locale. */\n  currentPath: string\n}\n\n/**\n * Resolve `(locale, path)` — canonical OR historical — to the current canonical\n * path of its owning document, or `null` when nothing routes there.\n *\n * Returns `null` when:\n *  - No `toolkit_paths` row (of any `is_canonical`) matches `(locale, path)`.\n *  - The owning document has no current canonical row for `locale` anymore\n *    (its locale variant was unpublished/deleted since) — the caller treats\n *    this as a 404, matching the Unpublish/Delete rows of the §2 change matrix.\n *\n * Known edge case (documented, NOT over-engineered per the brief): two DIFFERENT\n * documents can both hold a HISTORICAL row at the same `(locale, path)` if one\n * occupied that URL, moved away, and a LATER document independently claimed then\n * also moved away from it — the partial-unique only forbids two *canonical* rows\n * sharing a URL, never two historical ones. When multiple rows match we prefer\n * the most-recently-updated, but only among those that still RESOLVE: self-\n * healing / approximate, consistent with this feature's already-accepted\n * tolerance for narrow non-security drift (F014's precedent — accept the race\n * rather than add locking machinery).\n *\n * Preferring the newest *resolvable* candidate rather than simply the newest is\n * load-bearing since trashing a document releases its canonical claim while\n * keeping its history: without it, a trashed document's leftover history row\n * would out-rank and silently kill a LIVE document's redirect at the same URL —\n * the same \"a row belonging to an invisible document shadows a live one\" defect\n * that the trash-side release exists to remove, displaced one tier down.\n */\nexport async function findRedirectTarget(args: {\n  // Narrow structural reader (the real `ToolkitPathsClient` satisfies it — see\n  // `./index-reader.ts`). Widened from `ToolkitPathsClient` in PR06 so the\n  // resolution core can inject a cast-free unit-test stub; the integration\n  // tests still pass the real client, proving the assignment.\n  pathsClient: PathIndexReader\n  locale: string\n  path: string\n  /**\n   * Optional, and used for ONE thing: saying so when the candidate cap was\n   * reached and nothing resolved. Without it that 404 is indistinguishable\n   * from a genuine miss and the pathological URL stays invisible — which is\n   * the silent-truncation failure CLAUDE.md's fan-out rule names directly.\n   */\n  logger?: Logger\n}): Promise<RedirectTarget | null> {\n  const { pathsClient, locale, path, logger } = args\n\n  // Any row (canonical or historical) at this URL, most-recent first. Several\n  // documents can hold a historical row at the same URL — each one lived here\n  // and moved on — and the most recent is the best answer among those that can\n  // still BE answered.\n  //\n  // Bounded, and taking only the first row would be the bug: a document whose\n  // canonical is gone (trashed, so its claim was released; or its locale\n  // variant unpublished) still owns its history rows, and if one of those wins\n  // the pick, an unanswerable candidate would shadow a live document's\n  // redirect at the same URL and turn a working 301 into a 404. So walk the\n  // candidates in recency order and take the first whose owner can actually be\n  // redirected to.\n  //\n  // `MAX_REDIRECT_CANDIDATES` is a hard ceiling per CLAUDE.md's no-unbounded-\n  // fan-out rule — this runs on the miss path of every unmatched URL, which is\n  // exactly where a crawler or a scanner spends its time. Beyond it we answer\n  // 404 rather than keep looking; a URL contended by that many documents is\n  // already pathological, and the alternative is letting one request issue\n  // unbounded lookups.\n  const matches = await pathsClient.findMany({\n    where: { locale, path },\n    orderBy: [{ column: 'updatedAt', dir: 'desc' }],\n    limit: MAX_REDIRECT_CANDIDATES,\n  })\n\n  for (const match of matches) {\n    // Resolve the owning document's CURRENT canonical row for this locale.\n    // This is the single hop that makes redirects chain-free: we jump from\n    // \"some URL this document used to (or does) live at\" straight to \"where it\n    // lives now\".\n    const canonical = await pathsClient.findOne({\n      entityType: match.entityType,\n      entityId: match.entityId,\n      locale,\n      isCanonical: true,\n    })\n    // This owner has no live canonical path in this locale anymore. Skip it and\n    // try the next candidate rather than answering 404 on its behalf — the §2\n    // change matrix's 404 is for when NO candidate resolves, not when the\n    // newest one happens not to.\n    if (canonical) {\n      return {\n        entityType: match.entityType,\n        entityId: match.entityId,\n        currentPath: canonical.path,\n      }\n    }\n  }\n\n  // Nothing resolved. If we also filled the candidate window, the answer may be\n  // a TRUNCATION rather than a miss — say so, because the two are identical\n  // from outside and only one of them is a URL somebody should look at.\n  if (matches.length === MAX_REDIRECT_CANDIDATES) {\n    logger?.warn?.(\n      { locale, path, examined: matches.length },\n      'toolkit_paths: redirect lookup examined the full candidate window without ' +\n        'resolving one — answering 404, but a further candidate may exist',\n    )\n  }\n\n  return null\n}\n","/**\n * The public path-resolution API (plan/routing PR06; phase\n * `05-resolution-and-enumeration-api.md` §2, phase `04` §2-4).\n *\n * `resolvePath` maps an incoming `(path, locale)` to a document, a redirect, or\n * a 404, applying the settled precedence:\n *\n *   `/` homepage → canonical → manual redirect → historical redirect → none\n *\n * **Security (CLAUDE.md #1 priority).** These functions gate whether content is\n * reachable by URL. `resolvePath` publish-checks at every tier that resolves to\n * a document (homepage / canonical / historical) via the injected\n * {@link PublishChecker} — an UNPUBLISHED document in the requested locale is\n * NOT routable (`{ kind: 'none' }`). A canonical row \"claims\" its path even in\n * draft, so an unpublished canonical returns `none` WITHOUT falling through to\n * manual/historical (nothing else may resolve there). `resolveDraftPath` is the\n * ONLY function that skips publish checks — it is admin/preview-only. Its one\n * sanctioned HTTP caller is `./routes.ts` (`GET /api/admin/paths/resolve`,\n * added for #775: permission-gated `path:resolve` PLUS a per-document `view`\n * re-check). It must NEVER be wired to a `content-api` endpoint — that surface\n * is public and published-only.\n *\n * **Leaf module.** All cross-package state (path/redirect readers, the publish\n * checker, the homepage reader) is injected via `deps` — this module imports no\n * `@murumets-ee/core` and no `server-only` graph. The concrete `deps` are built\n * from an app in `./resolve-context.ts`.\n */\n\nimport type { Logger } from '@murumets-ee/core'\nimport type { Entity } from '@murumets-ee/entity'\nimport type { RedirectTarget } from '../redirects/target.js'\nimport { normalizePath } from './generate-path.js'\nimport type { PathIndexReader } from './index-reader.js'\nimport type { HomepagePointer } from './homepage.js'\nimport { findRedirectTarget } from './redirect-target.js'\n\n// ---------------------------------------------------------------------------\n// Result type (phase 05 §2 — exact shape)\n// ---------------------------------------------------------------------------\n\n/** The document that serves the requested path. */\nexport interface ResolveDocumentResult {\n  kind: 'document'\n  entityType: string\n  id: string\n}\n/** A redirect to another URL/path. `301` permanent, `302` temporary. */\nexport interface ResolveRedirectResult {\n  kind: 'redirect'\n  to: string\n  status: 301 | 302\n}\n/** Nothing routes here (404). */\nexport interface ResolveNoneResult {\n  kind: 'none'\n}\nexport type ResolveResult = ResolveDocumentResult | ResolveRedirectResult | ResolveNoneResult\n\n// ---------------------------------------------------------------------------\n// Dependency-injection surface\n// ---------------------------------------------------------------------------\n\n/**\n * Is `(entityType, entityId)` published in `locale`? Backed by\n * `QueryClient.findById`, which applies the publish filter for any principal\n * WITHOUT `view_unpublished` (D017) — so the answer is only \"published\" if the\n * injected client's context withholds that action, which the real one\n * (`resolve-context.ts`'s reach context) does. See {@link createPublishChecker}.\n * `resolveDraftPath` bypasses this entirely.\n */\nexport interface PublishChecker {\n  isPublished(entityType: string, entityId: string, locale: string): Promise<boolean>\n}\n\n/** Resolve an entity TYPE NAME to its `Entity`, or `undefined` when unregistered. */\nexport type EntityResolver = (entityType: string) => Entity | undefined\n\n/** The `QueryClient.findById` surface the publish checker needs (publish filter is internal). */\nexport interface PublishQueryClient {\n  findById(id: string, options?: { locale?: string | undefined }): Promise<unknown>\n}\n\n/** Build a publish-filtering read client for an entity (real: `new QueryClient(...)`). */\nexport type QueryClientFactory = (entity: Entity) => PublishQueryClient\n\n/** Read the current homepage pointer, or `null` when unset/malformed. */\nexport type HomepageReader = () => Promise<HomepagePointer | null>\n\n/** The manual-redirect lookup surface (locale-specific + catch-all rows). */\nexport interface RedirectLookupReader {\n  findOne(where: {\n    fromPath: string\n    /** A concrete locale, or `null` for the catch-all (all-locales) row. */\n    locale: string | null\n  }): Promise<{ target: RedirectTarget; status: number } | null>\n}\n\n/** Deps for {@link getCanonicalPath} — the minimal index read. */\nexport interface CanonicalPathDeps {\n  pathsClient: PathIndexReader\n}\n\n/** Deps for {@link resolvePath} / {@link resolveDraftPath}. */\nexport interface ResolvePathDeps extends CanonicalPathDeps {\n  redirectsClient: RedirectLookupReader\n  publishChecker: PublishChecker\n  homepageReader: HomepageReader\n  /**\n   * Optional so the unit-test deps builders stay unchanged. Its only use is\n   * letting the historical-redirect lookup report a truncated candidate window\n   * — see {@link findRedirectTarget}.\n   */\n  logger?: Logger\n}\n\n/** Deps for {@link getAlternates}. */\nexport interface AlternatesDeps extends CanonicalPathDeps {\n  publishChecker: PublishChecker\n  /** The locales to enumerate (configured content locales). */\n  locales: readonly string[]\n}\n\n/**\n * Hop cap on manual-redirect `path`-chain following at REQUEST time (F021 /\n * F027 point 4). `collapsePathTarget` only collapses ONE hop at save time, so a\n * chain created out-of-order can still need re-hopping here; exceeding the cap\n * resolves to `none` rather than looping or 500ing.\n */\nexport const MAX_REDIRECT_HOPS = 5\n\n// ---------------------------------------------------------------------------\n// getCanonicalPath — forward index read, NO publish filter (D-note below)\n// ---------------------------------------------------------------------------\n\n/**\n * The current canonical path for `(entityType, entityId, locale)`, or `null`\n * when the document has no canonical row in that locale.\n *\n * **No publish filter — deliberate.** This matches the CURRENT behavior of\n * `resolveEntityHref` / search's URL builder (both call `AdminClient.findById`,\n * which does zero publish filtering); Task 2 re-points those consumers onto this\n * function, so changing the filtering here would be an unplanned behavior change.\n * Callers that need a publish gate compose one explicitly (resolution's canonical\n * tier does).\n */\nexport async function getCanonicalPath(\n  entityType: string,\n  entityId: string,\n  locale: string,\n  deps: CanonicalPathDeps,\n): Promise<string | null> {\n  const row = await deps.pathsClient.findOne({ entityType, entityId, locale, isCanonical: true })\n  return row?.path ?? null\n}\n\n// ---------------------------------------------------------------------------\n// Publish checker\n// ---------------------------------------------------------------------------\n\n/**\n * Build a {@link PublishChecker} from an entity resolver + a query-client\n * factory. `isPublished` is `false` for an unknown entity type, else\n * `findById(id, { locale }) !== null` — a non-null result means \"published in\n * that locale\" because `QueryClient` applies the publish filter (and excludes\n * trashed rows) for every principal without `view_unpublished` (D017). The\n * factory therefore has to hand back a client whose context withholds that\n * action; `resolve-context.ts`'s reach context is the one in-repo\n * implementation and does. F027 point 1.\n */\nexport function createPublishChecker(deps: {\n  entityResolver: EntityResolver\n  queryClientFactory: QueryClientFactory\n}): PublishChecker {\n  return {\n    async isPublished(entityType, entityId, locale) {\n      const entity = deps.entityResolver(entityType)\n      if (entity === undefined) return false\n      const client = deps.queryClientFactory(entity)\n      const row = await client.findById(entityId, { locale })\n      return row !== null && row !== undefined\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n// resolvePath / resolveDraftPath\n// ---------------------------------------------------------------------------\n\n/** The publish predicate threaded through the tiers (real, or always-true for draft). */\ntype PublishPredicate = (entityType: string, entityId: string, locale: string) => Promise<boolean>\n\n/**\n * Resolve `(path, locale)` to a document / redirect / none, publish-checking at\n * every document-resolving tier. Public request surface (phase 05 §2).\n */\nexport function resolvePath(\n  path: string,\n  locale: string,\n  deps: ResolvePathDeps,\n): Promise<ResolveResult> {\n  return resolveInternal(path, locale, deps, (entityType, entityId, loc) =>\n    deps.publishChecker.isPublished(entityType, entityId, loc),\n  )\n}\n\n/**\n * Admin/preview resolution — identical tier structure to {@link resolvePath} but\n * SKIPS every publish check (draft and published documents both resolve). Per\n * phase 05 §2 this surface is admin-only. Exactly ONE HTTP route may call it —\n * `./routes.ts`'s `GET /api/admin/paths/resolve` (#775), which gates on\n * `path:resolve` and re-checks the caller's `view` grant on whatever it\n * resolves. NEVER wire it to `content-api` (public, published-only).\n */\nexport function resolveDraftPath(\n  path: string,\n  locale: string,\n  deps: ResolvePathDeps,\n): Promise<ResolveResult> {\n  // The ONLY difference from resolvePath: the publish predicate is always true.\n  return resolveInternal(path, locale, deps, async () => true)\n}\n\n/**\n * Shared tier engine for `resolvePath` / `resolveDraftPath`. The two differ ONLY\n * in `checkPublished` (real checker vs. always-true), so the precedence + every\n * branch stay byte-identical between the public and admin surfaces.\n */\nasync function resolveInternal(\n  rawPath: string,\n  locale: string,\n  deps: ResolvePathDeps,\n  checkPublished: PublishPredicate,\n): Promise<ResolveResult> {\n  const path = normalizePath(rawPath)\n  const homepage = await deps.homepageReader()\n\n  // ── Tier 1: `/` homepage special case ────────────────────────────────────\n  if (path === '/') {\n    if (homepage === null) return { kind: 'none' }\n    if (!(await checkPublished(homepage.entity, homepage.id, locale))) return { kind: 'none' }\n    return { kind: 'document', entityType: homepage.entity, id: homepage.id }\n  }\n\n  // ── Tier 2: canonical ─────────────────────────────────────────────────────\n  const canonical = await deps.pathsClient.findOne({ locale, path, isCanonical: true })\n  if (canonical) {\n    // The path is CLAIMED by this document even in draft — an unpublished\n    // canonical returns `none` and does NOT fall through to manual/historical.\n    if (!(await checkPublished(canonical.entityType, canonical.entityId, locale))) {\n      return { kind: 'none' }\n    }\n    // D004 dedup: the homepage document's own pattern URL always 301s to `/`.\n    if (isHomepage(homepage, canonical.entityType, canonical.entityId)) {\n      return { kind: 'redirect', to: '/', status: 301 }\n    }\n    return { kind: 'document', entityType: canonical.entityType, id: canonical.entityId }\n  }\n\n  // ── Tier 3: manual redirects ──────────────────────────────────────────────\n  const manual = await resolveManualRedirect(path, locale, deps, homepage)\n  if (manual !== null) return manual\n\n  // ── Tier 4: historical (automatic rename) redirects ───────────────────────\n  const historical = await findRedirectTarget({\n    pathsClient: deps.pathsClient,\n    locale,\n    path,\n    ...(deps.logger !== undefined && { logger: deps.logger }),\n  })\n  if (historical === null) return { kind: 'none' }\n  if (!(await checkPublished(historical.entityType, historical.entityId, locale))) {\n    return { kind: 'none' }\n  }\n  if (isHomepage(homepage, historical.entityType, historical.entityId)) {\n    return { kind: 'redirect', to: '/', status: 301 }\n  }\n  return { kind: 'redirect', to: historical.currentPath, status: 301 }\n}\n\n/**\n * Tier 3 — resolve a manual `toolkit_redirects` row at `fromPath`. Returns:\n *  - `null` when NO manual redirect exists at `fromPath` (caller falls to tier 4).\n *  - a {@link ResolveResult} otherwise (including `{ kind: 'none' }` for a target\n *    that resolves to nothing).\n *\n * `entity`-kind targets resolve via `getCanonicalPath` with NO publish check\n * (F027 point 3 — an unpublished target 404s on the FOLLOWING request via tier\n * 2's own check). `path`-kind targets are re-resolved at request time, bounded\n * by {@link MAX_REDIRECT_HOPS}, so an out-of-order chain (F021) can't loop.\n */\nasync function resolveManualRedirect(\n  fromPath: string,\n  locale: string,\n  deps: ResolvePathDeps,\n  homepage: HomepagePointer | null,\n): Promise<ResolveResult | null> {\n  let row = await lookupManualRedirect(deps.redirectsClient, fromPath, locale)\n  if (row === null) return null // no manual redirect here → fall through to tier 4\n\n  for (let hop = 0; hop < MAX_REDIRECT_HOPS; hop++) {\n    const target = row.target\n    const status = toRedirectStatus(row.status)\n\n    if (target.kind === 'url') {\n      return { kind: 'redirect', to: target.url, status } // terminal, external\n    }\n\n    if (target.kind === 'entity') {\n      // Homepage-collision (D004), same as tiers 2/4 + the path-walk-hits-canonical\n      // case: if the redirect points AT the homepage document, go straight to `/`\n      // rather than its pattern URL (which would then 301 to `/` anyway — a pointless\n      // double hop). Keep the manual redirect's own status.\n      if (isHomepage(homepage, target.entity, target.id)) {\n        return { kind: 'redirect', to: '/', status }\n      }\n      const to = await getCanonicalPath(target.entity, target.id, locale, deps)\n      if (to === null) return { kind: 'none' } // target has no canonical row in this locale\n      return { kind: 'redirect', to, status }\n    }\n\n    // target.kind === 'path' — re-resolve at request time (bounded).\n    const nextPath = normalizePath(target.path)\n    const nextRow = await lookupManualRedirect(deps.redirectsClient, nextPath, locale)\n    if (nextRow !== null) {\n      row = nextRow // hop to the next redirect and keep walking\n      continue\n    }\n    // No further redirect at `nextPath` — does it serve canonical content?\n    const canonical = await deps.pathsClient.findOne({\n      locale,\n      path: nextPath,\n      isCanonical: true,\n    })\n    if (canonical) {\n      if (isHomepage(homepage, canonical.entityType, canonical.entityId)) {\n        return { kind: 'redirect', to: '/', status: 301 }\n      }\n      return { kind: 'redirect', to: nextPath, status }\n    }\n    return { kind: 'none' } // path target points at neither a redirect nor content\n  }\n\n  return { kind: 'none' } // exceeded MAX_REDIRECT_HOPS — never loop, never 500\n}\n\n/**\n * Look up a manual redirect at `fromPath`: a locale-specific row wins, else the\n * catch-all (`locale = null`) row. Mirrors `collapsePathTarget`'s precedence.\n */\nasync function lookupManualRedirect(\n  client: RedirectLookupReader,\n  fromPath: string,\n  locale: string,\n): Promise<{ target: RedirectTarget; status: number } | null> {\n  const exact = await client.findOne({ fromPath, locale })\n  if (exact) return exact\n  return client.findOne({ fromPath, locale: null })\n}\n\n// ---------------------------------------------------------------------------\n// getAlternates\n// ---------------------------------------------------------------------------\n\n/**\n * The published per-locale canonical URLs for a document — the `hreflang`\n * alternates set (phase 05 §2, \"published locales only\"). A locale is included\n * only when the document has a canonical row AND is published there. Bounded by\n * the (small, fixed) configured-locale count — no fan-out concern.\n */\nexport async function getAlternates(\n  entityType: string,\n  id: string,\n  deps: AlternatesDeps,\n): Promise<Array<{ locale: string; path: string }>> {\n  const alternates: Array<{ locale: string; path: string }> = []\n  for (const locale of deps.locales) {\n    const path = await getCanonicalPath(entityType, id, locale, deps)\n    if (path === null) continue\n    if (!(await deps.publishChecker.isPublished(entityType, id, locale))) continue\n    alternates.push({ locale, path })\n  }\n  return alternates\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\n/** Is `(entityType, entityId)` the configured homepage document? */\nfunction isHomepage(\n  homepage: HomepagePointer | null,\n  entityType: string,\n  entityId: string,\n): boolean {\n  return homepage !== null && homepage.entity === entityType && homepage.id === entityId\n}\n\n/**\n * Narrow the DB `status` integer (validated `301 | 302` at write time) to the\n * result union. Defaults to `301` for any unexpected value — never a raw number\n * leaking into the typed result.\n */\nfunction toRedirectStatus(status: number): 301 | 302 {\n  return status === 302 ? 302 : 301\n}\n","/**\n * `toolkit_redirects` — the manual-redirect table (plan/routing PR05, phase\n * `04-path-lifecycle-and-redirects.md` §3). One row per admin-authored redirect:\n * a `from_path` (locale-relative source URL) → a {@link RedirectTarget}\n * (entity / url / path). Distinct from the AUTOMATIC redirect history, which lives\n * as demoted (`is_canonical = false`) rows in `toolkit_paths` — this table is only\n * for the URLs automatic history can't express (campaign URLs, migrated-site\n * paths). Owned by `@murumets-ee/content`.\n *\n * Uses `defineTable` (per plan/routing C3, CLAUDE.md \"no raw SQL / typed APIs\n * only\") so reads/writes go through a typed `TableClient` — Task 2's CRUD routes\n * and the save-time validation (`./validation.ts`) never touch raw SQL.\n *\n * ## Uniqueness — TWO partial-unique indexes (F020 point 4)\n *\n * `locale` is nullable: `null` means \"applies to all locales\" (a catch-all\n * redirect). Postgres treats `NULL`s as DISTINCT in an ordinary unique constraint,\n * so a naive `UNIQUE (locale, from_path)` would silently allow duplicate catch-all\n * rows at the same path. Two partial-uniques express the real intent:\n *\n *  - `UNIQUE (locale, from_path) WHERE locale IS NOT NULL` — a locale-specific\n *    redirect is unique per (locale, from_path).\n *  - `UNIQUE (from_path) WHERE locale IS NULL` — at most ONE catch-all redirect per\n *    from_path.\n *\n * A locale-specific row and a catch-all row MAY legitimately coexist at the same\n * `from_path` (intentional per-locale override layering) — the two indexes don't\n * forbid that, only duplicates WITHIN each stratum. Both indexes are keyed on\n * `from_path`, so the \"does this from_path already exist as ANY redirect\"\n * collapse-lookup (`./validation.ts`) is already covered — no extra plain index\n * needed.\n *\n * Both use the callback `where` form (F007's `defineTable` partial-unique support)\n * with an INLINE `IS NULL` / `IS NOT NULL` literal — never `eq()`, which would bind\n * a `$1` param that is invalid in DDL (CLAUDE.md partial-unique gotcha; same form\n * `toolkit_paths` uses).\n */\n\nimport { column } from '@murumets-ee/db'\nimport { sql } from 'drizzle-orm'\nimport { defineSitePartitionedTable } from '../schema/site-partition.js'\nimport type { RedirectTarget } from './target.js'\n\n/**\n * Per site (plan `multisite` phase 03, D005): partitioned by `_site` — both\n * uniques below lead with it, so each site keeps its own redirects from the\n * same `from_path`. A client cannot be built without a site.\n */\nexport const toolkitRedirectsTable = defineSitePartitionedTable({\n  name: 'toolkit_redirects',\n  columns: {\n    id: column.uuid({ primaryKey: true, defaultRandom: true }),\n    /** BCP47 locale, or `null` = applies to all locales (catch-all). */\n    locale: column.varchar({ length: 10 }),\n    /** Locale-relative source URL: leading '/', no trailing '/' (same convention as `toolkit_paths.path`). */\n    fromPath: column.text({ notNull: true, pgName: 'from_path' }),\n    /** The redirect destination — see {@link RedirectTarget}. Stored as the discriminated-union object. */\n    target: column.jsonb<RedirectTarget, true>({ notNull: true }),\n    /** HTTP status. `301 | 302` is validated at the Zod boundary in Task 2's route layer. */\n    status: column.integer({ notNull: true, default: 301 }),\n    /**\n     * The admin who authored the redirect. VARCHAR, never UUID — better-auth user\n     * ids are random strings (CLAUDE.md). Nullable: system-created rows (future\n     * migration/import tooling) have no natural actor, matching how other\n     * audit-style columns in `defineTable` tables stay nullable.\n     */\n    createdBy: column.varchar({ length: 255, pgName: 'created_by' }),\n    createdAt: column.timestamp({\n      notNull: true,\n      defaultNow: true,\n      withTimezone: true,\n      pgName: 'created_at',\n    }),\n    updatedAt: column.timestamp({\n      notNull: true,\n      defaultNow: true,\n      withTimezone: true,\n      pgName: 'updated_at',\n    }),\n  },\n  unique: [\n    // A locale-specific redirect is unique per (locale, from_path). Excludes\n    // catch-all rows (locale IS NULL) from this stratum.\n    { on: ['locale', 'fromPath'], where: (c) => sql`${c.locale} IS NOT NULL` },\n    // At most ONE catch-all (all-locales) redirect per from_path. Postgres would\n    // otherwise treat every NULL locale as distinct and allow duplicates.\n    { on: ['fromPath'], where: (c) => sql`${c.locale} IS NULL` },\n  ],\n})\n\n/** Backwards-compatible raw pgTable export (for the plugin `tables:` slot + migrations). */\nexport const toolkitRedirects = toolkitRedirectsTable.table\n\n/** The full `DefinedTable` for `toolkit_redirects`. */\nexport type ToolkitRedirectsTable = typeof toolkitRedirectsTable\n\n/** The typed `TableClient` for `toolkit_redirects` (`toolkitRedirectsTable.makeClient(db)`). */\nexport type ToolkitRedirectsClient = ReturnType<typeof toolkitRedirectsTable.makeClient>\n"],"mappings":"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"}
+{"version":3,"file":"schema-LlK6EkOJ.mjs","names":[],"sources":["../src/paths/errors.ts","../src/paths/generate-path.ts","../src/paths/redirect-target.ts","../src/paths/resolve.ts","../src/redirects/schema.ts"],"sourcesContent":["/**\n * Domain errors thrown by the pre-commit `pathConflictGuard` (plan/routing PR03,\n * F010). Distinct classes so the admin-ui API handler can map them to a 4xx\n * (caller-actionable) rather than a generic 500, and so callers can branch on\n * `instanceof`.\n */\n\n/**\n * A document's candidate canonical URL is already claimed by a DIFFERENT\n * document in the same locale, and it can't be auto-resolved: either the slug\n * is manually pinned (`slug_mode = 'manual'`), or the auto-suffix ladder was\n * exhausted / there is no slug to suffix. The write is aborted before commit.\n */\nexport class PathConflictError extends Error {\n  readonly entityName: string\n  readonly locale: string\n  readonly path: string\n  /** The id of the document already holding `(locale, path)`, when known. */\n  readonly conflictingEntityId: string | undefined\n\n  constructor(\n    entityName: string,\n    locale: string,\n    path: string,\n    conflictingEntityId?: string,\n    message?: string,\n  ) {\n    super(\n      message ??\n        `Path \"${path}\" (locale \"${locale}\") is already used by another ${entityName} document. ` +\n          `Choose a different slug, or set this document's slug manually.`,\n    )\n    this.name = 'PathConflictError'\n    this.entityName = entityName\n    this.locale = locale\n    this.path = path\n    this.conflictingEntityId = conflictingEntityId\n  }\n}\n\n/**\n * A document's resolved canonical URL falls under a reserved path prefix\n * (`reservedPathPrefixes`, e.g. `/admin` or `/api`). Allowing it would make the\n * document reachable under a route the framework owns, so the write is aborted\n * before commit — for the WRITE's OWN locale only (F010's one-locale-per-write\n * scope; the boot-time lint only WARNs, and only on statically-analysable\n * patterns). A reserved-prefix hit in a DIFFERENT locale than the one being\n * written (e.g. a base-row reparent that only collides for a non-default\n * locale) isn't caught here — `pathIndexWriter`'s post-commit pass screens\n * every other locale too and refuses to persist a reserved path, but by then\n * the entity write has already committed (F013).\n */\nexport class PathReservedPrefixError extends Error {\n  readonly entityName: string\n  readonly path: string\n  readonly prefix: string\n\n  constructor(entityName: string, path: string, prefix: string) {\n    super(\n      `Path \"${path}\" falls under the reserved prefix \"${prefix}\" and cannot be used as a ` +\n        `public URL for a ${entityName} document.`,\n    )\n    this.name = 'PathReservedPrefixError'\n    this.entityName = entityName\n    this.path = path\n    this.prefix = prefix\n  }\n}\n","/**\n * Shared path-generation + conflict logic (plan/routing PR03, Part 3).\n *\n * `computeCanonicalPath` resolves a routable row to its locale-relative\n * canonical URL — reusing `buildEntityHref` (the PR02-shipped token engine) and\n * expanding the `[parent.path]` token against the parent's own indexed path\n * (F004's PR03 payoff). Used by BOTH seams:\n *   - `pathIndexWriter` (post-commit) — compute + upsert.\n *   - `pathConflictGuard` (pre-commit, via `ensurePathAvailable`) — compute +\n *     check + maybe-mutate-and-rethrow.\n *\n * so the pattern-resolution + parent-expansion logic exists exactly once.\n *\n * NOTE on the signature vs. the task brief: the brief typed\n * `computeCanonicalPath` as synchronous (`: string | null`), but the\n * `[parent.path]` expansion requires a `toolkit_paths` lookup, which is async —\n * so both functions are `Promise`-returning and take the `ToolkitPathsClient`.\n * (Same shape of necessary deviation as Task 1's `defineTable` `where`\n * predicate, which the brief typed as `SQL` but had to widen to a callback.)\n */\n\nimport {\n  buildEntityHref,\n  type Entity,\n  matchReservedPrefix,\n  resolvePattern,\n} from '@murumets-ee/entity'\nimport type { PathSkipReason } from './apply-path.js'\nimport { PathConflictError, PathReservedPrefixError } from './errors.js'\nimport type { ToolkitPathsClient } from './schema.js'\n\n/** Hard cap on auto-suffix attempts — a pathological run of taken slugs throws\n *  rather than looping forever (matches the repo's no-unbounded-work posture,\n *  even though this is a single-document loop, not a fan-out). */\nconst MAX_SUFFIX_ATTEMPTS = 50\n\n/** {@link computeCanonicalPath}'s result — a computed path, or `null` plus WHY (F075). */\nexport type ComputeCanonicalPathResult =\n  | { path: string; skipReason?: undefined }\n  | { path: null; skipReason: PathSkipReason }\n\n/**\n * Compute a row's locale-relative canonical path for `locale`, or `{ path:\n * null, skipReason }` when it can't be built — the same typed-BROKEN-link\n * contract as {@link buildEntityHref}, plus a reason a caller can log or\n * ignore (F075; see {@link PathSkipReason} for what each reason means and\n * which ones are worth surfacing).\n *\n * `[parent.path]` expansion: when `row.parent` is a set self-reference\n * (`pathParent()`), the parent's OWN canonical `toolkit_paths` path for the\n * SAME `(entityType, locale, isCanonical)` is substituted directly into the\n * PATTERN STRING (not via `buildEntityHref`'s row-based token substitution —\n * see below for why). If the parent isn't indexed yet in this locale, the\n * whole path is unresolved (`skipReason: 'parent-not-indexed'` — usually a\n * transient/ordering condition, not a permanent error). A ROOT document\n * (`row.parent` null/absent) substitutes `''` — per Phase 01 §3's settled\n * design, \"root documents expand `[parent.path]` to nothing\", so a root under\n * `/[parent.path]/[slug]` still resolves (to `/[slug]` after\n * {@link normalizePath} collapses the doubled separator).\n *\n * This can't go through `buildEntityHref`'s normal `row[token]` substitution:\n * that function treats ANY empty-string token value as a broken link\n * (`missing = true`) — correct for ordinary content tokens (an empty slug\n * really is broken), wrong for `parent.path`'s root case (empty there is\n * intentional, not missing). So `[parent.path]` is resolved against the raw\n * PATTERN STRING first (via `resolvePattern`, the same per-locale/map\n * resolution `buildEntityHref` uses internally), and the already-substituted\n * string is then handed to `buildEntityHref` for the REMAINING tokens (e.g.\n * `[slug]`), which keep the normal missing-is-broken rule.\n */\nexport async function computeCanonicalPath(args: {\n  entity: Entity\n  /** Locale-merged row for the target locale. */\n  row: Record<string, unknown>\n  locale: string\n  defaultLocale: string\n  pathsClient: ToolkitPathsClient\n}): Promise<ComputeCanonicalPathResult> {\n  const declaredPath = args.entity.frontend?.path\n  if (declaredPath === undefined) return { path: null, skipReason: 'not-routable' }\n\n  const pattern = resolvePattern(declaredPath, args.locale, args.defaultLocale)\n  if (pattern === null) return { path: null, skipReason: 'no-pattern-for-locale' }\n\n  let effectivePattern = pattern\n  if (typeof pattern === 'string' && pattern.includes('[parent.path]')) {\n    const parentId = args.row.parent\n    if (typeof parentId === 'string' && parentId.length > 0) {\n      // Same-entity self-reference, so the parent lives in this entity's own\n      // path rows — no cross-entity-type registry needed.\n      const parentRow = await args.pathsClient.findOne({\n        entityType: args.entity.name,\n        entityId: parentId,\n        locale: args.locale,\n        isCanonical: true,\n      })\n      // parent not indexed in this locale yet — broken, not root\n      if (!parentRow) return { path: null, skipReason: 'parent-not-indexed' }\n      effectivePattern = pattern.replaceAll('[parent.path]', parentRow.path)\n    } else {\n      // Root document — expands to nothing (Phase 01 §3), not \"missing\".\n      effectivePattern = pattern.replaceAll('[parent.path]', '')\n    }\n  }\n\n  const href = buildEntityHref(effectivePattern, args.row, args.locale, args.defaultLocale)\n  return href === null\n    ? { path: null, skipReason: 'unresolved-token' }\n    : { path: normalizePath(href) }\n}\n\n/**\n * Canonicalize a path for storage/comparison: collapse duplicate slashes and\n * strip a trailing slash (except the bare root `/`). This makes the\n * `[parent.path]` composition robust — `/[parent.path]/[slug]` with a\n * `parent.path` of `/handbook` yields `//handbook/intro`, which normalizes to\n * `/handbook/intro` — and guarantees the guard and writer compute byte-identical\n * paths for the same row (so a re-save is correctly seen as \"no change\").\n */\nexport function normalizePath(path: string): string {\n  const collapsed = path.replace(/\\/{2,}/g, '/')\n  return collapsed.length > 1 && collapsed.endsWith('/') ? collapsed.slice(0, -1) : collapsed\n}\n\n/**\n * Pre-commit conflict check + auto-suffix for a SINGLE locale's write. Called by\n * `pathConflictGuard`. Computes the candidate path from `data` merged onto\n * `currentRow`, rejects reserved-prefix hits and manual-slug conflicts, and —\n * for auto slugs — mutates `data.slug` in place with an incrementing suffix\n * (`hello` → `hello-2` → `hello-3`) until the path is free (bounded).\n *\n * `data.slug` mutations are persisted by the SAME entity write (the guard fires\n * before the INSERT/UPDATE and `data` is the in-flight payload), so no\n * follow-up write is needed.\n */\nexport async function ensurePathAvailable(args: {\n  entity: Entity\n  /** Mutable in-flight write payload — may get `data.slug` rewritten. */\n  data: Record<string, unknown>\n  /** Pre-write locale-merged row for `update`/`updateForLocale`; `null` on create. */\n  currentRow: Record<string, unknown> | null\n  /** The row id, or `undefined` on create (nothing to self-exclude). */\n  id: string | undefined\n  locale: string\n  defaultLocale: string\n  slugMode: 'auto' | 'manual'\n  reservedPathPrefixes: readonly string[]\n  pathsClient: ToolkitPathsClient\n}): Promise<void> {\n  const {\n    entity,\n    data,\n    currentRow,\n    id,\n    locale,\n    defaultLocale,\n    slugMode,\n    reservedPathPrefixes,\n    pathsClient,\n  } = args\n\n  let lastPath = ''\n  for (let attempt = 0; attempt < MAX_SUFFIX_ATTEMPTS; attempt++) {\n    // Working row = current row overlaid with the in-flight write (create:\n    // `data` IS the full row, `currentRow` is null).\n    const row = { ...(currentRow ?? {}), ...data }\n    const computed = await computeCanonicalPath({ entity, row, locale, defaultLocale, pathsClient })\n    // Typed broken link — nothing to conflict-check for this locale. Pre-commit\n    // silence is correct here (unlike the post-commit writer, F075): the write\n    // hasn't happened yet, so there is nothing yet to be missing a path.\n    if (computed.path === null) return\n    const path = computed.path\n    lastPath = path\n\n    // Reserved-prefix boundary — the real enforcement point (Part 2 write-time).\n    const reserved = matchReservedPrefix(path, reservedPathPrefixes)\n    if (reserved !== undefined) {\n      throw new PathReservedPrefixError(entity.name, path, reserved)\n    }\n\n    // The partial-unique index guarantees at most ONE canonical row per\n    // (locale, path). A hit that ISN'T this document's own row is a conflict\n    // (self-match excluded — a routine re-save keeping its own path is fine;\n    // on create `id` is undefined so nothing is excluded).\n    const existing = await pathsClient.findOne({ locale, path, isCanonical: true })\n    const isSelf =\n      existing != null && existing.entityType === entity.name && existing.entityId === id\n    if (existing == null || isSelf) return\n\n    // Real conflict with another document.\n    if (slugMode === 'manual') {\n      throw new PathConflictError(entity.name, locale, path, existing.entityId)\n    }\n    const currentSlug = row.slug\n    if (typeof currentSlug !== 'string' || currentSlug.length === 0) {\n      // Auto mode but nothing to suffix — can't resolve automatically.\n      throw new PathConflictError(entity.name, locale, path, existing.entityId)\n    }\n    // Persisted by the same write (the guard runs before the SQL is built).\n    data.slug = incrementSlugSuffix(currentSlug)\n  }\n\n  // Exhausted the suffix ladder — pathological (50 taken slugs in a row).\n  throw new PathConflictError(\n    entity.name,\n    locale,\n    lastPath,\n    undefined,\n    `Could not find a free path for a ${entity.name} document near \"${lastPath}\" (locale \"${locale}\") ` +\n      `after ${MAX_SUFFIX_ATTEMPTS} attempts — choose a different slug manually.`,\n  )\n}\n\n/**\n * Increment a numeric slug suffix, WordPress/pathauto-style:\n * `hello` → `hello-2`, `hello-2` → `hello-3`, `hello-9` → `hello-10`.\n * A slug with no trailing `-<n>` gets `-2` appended.\n */\nexport function incrementSlugSuffix(slug: string): string {\n  const match = /^(.*)-(\\d+)$/.exec(slug)\n  if (match) {\n    const base = match[1] ?? slug\n    const n = Number.parseInt(match[2] ?? '1', 10)\n    return `${base}-${n + 1}`\n  }\n  return `${slug}-2`\n}\n","/**\n * Internal redirect-resolution helper (plan/routing PR04, Part 4).\n *\n * Given a `(locale, path)` that may be a HISTORICAL (demoted) URL, resolve the\n * CURRENT canonical path of the document that once lived there — the \"301 to\n * wherever this document now lives\" lookup that backs automatic redirect\n * history (D005 / the change-matrix in `04-path-lifecycle-and-redirects.md`).\n *\n * **Chain-free by construction.** Every historical row is keyed to the OWNING\n * DOCUMENT (`entity_type`, `entity_id`), never to \"the next URL in the rename\n * sequence\". So a document renamed A → B → C leaves historical rows at A and B\n * both pointing at the same document, and this helper resolves EITHER of them\n * straight to C in one hop — it never walks A → B → C. (WP `_wp_old_slug` /\n * Drupal redirect both use this keyed-to-target model — R01.)\n *\n * NOT the public resolution API. Phase 05 / PR06 owns `resolvePath` and the\n * canonical → manual → historical → 404 precedence contract (§2, §4 of Phase\n * 04); this phase ships only the underlying historical-row → current-canonical\n * mechanism. PR06 imports and wraps this. (Scope split filed as a Finding in\n * `plan/routing/progress.md`, mirroring F004's PR02/03 precedent.)\n */\n\nimport type { Logger } from '@murumets-ee/core'\nimport type { PathIndexReader } from './index-reader.js'\n\n/**\n * How many `(locale, path)` candidates a single redirect lookup will consider\n * before giving up and answering 404.\n *\n * Several documents can hold a historical row at one URL, and one whose owner\n * has no current canonical (trashed, or that locale unpublished) must not\n * shadow one that does — so the lookup walks candidates rather than trusting\n * the newest. This is the ceiling on that walk: it runs on the miss path of\n * every unmatched URL, which is where crawlers and scanners spend their time,\n * and CLAUDE.md's no-unbounded-fan-out rule applies to a per-request loop as\n * much as to a server one.\n */\nconst MAX_REDIRECT_CANDIDATES = 10\n\n/** The current canonical location a historical/canonical `(locale, path)` resolves to. */\nexport interface RedirectTarget {\n  entityType: string\n  entityId: string\n  /** The owning document's CURRENT canonical path for this locale. */\n  currentPath: string\n}\n\n/**\n * Resolve `(locale, path)` — canonical OR historical — to the current canonical\n * path of its owning document, or `null` when nothing routes there.\n *\n * Returns `null` when:\n *  - No `toolkit_paths` row (of any `is_canonical`) matches `(locale, path)`.\n *  - The owning document has no current canonical row for `locale` anymore\n *    (its locale variant was unpublished/deleted since) — the caller treats\n *    this as a 404, matching the Unpublish/Delete rows of the §2 change matrix.\n *\n * Known edge case (documented, NOT over-engineered per the brief): two DIFFERENT\n * documents can both hold a HISTORICAL row at the same `(locale, path)` if one\n * occupied that URL, moved away, and a LATER document independently claimed then\n * also moved away from it — the partial-unique only forbids two *canonical* rows\n * sharing a URL, never two historical ones. When multiple rows match we prefer\n * the most-recently-updated, but only among those that still RESOLVE: self-\n * healing / approximate, consistent with this feature's already-accepted\n * tolerance for narrow non-security drift (F014's precedent — accept the race\n * rather than add locking machinery).\n *\n * Preferring the newest *resolvable* candidate rather than simply the newest is\n * load-bearing since trashing a document releases its canonical claim while\n * keeping its history: without it, a trashed document's leftover history row\n * would out-rank and silently kill a LIVE document's redirect at the same URL —\n * the same \"a row belonging to an invisible document shadows a live one\" defect\n * that the trash-side release exists to remove, displaced one tier down.\n */\nexport async function findRedirectTarget(args: {\n  // Narrow structural reader (the real `ToolkitPathsClient` satisfies it — see\n  // `./index-reader.ts`). Widened from `ToolkitPathsClient` in PR06 so the\n  // resolution core can inject a cast-free unit-test stub; the integration\n  // tests still pass the real client, proving the assignment.\n  pathsClient: PathIndexReader\n  locale: string\n  path: string\n  /**\n   * Optional, and used for ONE thing: saying so when the candidate cap was\n   * reached and nothing resolved. Without it that 404 is indistinguishable\n   * from a genuine miss and the pathological URL stays invisible — which is\n   * the silent-truncation failure CLAUDE.md's fan-out rule names directly.\n   */\n  logger?: Logger\n}): Promise<RedirectTarget | null> {\n  const { pathsClient, locale, path, logger } = args\n\n  // Any row (canonical or historical) at this URL, most-recent first. Several\n  // documents can hold a historical row at the same URL — each one lived here\n  // and moved on — and the most recent is the best answer among those that can\n  // still BE answered.\n  //\n  // Bounded, and taking only the first row would be the bug: a document whose\n  // canonical is gone (trashed, so its claim was released; or its locale\n  // variant unpublished) still owns its history rows, and if one of those wins\n  // the pick, an unanswerable candidate would shadow a live document's\n  // redirect at the same URL and turn a working 301 into a 404. So walk the\n  // candidates in recency order and take the first whose owner can actually be\n  // redirected to.\n  //\n  // `MAX_REDIRECT_CANDIDATES` is a hard ceiling per CLAUDE.md's no-unbounded-\n  // fan-out rule — this runs on the miss path of every unmatched URL, which is\n  // exactly where a crawler or a scanner spends its time. Beyond it we answer\n  // 404 rather than keep looking; a URL contended by that many documents is\n  // already pathological, and the alternative is letting one request issue\n  // unbounded lookups.\n  const matches = await pathsClient.findMany({\n    where: { locale, path },\n    orderBy: [{ column: 'updatedAt', dir: 'desc' }],\n    limit: MAX_REDIRECT_CANDIDATES,\n  })\n\n  for (const match of matches) {\n    // Resolve the owning document's CURRENT canonical row for this locale.\n    // This is the single hop that makes redirects chain-free: we jump from\n    // \"some URL this document used to (or does) live at\" straight to \"where it\n    // lives now\".\n    const canonical = await pathsClient.findOne({\n      entityType: match.entityType,\n      entityId: match.entityId,\n      locale,\n      isCanonical: true,\n    })\n    // This owner has no live canonical path in this locale anymore. Skip it and\n    // try the next candidate rather than answering 404 on its behalf — the §2\n    // change matrix's 404 is for when NO candidate resolves, not when the\n    // newest one happens not to.\n    if (canonical) {\n      return {\n        entityType: match.entityType,\n        entityId: match.entityId,\n        currentPath: canonical.path,\n      }\n    }\n  }\n\n  // Nothing resolved. If we also filled the candidate window, the answer may be\n  // a TRUNCATION rather than a miss — say so, because the two are identical\n  // from outside and only one of them is a URL somebody should look at.\n  if (matches.length === MAX_REDIRECT_CANDIDATES) {\n    logger?.warn?.(\n      { locale, path, examined: matches.length },\n      'toolkit_paths: redirect lookup examined the full candidate window without ' +\n        'resolving one — answering 404, but a further candidate may exist',\n    )\n  }\n\n  return null\n}\n","/**\n * The public path-resolution API (plan/routing PR06; phase\n * `05-resolution-and-enumeration-api.md` §2, phase `04` §2-4).\n *\n * `resolvePath` maps an incoming `(path, locale)` to a document, a redirect, or\n * a 404, applying the settled precedence:\n *\n *   `/` homepage → canonical → manual redirect → historical redirect → none\n *\n * **Security (CLAUDE.md #1 priority).** These functions gate whether content is\n * reachable by URL. `resolvePath` publish-checks at every tier that resolves to\n * a document (homepage / canonical / historical) via the injected\n * {@link PublishChecker} — an UNPUBLISHED document in the requested locale is\n * NOT routable (`{ kind: 'none' }`). A canonical row \"claims\" its path even in\n * draft, so an unpublished canonical returns `none` WITHOUT falling through to\n * manual/historical (nothing else may resolve there). `resolveDraftPath` is the\n * ONLY function that skips publish checks — it is admin/preview-only. Its one\n * sanctioned HTTP caller is `./routes.ts` (`GET /api/admin/paths/resolve`,\n * added for #775: permission-gated `path:resolve` PLUS a per-document `view`\n * re-check). It must NEVER be wired to a `content-api` endpoint — that surface\n * is public and published-only.\n *\n * **Leaf module.** All cross-package state (path/redirect readers, the publish\n * checker, the homepage reader) is injected via `deps` — this module imports no\n * `@murumets-ee/core` and no `server-only` graph. The concrete `deps` are built\n * from an app in `./resolve-context.ts`.\n */\n\nimport type { Logger } from '@murumets-ee/core'\nimport type { Entity } from '@murumets-ee/entity'\nimport type { RedirectTarget } from '../redirects/target.js'\nimport { normalizePath } from './generate-path.js'\nimport type { PathIndexReader } from './index-reader.js'\nimport type { HomepagePointer } from './homepage.js'\nimport { findRedirectTarget } from './redirect-target.js'\n\n// ---------------------------------------------------------------------------\n// Result type (phase 05 §2 — exact shape)\n// ---------------------------------------------------------------------------\n\n/** The document that serves the requested path. */\nexport interface ResolveDocumentResult {\n  kind: 'document'\n  entityType: string\n  id: string\n}\n/** A redirect to another URL/path. `301` permanent, `302` temporary. */\nexport interface ResolveRedirectResult {\n  kind: 'redirect'\n  to: string\n  status: 301 | 302\n}\n/** Nothing routes here (404). */\nexport interface ResolveNoneResult {\n  kind: 'none'\n}\nexport type ResolveResult = ResolveDocumentResult | ResolveRedirectResult | ResolveNoneResult\n\n// ---------------------------------------------------------------------------\n// Dependency-injection surface\n// ---------------------------------------------------------------------------\n\n/**\n * Is `(entityType, entityId)` published in `locale`? Backed by\n * `QueryClient.findById`, which applies the publish filter for any principal\n * WITHOUT `view_unpublished` (D017) — so the answer is only \"published\" if the\n * injected client's context withholds that action, which the real one\n * (`resolve-context.ts`'s reach context) does. See {@link createPublishChecker}.\n * `resolveDraftPath` bypasses this entirely.\n */\nexport interface PublishChecker {\n  isPublished(entityType: string, entityId: string, locale: string): Promise<boolean>\n}\n\n/** Resolve an entity TYPE NAME to its `Entity`, or `undefined` when unregistered. */\nexport type EntityResolver = (entityType: string) => Entity | undefined\n\n/** The `QueryClient.findById` surface the publish checker needs (publish filter is internal). */\nexport interface PublishQueryClient {\n  findById(id: string, options?: { locale?: string | undefined }): Promise<unknown>\n}\n\n/** Build a publish-filtering read client for an entity (real: `new QueryClient(...)`). */\nexport type QueryClientFactory = (entity: Entity) => PublishQueryClient\n\n/** Read the current homepage pointer, or `null` when unset/malformed. */\nexport type HomepageReader = () => Promise<HomepagePointer | null>\n\n/** The manual-redirect lookup surface (locale-specific + catch-all rows). */\nexport interface RedirectLookupReader {\n  findOne(where: {\n    fromPath: string\n    /** A concrete locale, or `null` for the catch-all (all-locales) row. */\n    locale: string | null\n  }): Promise<{ target: RedirectTarget; status: number } | null>\n}\n\n/** Deps for {@link getCanonicalPath} — the minimal index read. */\nexport interface CanonicalPathDeps {\n  pathsClient: PathIndexReader\n}\n\n/** Deps for {@link resolvePath} / {@link resolveDraftPath}. */\nexport interface ResolvePathDeps extends CanonicalPathDeps {\n  redirectsClient: RedirectLookupReader\n  publishChecker: PublishChecker\n  homepageReader: HomepageReader\n  /**\n   * Is this entity type still routable (does it declare `frontend.path`)? A\n   * `toolkit_paths` row outlives its entity losing the path (F068), so every\n   * tier that serves a row's document asks first: a row of a non-routable\n   * entity is `none`, never a document or a redirect. `buildResolveDeps`\n   * always supplies it; omitted (unit-test builders only) means \"every entity\n   * is routable\".\n   */\n  isRoutable?: (entityType: string) => boolean\n  /**\n   * Optional so the unit-test deps builders stay unchanged. Its only use is\n   * letting the historical-redirect lookup report a truncated candidate window\n   * — see {@link findRedirectTarget}.\n   */\n  logger?: Logger\n}\n\n/** Deps for {@link getAlternates}. */\nexport interface AlternatesDeps extends CanonicalPathDeps {\n  publishChecker: PublishChecker\n  /** The locales to enumerate (configured content locales). */\n  locales: readonly string[]\n}\n\n/**\n * Hop cap on manual-redirect `path`-chain following at REQUEST time (F021 /\n * F027 point 4). `collapsePathTarget` only collapses ONE hop at save time, so a\n * chain created out-of-order can still need re-hopping here; exceeding the cap\n * resolves to `none` rather than looping or 500ing.\n */\nexport const MAX_REDIRECT_HOPS = 5\n\n// ---------------------------------------------------------------------------\n// getCanonicalPath — forward index read, NO publish filter (D-note below)\n// ---------------------------------------------------------------------------\n\n/**\n * The current canonical path for `(entityType, entityId, locale)`, or `null`\n * when the document has no canonical row in that locale.\n *\n * **No publish filter — deliberate.** This matches the CURRENT behavior of\n * `resolveEntityHref` / search's URL builder (both call `AdminClient.findById`,\n * which does zero publish filtering); Task 2 re-points those consumers onto this\n * function, so changing the filtering here would be an unplanned behavior change.\n * Callers that need a publish gate compose one explicitly (resolution's canonical\n * tier does).\n */\nexport async function getCanonicalPath(\n  entityType: string,\n  entityId: string,\n  locale: string,\n  deps: CanonicalPathDeps,\n): Promise<string | null> {\n  const row = await deps.pathsClient.findOne({ entityType, entityId, locale, isCanonical: true })\n  return row?.path ?? null\n}\n\n// ---------------------------------------------------------------------------\n// Publish checker\n// ---------------------------------------------------------------------------\n\n/**\n * Build a {@link PublishChecker} from an entity resolver + a query-client\n * factory. `isPublished` is `false` for an unknown entity type, else\n * `findById(id, { locale }) !== null` — a non-null result means \"published in\n * that locale\" because `QueryClient` applies the publish filter (and excludes\n * trashed rows) for every principal without `view_unpublished` (D017). The\n * factory therefore has to hand back a client whose context withholds that\n * action; `resolve-context.ts`'s reach context is the one in-repo\n * implementation and does. F027 point 1.\n */\nexport function createPublishChecker(deps: {\n  entityResolver: EntityResolver\n  queryClientFactory: QueryClientFactory\n}): PublishChecker {\n  return {\n    async isPublished(entityType, entityId, locale) {\n      const entity = deps.entityResolver(entityType)\n      if (entity === undefined) return false\n      const client = deps.queryClientFactory(entity)\n      const row = await client.findById(entityId, { locale })\n      return row !== null && row !== undefined\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n// resolvePath / resolveDraftPath\n// ---------------------------------------------------------------------------\n\n/** The publish predicate threaded through the tiers (real, or always-true for draft). */\ntype PublishPredicate = (entityType: string, entityId: string, locale: string) => Promise<boolean>\n\n/**\n * Resolve `(path, locale)` to a document / redirect / none, publish-checking at\n * every document-resolving tier. Public request surface (phase 05 §2).\n */\nexport function resolvePath(\n  path: string,\n  locale: string,\n  deps: ResolvePathDeps,\n): Promise<ResolveResult> {\n  return resolveInternal(path, locale, deps, (entityType, entityId, loc) =>\n    deps.publishChecker.isPublished(entityType, entityId, loc),\n  )\n}\n\n/**\n * Admin/preview resolution — identical tier structure to {@link resolvePath} but\n * SKIPS every publish check (draft and published documents both resolve). Per\n * phase 05 §2 this surface is admin-only. Exactly ONE HTTP route may call it —\n * `./routes.ts`'s `GET /api/admin/paths/resolve` (#775), which gates on\n * `path:resolve` and re-checks the caller's `view` grant on whatever it\n * resolves. NEVER wire it to `content-api` (public, published-only).\n */\nexport function resolveDraftPath(\n  path: string,\n  locale: string,\n  deps: ResolvePathDeps,\n): Promise<ResolveResult> {\n  // The ONLY difference from resolvePath: the publish predicate is always true.\n  return resolveInternal(path, locale, deps, async () => true)\n}\n\n/**\n * Shared tier engine for `resolvePath` / `resolveDraftPath`. The two differ ONLY\n * in `checkPublished` (real checker vs. always-true), so the precedence + every\n * branch stay byte-identical between the public and admin surfaces.\n */\nasync function resolveInternal(\n  rawPath: string,\n  locale: string,\n  deps: ResolvePathDeps,\n  checkPublished: PublishPredicate,\n): Promise<ResolveResult> {\n  const path = normalizePath(rawPath)\n  const routable = (entityType: string): boolean => deps.isRoutable?.(entityType) ?? true\n  const homepage = await deps.homepageReader()\n\n  // ── Tier 1: `/` homepage special case ────────────────────────────────────\n  if (path === '/') {\n    if (homepage === null) return { kind: 'none' }\n    if (!(await checkPublished(homepage.entity, homepage.id, locale))) return { kind: 'none' }\n    return { kind: 'document', entityType: homepage.entity, id: homepage.id }\n  }\n\n  // ── Tier 2: canonical ─────────────────────────────────────────────────────\n  const canonical = await deps.pathsClient.findOne({ locale, path, isCanonical: true })\n  if (canonical) {\n    // A row whose entity stopped declaring a frontend path serves nothing, and\n    // (like an unpublished canonical) claims the path: no fall-through.\n    if (!routable(canonical.entityType)) return { kind: 'none' }\n    // The path is CLAIMED by this document even in draft — an unpublished\n    // canonical returns `none` and does NOT fall through to manual/historical.\n    if (!(await checkPublished(canonical.entityType, canonical.entityId, locale))) {\n      return { kind: 'none' }\n    }\n    // D004 dedup: the homepage document's own pattern URL always 301s to `/`.\n    if (isHomepage(homepage, canonical.entityType, canonical.entityId)) {\n      return { kind: 'redirect', to: '/', status: 301 }\n    }\n    return { kind: 'document', entityType: canonical.entityType, id: canonical.entityId }\n  }\n\n  // ── Tier 3: manual redirects ──────────────────────────────────────────────\n  const manual = await resolveManualRedirect(path, locale, deps, homepage, routable)\n  if (manual !== null) return manual\n\n  // ── Tier 4: historical (automatic rename) redirects ───────────────────────\n  const historical = await findRedirectTarget({\n    pathsClient: deps.pathsClient,\n    locale,\n    path,\n    ...(deps.logger !== undefined && { logger: deps.logger }),\n  })\n  if (historical === null) return { kind: 'none' }\n  if (!routable(historical.entityType)) return { kind: 'none' }\n  if (!(await checkPublished(historical.entityType, historical.entityId, locale))) {\n    return { kind: 'none' }\n  }\n  if (isHomepage(homepage, historical.entityType, historical.entityId)) {\n    return { kind: 'redirect', to: '/', status: 301 }\n  }\n  return { kind: 'redirect', to: historical.currentPath, status: 301 }\n}\n\n/**\n * Tier 3 — resolve a manual `toolkit_redirects` row at `fromPath`. Returns:\n *  - `null` when NO manual redirect exists at `fromPath` (caller falls to tier 4).\n *  - a {@link ResolveResult} otherwise (including `{ kind: 'none' }` for a target\n *    that resolves to nothing).\n *\n * `entity`-kind targets resolve via `getCanonicalPath` with NO publish check\n * (F027 point 3 — an unpublished target 404s on the FOLLOWING request via tier\n * 2's own check). `path`-kind targets are re-resolved at request time, bounded\n * by {@link MAX_REDIRECT_HOPS}, so an out-of-order chain (F021) can't loop.\n */\nasync function resolveManualRedirect(\n  fromPath: string,\n  locale: string,\n  deps: ResolvePathDeps,\n  homepage: HomepagePointer | null,\n  routable: (entityType: string) => boolean,\n): Promise<ResolveResult | null> {\n  let row = await lookupManualRedirect(deps.redirectsClient, fromPath, locale)\n  if (row === null) return null // no manual redirect here → fall through to tier 4\n\n  for (let hop = 0; hop < MAX_REDIRECT_HOPS; hop++) {\n    const target = row.target\n    const status = toRedirectStatus(row.status)\n\n    if (target.kind === 'url') {\n      return { kind: 'redirect', to: target.url, status } // terminal, external\n    }\n\n    if (target.kind === 'entity') {\n      // Homepage-collision (D004), same as tiers 2/4 + the path-walk-hits-canonical\n      // case: if the redirect points AT the homepage document, go straight to `/`\n      // rather than its pattern URL (which would then 301 to `/` anyway — a pointless\n      // double hop). Keep the manual redirect's own status.\n      if (isHomepage(homepage, target.entity, target.id)) {\n        return { kind: 'redirect', to: '/', status }\n      }\n      if (!routable(target.entity)) return { kind: 'none' }\n      const to = await getCanonicalPath(target.entity, target.id, locale, deps)\n      if (to === null) return { kind: 'none' } // target has no canonical row in this locale\n      return { kind: 'redirect', to, status }\n    }\n\n    // target.kind === 'path' — re-resolve at request time (bounded).\n    const nextPath = normalizePath(target.path)\n    const nextRow = await lookupManualRedirect(deps.redirectsClient, nextPath, locale)\n    if (nextRow !== null) {\n      row = nextRow // hop to the next redirect and keep walking\n      continue\n    }\n    // No further redirect at `nextPath` — does it serve canonical content?\n    const canonical = await deps.pathsClient.findOne({\n      locale,\n      path: nextPath,\n      isCanonical: true,\n    })\n    if (canonical) {\n      if (!routable(canonical.entityType)) return { kind: 'none' }\n      if (isHomepage(homepage, canonical.entityType, canonical.entityId)) {\n        return { kind: 'redirect', to: '/', status: 301 }\n      }\n      return { kind: 'redirect', to: nextPath, status }\n    }\n    return { kind: 'none' } // path target points at neither a redirect nor content\n  }\n\n  return { kind: 'none' } // exceeded MAX_REDIRECT_HOPS — never loop, never 500\n}\n\n/**\n * Look up a manual redirect at `fromPath`: a locale-specific row wins, else the\n * catch-all (`locale = null`) row. Mirrors `collapsePathTarget`'s precedence.\n */\nasync function lookupManualRedirect(\n  client: RedirectLookupReader,\n  fromPath: string,\n  locale: string,\n): Promise<{ target: RedirectTarget; status: number } | null> {\n  const exact = await client.findOne({ fromPath, locale })\n  if (exact) return exact\n  return client.findOne({ fromPath, locale: null })\n}\n\n// ---------------------------------------------------------------------------\n// getAlternates\n// ---------------------------------------------------------------------------\n\n/**\n * The published per-locale canonical URLs for a document — the `hreflang`\n * alternates set (phase 05 §2, \"published locales only\"). A locale is included\n * only when the document has a canonical row AND is published there. Bounded by\n * the (small, fixed) configured-locale count — no fan-out concern.\n */\nexport async function getAlternates(\n  entityType: string,\n  id: string,\n  deps: AlternatesDeps,\n): Promise<Array<{ locale: string; path: string }>> {\n  const alternates: Array<{ locale: string; path: string }> = []\n  for (const locale of deps.locales) {\n    const path = await getCanonicalPath(entityType, id, locale, deps)\n    if (path === null) continue\n    if (!(await deps.publishChecker.isPublished(entityType, id, locale))) continue\n    alternates.push({ locale, path })\n  }\n  return alternates\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\n/** Is `(entityType, entityId)` the configured homepage document? */\nfunction isHomepage(\n  homepage: HomepagePointer | null,\n  entityType: string,\n  entityId: string,\n): boolean {\n  return homepage !== null && homepage.entity === entityType && homepage.id === entityId\n}\n\n/**\n * Narrow the DB `status` integer (validated `301 | 302` at write time) to the\n * result union. Defaults to `301` for any unexpected value — never a raw number\n * leaking into the typed result.\n */\nfunction toRedirectStatus(status: number): 301 | 302 {\n  return status === 302 ? 302 : 301\n}\n","/**\n * `toolkit_redirects` — the manual-redirect table (plan/routing PR05, phase\n * `04-path-lifecycle-and-redirects.md` §3). One row per admin-authored redirect:\n * a `from_path` (locale-relative source URL) → a {@link RedirectTarget}\n * (entity / url / path). Distinct from the AUTOMATIC redirect history, which lives\n * as demoted (`is_canonical = false`) rows in `toolkit_paths` — this table is only\n * for the URLs automatic history can't express (campaign URLs, migrated-site\n * paths). Owned by `@murumets-ee/content`.\n *\n * Uses `defineTable` (per plan/routing C3, CLAUDE.md \"no raw SQL / typed APIs\n * only\") so reads/writes go through a typed `TableClient` — Task 2's CRUD routes\n * and the save-time validation (`./validation.ts`) never touch raw SQL.\n *\n * ## Uniqueness — TWO partial-unique indexes (F020 point 4)\n *\n * `locale` is nullable: `null` means \"applies to all locales\" (a catch-all\n * redirect). Postgres treats `NULL`s as DISTINCT in an ordinary unique constraint,\n * so a naive `UNIQUE (locale, from_path)` would silently allow duplicate catch-all\n * rows at the same path. Two partial-uniques express the real intent:\n *\n *  - `UNIQUE (locale, from_path) WHERE locale IS NOT NULL` — a locale-specific\n *    redirect is unique per (locale, from_path).\n *  - `UNIQUE (from_path) WHERE locale IS NULL` — at most ONE catch-all redirect per\n *    from_path.\n *\n * A locale-specific row and a catch-all row MAY legitimately coexist at the same\n * `from_path` (intentional per-locale override layering) — the two indexes don't\n * forbid that, only duplicates WITHIN each stratum. Both indexes are keyed on\n * `from_path`, so the \"does this from_path already exist as ANY redirect\"\n * collapse-lookup (`./validation.ts`) is already covered — no extra plain index\n * needed.\n *\n * Both use the callback `where` form (F007's `defineTable` partial-unique support)\n * with an INLINE `IS NULL` / `IS NOT NULL` literal — never `eq()`, which would bind\n * a `$1` param that is invalid in DDL (CLAUDE.md partial-unique gotcha; same form\n * `toolkit_paths` uses).\n */\n\nimport { column } from '@murumets-ee/db'\nimport { sql } from 'drizzle-orm'\nimport { defineSitePartitionedTable } from '../schema/site-partition.js'\nimport type { RedirectTarget } from './target.js'\n\n/**\n * Per site (plan `multisite` phase 03, D005): partitioned by `_site` — both\n * uniques below lead with it, so each site keeps its own redirects from the\n * same `from_path`. A client cannot be built without a site.\n */\nexport const toolkitRedirectsTable = defineSitePartitionedTable({\n  name: 'toolkit_redirects',\n  columns: {\n    id: column.uuid({ primaryKey: true, defaultRandom: true }),\n    /** BCP47 locale, or `null` = applies to all locales (catch-all). */\n    locale: column.varchar({ length: 10 }),\n    /** Locale-relative source URL: leading '/', no trailing '/' (same convention as `toolkit_paths.path`). */\n    fromPath: column.text({ notNull: true, pgName: 'from_path' }),\n    /** The redirect destination — see {@link RedirectTarget}. Stored as the discriminated-union object. */\n    target: column.jsonb<RedirectTarget, true>({ notNull: true }),\n    /** HTTP status. `301 | 302` is validated at the Zod boundary in Task 2's route layer. */\n    status: column.integer({ notNull: true, default: 301 }),\n    /**\n     * The admin who authored the redirect. VARCHAR, never UUID — better-auth user\n     * ids are random strings (CLAUDE.md). Nullable: system-created rows (future\n     * migration/import tooling) have no natural actor, matching how other\n     * audit-style columns in `defineTable` tables stay nullable.\n     */\n    createdBy: column.varchar({ length: 255, pgName: 'created_by' }),\n    createdAt: column.timestamp({\n      notNull: true,\n      defaultNow: true,\n      withTimezone: true,\n      pgName: 'created_at',\n    }),\n    updatedAt: column.timestamp({\n      notNull: true,\n      defaultNow: true,\n      withTimezone: true,\n      pgName: 'updated_at',\n    }),\n  },\n  unique: [\n    // A locale-specific redirect is unique per (locale, from_path). Excludes\n    // catch-all rows (locale IS NULL) from this stratum.\n    { on: ['locale', 'fromPath'], where: (c) => sql`${c.locale} IS NOT NULL` },\n    // At most ONE catch-all (all-locales) redirect per from_path. Postgres would\n    // otherwise treat every NULL locale as distinct and allow duplicates.\n    { on: ['fromPath'], where: (c) => sql`${c.locale} IS NULL` },\n  ],\n})\n\n/** Backwards-compatible raw pgTable export (for the plugin `tables:` slot + migrations). */\nexport const toolkitRedirects = toolkitRedirectsTable.table\n\n/** The full `DefinedTable` for `toolkit_redirects`. */\nexport type ToolkitRedirectsTable = typeof toolkitRedirectsTable\n\n/** The typed `TableClient` for `toolkit_redirects` (`toolkitRedirectsTable.makeClient(db)`). */\nexport type ToolkitRedirectsClient = ReturnType<typeof toolkitRedirectsTable.makeClient>\n"],"mappings":"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"}

package/dist/{versions-B8feZTS9.mjs → versions-C5_IJpI8.mjs}

@@ -1,2 +1,2 @@
-import{t as e}from"./rolldown-runtime-DK3Fl9T5.mjs";import{i as t,n}from"./errors-NRNILhhm.mjs";import{t as r}from"./content-config-store-8omQF5p5.mjs";import{n as i}from"./plugin-ChCEq_Qy.mjs";import{t as a}from"./locale-utils-B0mFoV47.mjs";import{a as o,i as s}from"./context-D7eEItCY.mjs";import{schemaRegistry as c}from"@murumets-ee/db";import{eq as l}from"drizzle-orm";import"server-only";function u(e){return e.match(/\S+|\s+/g)??[]}function d(e,t){if(e===t)return e?[{type:`equal`,value:e}]:[];if(!e)return[{type:`add`,value:t}];if(!t)return[{type:`remove`,value:e}];let n=u(e),r=u(t),i=n.length,a=r.length,o=Array.from({length:i+1},()=>Array(a+1).fill(0));for(let e=1;e<=i;e++){let t=o[e],i=o[e-1];if(!(!t||!i))for(let o=1;o<=a;o++)n[e-1]===r[o-1]?t[o]=(i[o-1]??0)+1:t[o]=Math.max(i[o]??0,t[o-1]??0)}let s=[],c=i,l=a,d=[];for(;c>0||l>0;){let e=c>0?n[c-1]:void 0,t=l>0?r[l-1]:void 0;if(c>0&&l>0&&e!==void 0&&e===t)d.push({type:`equal`,value:e}),c--,l--;else if(l>0&&t!==void 0&&(c===0||(o[c]?.[l-1]??0)>=(o[c-1]?.[l]??0)))d.push({type:`add`,value:t}),l--;else if(e!==void 0)d.push({type:`remove`,value:e}),c--;else break}d.reverse();for(let e of d){let t=s[s.length-1];t&&t.type===e.type?t.value+=e.value:s.push({...e})}return s}function f(e){return e.replace(/<[^>]*>/g,` `).replace(/\s+/g,` `).trim()}function p(e){return e==null?``:e instanceof Date?e.toISOString():typeof e==`object`?JSON.stringify(e):String(e)}function m(e,t,n,r){if(JSON.stringify(t)===JSON.stringify(n))return null;switch(r?.type??g(t,n)){case`text`:case`slug`:return{field:e,type:`text`,from:t,to:n,segments:d(p(t),p(n))};case`richtext`:return{field:e,type:`richtext`,from:t,to:n,segments:d(f(p(t)),f(p(n)))};case`number`:return{field:e,type:`number`,from:t,to:n};case`boolean`:return{field:e,type:`boolean`,from:t,to:n};case`date`:return{field:e,type:`date`,from:t,to:n};case`select`:return{field:e,type:`select`,from:t,to:n};case`media`:return{field:e,type:`media`,from:t,to:n};case`json`:return{field:e,type:`json`,from:t,to:n};case`blockTree`:return{field:e,type:`blockTree`,from:t,to:n};default:return{field:e,type:`unknown`,from:t,to:n}}}function h(e,t,n){let r=new Set([...Object.keys(e),...Object.keys(t)]),i=[];for(let a of r){if(a===`id`||a===`createdAt`||a===`updatedAt`)continue;let r=m(a,e[a],t[a],n?.[a]);r&&i.push(r)}return i}function g(e,t){let n=e??t;if(typeof n==`number`)return`number`;if(typeof n==`boolean`)return`boolean`;if(n instanceof Date)return`date`;if(typeof n==`string`)return/^\d{4}-\d{2}-\d{2}/.test(n)?`date`:`text`;if(Array.isArray(n)){let e=n[0];return n.length>0&&typeof e==`object`&&e&&`type`in e&&`id`in e?`blockTree`:`json`}return typeof n==`object`?`json`:`unknown`}function _(e,t){if(typeof e==`string`||typeof t==`string`)return d(p(e),p(t))}function v(e){if(typeof e!=`object`||!e)return null;let t=e;if(typeof t.id!=`string`||typeof t.type!=`string`)return null;let n={...t.props??{}};return t.traits!==void 0&&(n.traits=t.traits),t.children!==void 0&&(n.children=t.children),{id:t.id,type:t.type,props:n}}function y(e,t){let n=new Set([...Object.keys(e),...Object.keys(t)]),r=[];for(let i of n){let n=e[i],a=t[i];JSON.stringify(n)!==JSON.stringify(a)&&r.push({field:i,from:n,to:a,segments:_(n,a)})}return r}function b(e){let t=new Map,n=0;for(let r of e){let e=v(r);e&&(t.set(e.id,{block:e,index:n}),n++)}return t}function x(e,t){let n=b(e),r=b(t),i=[],a=new Set;for(let[e,{block:t,index:o}]of r){a.add(e);let r=n.get(e);if(!r){i.push({blockId:e,blockType:t.type,status:`added`,toIndex:o});continue}let s=r.block,c=r.index,l=y(s.props,t.props),u=c!==o;l.length===0&&!u?i.push({blockId:e,blockType:t.type,status:`unchanged`,fromIndex:c,toIndex:o}):l.length>0?i.push({blockId:e,blockType:t.type,status:`changed`,fromIndex:c,toIndex:o,propDiffs:l}):i.push({blockId:e,blockType:t.type,status:`moved`,fromIndex:c,toIndex:o})}for(let[e,{block:t,index:r}]of n)a.has(e)||i.push({blockId:e,blockType:t.type,status:`removed`,fromIndex:r});return i}function S(e){return e===`_`||e===r().defaultLocale}function C(e){let{defaultLocale:t}=r();return S(e)?{defaultLocale:t}:{locale:e,defaultLocale:t}}async function w(e,t,n,o,c){if(c!==void 0&&e.db!==c)throw Error("applyLocaleRoutedUpdate: `tx` must be the context's own db handle");let l=await s(e);return e.admin.updateForLocale(t,n,o,{defaultLocale:r().defaultLocale,...c!==void 0&&{tx:c},...l!==null&&{localeStatusWriter:(e,t,n)=>(a(t),i(l,e,t,n))}})}const T=new Set([`id`,`createdAt`,`createdBy`,`updatedAt`,`updatedBy`]);function E(e,t){let n=e.allFields,r={};for(let e of Object.keys(t)){if(T.has(e)||e.startsWith(`_`)||!Object.hasOwn(n,e))continue;let i=n[e];i&&i.internal===!0||(r[e]=t[e])}return r}function D(e,t){return JSON.stringify(e)===JSON.stringify(t)}function O(e,t){let n={};for(let r of Object.keys(t))r===`id`||r.startsWith(`_`)||D(e[r],t[r])||(n[r]=t[r]);return n}var k=e({compareVersions:()=>M,createVersionSnapshot:()=>I,getVersion:()=>j,getVersions:()=>A,pruneVersions:()=>P,restoreVersion:()=>N,saveVersionSnapshot:()=>F,writeVersionColumn:()=>L});async function A(e,t,n){n?.locale!==void 0&&a(n.locale);let r=await o(e);return r?await r.findMany({where:{entityId:t,locale:n?.locale??`_`},orderBy:[{column:`version`,dir:`desc`}],...n?.limit===void 0?{}:{limit:n.limit},...n?.offset===void 0?{}:{offset:n.offset}}):[]}async function j(e,t,n,r=`_`){a(r);let i=await o(e);return i?await i.findOne({entityId:t,version:n,locale:r})??null:null}async function M(e,t,n,r,i=`_`){a(i);let[o,s]=await Promise.all([j(e,t,n,i),j(e,t,r,i)]);if(!o||!s)return null;let c=e.entity.allFields,l=h(o.data,s.data,c);for(let e of l)e.type===`blockTree`&&(e.blockDiffs=x(Array.isArray(e.from)?e.from:[],Array.isArray(e.to)?e.to:[]));return{diffs:l,fromVersion:o,toVersion:s}}async function N(e,r,i,s=`_`){if(a(s),!await o(e))throw new n(e.entity.name,`versions`);let c=await j(e,r,i,s);if(!c)throw new t(r,i,s);let l=c.data;return w(e,r,E(e.entity,l),s)}async function P(e,t,n=`_`){if(a(n),!e.versionableOptions)return;let r=await o(e);if(!r)return;let i=e.versionableOptions.maxPerDoc,s=await r.findMany({where:{entityId:t,locale:n},orderBy:[{column:`version`,dir:`desc`}],limit:i});if(s.length<i)return;let c=s.map(e=>e.id);await r.deleteMany({entityId:t,locale:n,id:{notIn:c}})}async function F(e,t,n,r,i,s=`_`,c){a(s);let l=await o(e);if(!l)return;let[u]=await l.aggregate({select:{maxVersion:{fn:`max`,column:`version`}},where:{entityId:t,locale:s}}),d=Number(u?.maxVersion??0)+1,f=n.status??null;if(i){let e=await l.findOne({entityId:t,isAutosave:!0,version:d,locale:s});if(e)return await l.update({id:e.id},{data:n,delta:r,status:f,createdAt:new Date}),d}return await l.insert({entityId:t,version:d,locale:s,data:n,delta:r,status:f,createdBy:c?.id??null,createdByName:c?.name??null,isAutosave:i}),d}async function I(e,t,n,r,i,o){if(i!==void 0&&a(i),!e.versionableOptions)return;let s=i??`_`,c=await F(e,t,n,r?O(r,n):null,!1,s,o);c!==void 0&&s===`_`&&await L(e,t,c),await P(e,t,s)}async function L(e,t,n){let r=c.get(e.entity.name);r&&await e.db.update(r).set({_version:n}).where(l(r.id,t))}export{P as a,k as c,E as d,w as f,h,A as i,L as l,x as m,I as n,N as o,C as p,j as r,F as s,M as t,O as u};
-//# sourceMappingURL=versions-B8feZTS9.mjs.map
+import{t as e}from"./rolldown-runtime-DK3Fl9T5.mjs";import{i as t,n}from"./errors-NRNILhhm.mjs";import{t as r}from"./content-config-store-8omQF5p5.mjs";import{n as i}from"./plugin-DmyWYmuE.mjs";import{t as a}from"./locale-utils-B0mFoV47.mjs";import{a as o,i as s}from"./context-D7eEItCY.mjs";import{schemaRegistry as c}from"@murumets-ee/db";import{eq as l}from"drizzle-orm";import"server-only";function u(e){return e.match(/\S+|\s+/g)??[]}function d(e,t){if(e===t)return e?[{type:`equal`,value:e}]:[];if(!e)return[{type:`add`,value:t}];if(!t)return[{type:`remove`,value:e}];let n=u(e),r=u(t),i=n.length,a=r.length,o=Array.from({length:i+1},()=>Array(a+1).fill(0));for(let e=1;e<=i;e++){let t=o[e],i=o[e-1];if(!(!t||!i))for(let o=1;o<=a;o++)n[e-1]===r[o-1]?t[o]=(i[o-1]??0)+1:t[o]=Math.max(i[o]??0,t[o-1]??0)}let s=[],c=i,l=a,d=[];for(;c>0||l>0;){let e=c>0?n[c-1]:void 0,t=l>0?r[l-1]:void 0;if(c>0&&l>0&&e!==void 0&&e===t)d.push({type:`equal`,value:e}),c--,l--;else if(l>0&&t!==void 0&&(c===0||(o[c]?.[l-1]??0)>=(o[c-1]?.[l]??0)))d.push({type:`add`,value:t}),l--;else if(e!==void 0)d.push({type:`remove`,value:e}),c--;else break}d.reverse();for(let e of d){let t=s[s.length-1];t&&t.type===e.type?t.value+=e.value:s.push({...e})}return s}function f(e){return e.replace(/<[^>]*>/g,` `).replace(/\s+/g,` `).trim()}function p(e){return e==null?``:e instanceof Date?e.toISOString():typeof e==`object`?JSON.stringify(e):String(e)}function m(e,t,n,r){if(JSON.stringify(t)===JSON.stringify(n))return null;switch(r?.type??g(t,n)){case`text`:case`slug`:return{field:e,type:`text`,from:t,to:n,segments:d(p(t),p(n))};case`richtext`:return{field:e,type:`richtext`,from:t,to:n,segments:d(f(p(t)),f(p(n)))};case`number`:return{field:e,type:`number`,from:t,to:n};case`boolean`:return{field:e,type:`boolean`,from:t,to:n};case`date`:return{field:e,type:`date`,from:t,to:n};case`select`:return{field:e,type:`select`,from:t,to:n};case`media`:return{field:e,type:`media`,from:t,to:n};case`json`:return{field:e,type:`json`,from:t,to:n};case`blockTree`:return{field:e,type:`blockTree`,from:t,to:n};default:return{field:e,type:`unknown`,from:t,to:n}}}function h(e,t,n){let r=new Set([...Object.keys(e),...Object.keys(t)]),i=[];for(let a of r){if(a===`id`||a===`createdAt`||a===`updatedAt`)continue;let r=m(a,e[a],t[a],n?.[a]);r&&i.push(r)}return i}function g(e,t){let n=e??t;if(typeof n==`number`)return`number`;if(typeof n==`boolean`)return`boolean`;if(n instanceof Date)return`date`;if(typeof n==`string`)return/^\d{4}-\d{2}-\d{2}/.test(n)?`date`:`text`;if(Array.isArray(n)){let e=n[0];return n.length>0&&typeof e==`object`&&e&&`type`in e&&`id`in e?`blockTree`:`json`}return typeof n==`object`?`json`:`unknown`}function _(e,t){if(typeof e==`string`||typeof t==`string`)return d(p(e),p(t))}function v(e){if(typeof e!=`object`||!e)return null;let t=e;if(typeof t.id!=`string`||typeof t.type!=`string`)return null;let n={...t.props??{}};return t.traits!==void 0&&(n.traits=t.traits),t.children!==void 0&&(n.children=t.children),{id:t.id,type:t.type,props:n}}function y(e,t){let n=new Set([...Object.keys(e),...Object.keys(t)]),r=[];for(let i of n){let n=e[i],a=t[i];JSON.stringify(n)!==JSON.stringify(a)&&r.push({field:i,from:n,to:a,segments:_(n,a)})}return r}function b(e){let t=new Map,n=0;for(let r of e){let e=v(r);e&&(t.set(e.id,{block:e,index:n}),n++)}return t}function x(e,t){let n=b(e),r=b(t),i=[],a=new Set;for(let[e,{block:t,index:o}]of r){a.add(e);let r=n.get(e);if(!r){i.push({blockId:e,blockType:t.type,status:`added`,toIndex:o});continue}let s=r.block,c=r.index,l=y(s.props,t.props),u=c!==o;l.length===0&&!u?i.push({blockId:e,blockType:t.type,status:`unchanged`,fromIndex:c,toIndex:o}):l.length>0?i.push({blockId:e,blockType:t.type,status:`changed`,fromIndex:c,toIndex:o,propDiffs:l}):i.push({blockId:e,blockType:t.type,status:`moved`,fromIndex:c,toIndex:o})}for(let[e,{block:t,index:r}]of n)a.has(e)||i.push({blockId:e,blockType:t.type,status:`removed`,fromIndex:r});return i}function S(e){return e===`_`||e===r().defaultLocale}function C(e){let{defaultLocale:t}=r();return S(e)?{defaultLocale:t}:{locale:e,defaultLocale:t}}async function w(e,t,n,o,c){if(c!==void 0&&e.db!==c)throw Error("applyLocaleRoutedUpdate: `tx` must be the context's own db handle");let l=await s(e);return e.admin.updateForLocale(t,n,o,{defaultLocale:r().defaultLocale,...c!==void 0&&{tx:c},...l!==null&&{localeStatusWriter:(e,t,n)=>(a(t),i(l,e,t,n))}})}const T=new Set([`id`,`createdAt`,`createdBy`,`updatedAt`,`updatedBy`]);function E(e,t){let n=e.allFields,r={};for(let e of Object.keys(t)){if(T.has(e)||e.startsWith(`_`)||!Object.hasOwn(n,e))continue;let i=n[e];i&&i.internal===!0||(r[e]=t[e])}return r}function D(e,t){return JSON.stringify(e)===JSON.stringify(t)}function O(e,t){let n={};for(let r of Object.keys(t))r===`id`||r.startsWith(`_`)||D(e[r],t[r])||(n[r]=t[r]);return n}var k=e({compareVersions:()=>M,createVersionSnapshot:()=>I,getVersion:()=>j,getVersions:()=>A,pruneVersions:()=>P,restoreVersion:()=>N,saveVersionSnapshot:()=>F,writeVersionColumn:()=>L});async function A(e,t,n){n?.locale!==void 0&&a(n.locale);let r=await o(e);return r?await r.findMany({where:{entityId:t,locale:n?.locale??`_`},orderBy:[{column:`version`,dir:`desc`}],...n?.limit===void 0?{}:{limit:n.limit},...n?.offset===void 0?{}:{offset:n.offset}}):[]}async function j(e,t,n,r=`_`){a(r);let i=await o(e);return i?await i.findOne({entityId:t,version:n,locale:r})??null:null}async function M(e,t,n,r,i=`_`){a(i);let[o,s]=await Promise.all([j(e,t,n,i),j(e,t,r,i)]);if(!o||!s)return null;let c=e.entity.allFields,l=h(o.data,s.data,c);for(let e of l)e.type===`blockTree`&&(e.blockDiffs=x(Array.isArray(e.from)?e.from:[],Array.isArray(e.to)?e.to:[]));return{diffs:l,fromVersion:o,toVersion:s}}async function N(e,r,i,s=`_`){if(a(s),!await o(e))throw new n(e.entity.name,`versions`);let c=await j(e,r,i,s);if(!c)throw new t(r,i,s);let l=c.data;return w(e,r,E(e.entity,l),s)}async function P(e,t,n=`_`){if(a(n),!e.versionableOptions)return;let r=await o(e);if(!r)return;let i=e.versionableOptions.maxPerDoc,s=await r.findMany({where:{entityId:t,locale:n},orderBy:[{column:`version`,dir:`desc`}],limit:i});if(s.length<i)return;let c=s.map(e=>e.id);await r.deleteMany({entityId:t,locale:n,id:{notIn:c}})}async function F(e,t,n,r,i,s=`_`,c){a(s);let l=await o(e);if(!l)return;let[u]=await l.aggregate({select:{maxVersion:{fn:`max`,column:`version`}},where:{entityId:t,locale:s}}),d=Number(u?.maxVersion??0)+1,f=n.status??null;if(i){let e=await l.findOne({entityId:t,isAutosave:!0,version:d,locale:s});if(e)return await l.update({id:e.id},{data:n,delta:r,status:f,createdAt:new Date}),d}return await l.insert({entityId:t,version:d,locale:s,data:n,delta:r,status:f,createdBy:c?.id??null,createdByName:c?.name??null,isAutosave:i}),d}async function I(e,t,n,r,i,o){if(i!==void 0&&a(i),!e.versionableOptions)return;let s=i??`_`,c=await F(e,t,n,r?O(r,n):null,!1,s,o);c!==void 0&&s===`_`&&await L(e,t,c),await P(e,t,s)}async function L(e,t,n){let r=c.get(e.entity.name);r&&await e.db.update(r).set({_version:n}).where(l(r.id,t))}export{P as a,k as c,E as d,w as f,h,A as i,L as l,x as m,I as n,N as o,C as p,j as r,F as s,M as t,O as u};
+//# sourceMappingURL=versions-C5_IJpI8.mjs.map

package/dist/{versions-B8feZTS9.mjs.map → versions-C5_IJpI8.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"versions-B8feZTS9.mjs","names":[],"sources":["../src/diff/text-diff.ts","../src/diff/field-diff.ts","../src/diff/block-diff.ts","../src/internal/apply-locale-routed-update.ts","../src/internal/projection.ts","../src/versions.ts"],"sourcesContent":["/**\n * Word-level text diff using a simplified Myers algorithm.\n *\n * Splits text into words (preserving whitespace), computes the longest common\n * subsequence, and returns an array of diff segments.\n */\n\nimport type { DiffSegment } from './types.js'\n\n/**\n * Split text into tokens — words and whitespace runs — so diffs are\n * human-readable (\"Changed *this* word\") rather than character-level.\n */\nfunction tokenize(text: string): string[] {\n  return text.match(/\\S+|\\s+/g) ?? []\n}\n\n/**\n * Compute word-level diff between two strings.\n *\n * Uses a simple LCS (dynamic programming) approach which is fine for\n * the text sizes we deal with (entity field values, not source code).\n */\nexport function diffText(from: string, to: string): DiffSegment[] {\n  if (from === to) {\n    return from ? [{ type: 'equal', value: from }] : []\n  }\n  if (!from) {\n    return [{ type: 'add', value: to }]\n  }\n  if (!to) {\n    return [{ type: 'remove', value: from }]\n  }\n\n  const fromTokens = tokenize(from)\n  const toTokens = tokenize(to)\n\n  // Build LCS table\n  const m = fromTokens.length\n  const n = toTokens.length\n  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0))\n\n  for (let i = 1; i <= m; i++) {\n    const dpI = dp[i]\n    const dpIm1 = dp[i - 1]\n    if (!dpI || !dpIm1) continue\n    for (let j = 1; j <= n; j++) {\n      if (fromTokens[i - 1] === toTokens[j - 1]) {\n        dpI[j] = (dpIm1[j - 1] ?? 0) + 1\n      } else {\n        dpI[j] = Math.max(dpIm1[j] ?? 0, dpI[j - 1] ?? 0)\n      }\n    }\n  }\n\n  // Backtrack to build diff segments\n  const segments: DiffSegment[] = []\n  let i = m\n  let j = n\n\n  // Collect in reverse, then flip\n  const reversed: DiffSegment[] = []\n\n  while (i > 0 || j > 0) {\n    const fromTok = i > 0 ? fromTokens[i - 1] : undefined\n    const toTok = j > 0 ? toTokens[j - 1] : undefined\n    if (i > 0 && j > 0 && fromTok !== undefined && fromTok === toTok) {\n      reversed.push({ type: 'equal', value: fromTok })\n      i--\n      j--\n    } else if (j > 0 && toTok !== undefined && (i === 0 || (dp[i]?.[j - 1] ?? 0) >= (dp[i - 1]?.[j] ?? 0))) {\n      reversed.push({ type: 'add', value: toTok })\n      j--\n    } else if (fromTok !== undefined) {\n      reversed.push({ type: 'remove', value: fromTok })\n      i--\n    } else {\n      // Defensive: i and j both 0, but loop condition implied otherwise.\n      break\n    }\n  }\n\n  reversed.reverse()\n\n  // Merge consecutive segments of the same type\n  for (const seg of reversed) {\n    const last = segments[segments.length - 1]\n    if (last && last.type === seg.type) {\n      last.value += seg.value\n    } else {\n      segments.push({ ...seg })\n    }\n  }\n\n  return segments\n}\n","/**\n * Field-level diff — dispatches to the appropriate diff strategy per field type.\n */\n\nimport type { FieldConfig } from '@murumets-ee/entity'\nimport { diffText } from './text-diff.js'\nimport type { DiffSegment, FieldDiff } from './types.js'\n\n/** Strip HTML tags for diffing richtext content as plain text. */\nfunction stripHtml(html: string): string {\n  return html\n    .replace(/<[^>]*>/g, ' ')\n    .replace(/\\s+/g, ' ')\n    .trim()\n}\n\n/** Stringify a value for display (dates, objects, etc.). */\nfunction stringify(value: unknown): string {\n  if (value === null || value === undefined) return ''\n  if (value instanceof Date) return value.toISOString()\n  if (typeof value === 'object') return JSON.stringify(value)\n  return String(value)\n}\n\n/**\n * Compute diff for a single field, using the field's type to determine\n * the best diff strategy.\n */\nexport function diffField(\n  fieldName: string,\n  from: unknown,\n  to: unknown,\n  fieldConfig?: FieldConfig,\n): FieldDiff | null {\n  // No change\n  if (JSON.stringify(from) === JSON.stringify(to)) return null\n\n  const type = fieldConfig?.type ?? inferType(from, to)\n\n  switch (type) {\n    case 'text':\n    case 'slug': {\n      const segments = diffText(stringify(from), stringify(to))\n      return { field: fieldName, type: 'text', from, to, segments }\n    }\n\n    case 'richtext': {\n      // Diff on stripped HTML so users see word changes, not tag noise\n      const segments = diffText(stripHtml(stringify(from)), stripHtml(stringify(to)))\n      return { field: fieldName, type: 'richtext', from, to, segments }\n    }\n\n    case 'number':\n      return { field: fieldName, type: 'number', from, to }\n\n    case 'boolean':\n      return { field: fieldName, type: 'boolean', from, to }\n\n    case 'date':\n      return { field: fieldName, type: 'date', from, to }\n\n    case 'select':\n      return { field: fieldName, type: 'select', from, to }\n\n    case 'media':\n      return { field: fieldName, type: 'media', from, to }\n\n    case 'json':\n      return { field: fieldName, type: 'json', from, to }\n\n    case 'blockTree':\n      // Block tree — block-diff.ts computes the structural diff; just mark the\n      // field type so compareVersions/compareDraftWithCurrent populate\n      // `blockDiffs`.\n      return { field: fieldName, type: 'blockTree', from, to }\n\n    default:\n      return { field: fieldName, type: 'unknown', from, to }\n  }\n}\n\n/**\n * Diff all fields between two version snapshots.\n * Pass fieldConfigs to get type-aware diffs; without them, types are inferred.\n */\nexport function diffFields(\n  from: Record<string, unknown>,\n  to: Record<string, unknown>,\n  fieldConfigs?: Record<string, FieldConfig>,\n): FieldDiff[] {\n  const allKeys = new Set([...Object.keys(from), ...Object.keys(to)])\n  const diffs: FieldDiff[] = []\n\n  for (const key of allKeys) {\n    // Skip internal/auto-generated fields\n    if (key === 'id' || key === 'createdAt' || key === 'updatedAt') continue\n\n    const diff = diffField(key, from[key], to[key], fieldConfigs?.[key])\n    if (diff) diffs.push(diff)\n  }\n\n  return diffs\n}\n\n/** Best-effort type inference when no FieldConfig is available. */\nfunction inferType(from: unknown, to: unknown): string {\n  const val = from ?? to\n  if (typeof val === 'number') return 'number'\n  if (typeof val === 'boolean') return 'boolean'\n  if (val instanceof Date) return 'date'\n  if (typeof val === 'string') {\n    if (/^\\d{4}-\\d{2}-\\d{2}/.test(val)) return 'date'\n    return 'text'\n  }\n  if (Array.isArray(val)) {\n    const first = val[0]\n    if (val.length > 0 && typeof first === 'object' && first !== null) {\n      // Block tree: instances discriminated by `type` + `id`.\n      if ('type' in first && 'id' in first) return 'blockTree'\n    }\n    return 'json'\n  }\n  if (typeof val === 'object') return 'json'\n  return 'unknown'\n}\n\n/** Diff two string values and return segments (used by block-diff for string props). */\nexport function diffStringValues(from: unknown, to: unknown): DiffSegment[] | undefined {\n  if (typeof from === 'string' || typeof to === 'string') {\n    return diffText(stringify(from), stringify(to))\n  }\n  return undefined\n}\n","/**\n * Structural diff for block-tree arrays (`field.blockTree()` values).\n *\n * Operates on new-format `BlockInstance`s (`{ id, type, props, traits,\n * children }`) — the only block shape the toolkit stores. Blocks are\n * identified by their `id`. The algorithm detects:\n * - Added blocks (new id in target)\n * - Removed blocks (missing id in target)\n * - Moved blocks (same id, different position)\n * - Changed blocks (same id, different prop/trait/child values)\n * - Unchanged blocks\n */\n\nimport { diffStringValues } from './field-diff.js'\nimport type { BlockDiffEntry, PropDiff } from './types.js'\n\n/** Comparable view of a block instance. */\ninterface NormalizedBlock {\n  id: string\n  type: string\n  /** Comparable content map: `props` + folded-in `traits` / `children`. */\n  props: Record<string, unknown>\n}\n\n/**\n * Normalize a `BlockInstance` to its comparable `{ id, type, props }` view,\n * or null when the value isn't a recognizable block. `traits` and `children`\n * fold into the comparable map so trait edits and nested-tree changes surface\n * as prop diffs (`diffProps` skips JSON-equal values, so empty/unchanged ones\n * add no noise).\n */\nfunction normalizeBlock(val: unknown): NormalizedBlock | null {\n  if (typeof val !== 'object' || val === null) return null\n  const rec = val as Record<string, unknown>\n\n  if (typeof rec.id !== 'string' || typeof rec.type !== 'string') return null\n\n  const props: Record<string, unknown> = { ...((rec.props as Record<string, unknown>) ?? {}) }\n  if (rec.traits !== undefined) props.traits = rec.traits\n  if (rec.children !== undefined) props.children = rec.children\n  return { id: rec.id, type: rec.type, props }\n}\n\n/**\n * Diff two prop objects within a single block, returning per-prop diffs.\n */\nfunction diffProps(\n  fromProps: Record<string, unknown>,\n  toProps: Record<string, unknown>,\n): PropDiff[] {\n  const allKeys = new Set([...Object.keys(fromProps), ...Object.keys(toProps)])\n  const diffs: PropDiff[] = []\n\n  for (const key of allKeys) {\n    const fromVal = fromProps[key]\n    const toVal = toProps[key]\n\n    if (JSON.stringify(fromVal) !== JSON.stringify(toVal)) {\n      diffs.push({\n        field: key,\n        from: fromVal,\n        to: toVal,\n        segments: diffStringValues(fromVal, toVal),\n      })\n    }\n  }\n\n  return diffs\n}\n\n/**\n * Index a block array by id, assigning each block its position AMONG\n * recognizable blocks (not its raw array index). Values that fail\n * normalization are skipped without consuming a position, so a stray\n * non-block entry can't skew move detection for the real blocks around it.\n */\nfunction indexBlocks(blocks: unknown[]): Map<string, { block: NormalizedBlock; index: number }> {\n  const map = new Map<string, { block: NormalizedBlock; index: number }>()\n  let position = 0\n  for (const raw of blocks) {\n    const block = normalizeBlock(raw)\n    if (block) {\n      map.set(block.id, { block, index: position })\n      position++\n    }\n  }\n  return map\n}\n\n/**\n * Compute structural diff between two block arrays.\n *\n * Each block is identified by its id. Position changes, additions, removals,\n * and prop-level changes are all detected.\n */\nexport function diffBlocks(fromBlocks: unknown[], toBlocks: unknown[]): BlockDiffEntry[] {\n  const fromMap = indexBlocks(fromBlocks)\n  const toMap = indexBlocks(toBlocks)\n\n  const entries: BlockDiffEntry[] = []\n  const processedIds = new Set<string>()\n\n  // Walk the \"to\" array to preserve target order\n  for (const [id, { block: toBlock, index: toIndex }] of toMap) {\n    processedIds.add(id)\n    const fromEntry = fromMap.get(id)\n\n    if (!fromEntry) {\n      // Added\n      entries.push({\n        blockId: id,\n        blockType: toBlock.type,\n        status: 'added',\n        toIndex,\n      })\n      continue\n    }\n\n    const fromBlock = fromEntry.block\n    const fromIndex = fromEntry.index\n    const propDiffs = diffProps(fromBlock.props, toBlock.props)\n    const moved = fromIndex !== toIndex\n\n    if (propDiffs.length === 0 && !moved) {\n      entries.push({\n        blockId: id,\n        blockType: toBlock.type,\n        status: 'unchanged',\n        fromIndex,\n        toIndex,\n      })\n    } else if (propDiffs.length > 0) {\n      entries.push({\n        blockId: id,\n        blockType: toBlock.type,\n        status: 'changed',\n        fromIndex,\n        toIndex,\n        propDiffs,\n      })\n    } else {\n      entries.push({\n        blockId: id,\n        blockType: toBlock.type,\n        status: 'moved',\n        fromIndex,\n        toIndex,\n      })\n    }\n  }\n\n  // Removed blocks (in \"from\" but not in \"to\")\n  for (const [id, { block, index }] of fromMap) {\n    if (!processedIds.has(id)) {\n      entries.push({\n        blockId: id,\n        blockType: block.type,\n        status: 'removed',\n        fromIndex: index,\n      })\n    }\n  }\n\n  return entries\n}\n","/**\n * Locale-routed entity write shared by `publishDraft` and `restoreVersion`.\n *\n * Since SD021, the routing itself lives in ONE place —\n * `AdminClient.updateForLocale` (`@murumets-ee/entity`): default locale →\n * base row; non-default → translatable fields to `saveTranslation`,\n * `status` to the per-locale status store, non-translatable remainder to\n * the base row. This module is the thin content-side call: it supplies the\n * plugin's `defaultLocale` and a per-call locale-status writer bound to\n * THIS context's tables, so routing is deterministic regardless of how\n * `ctx.admin` was constructed.\n *\n * Lives in its own internal module because `drafts.ts` imports\n * `versions.ts` (for `createVersionSnapshot`) — exporting this from\n * either of them would close an import cycle.\n */\n\nimport type { FieldConfig } from '@murumets-ee/entity'\nimport type { InferEntityDTO, InferUpdateInput } from '@murumets-ee/entity/admin'\nimport type { PostgresJsDatabase } from 'drizzle-orm/postgres-js'\n// The LEAF definition, not the `../plugin.js` re-export — see `locale-utils.ts`'s\n// identical comment. `plugin.ts` imports this module (indirectly, through\n// `document-version-store.ts`'s contribution), so the barrel would cycle.\nimport { getContentConfig } from '../content-config-store.js'\nimport { upsertLocaleStatusRow } from '../locale-status-slot.js'\nimport { DEFAULT_LOCALE_SENTINEL, validateLocale } from '../locale-utils.js'\nimport { type ContentContext, getLocaleStatusClient } from './context.js'\n\n/** Is this snapshot-key locale the default locale (base-row) one? */\nexport function isDefaultLocale(locale: string): boolean {\n  return locale === DEFAULT_LOCALE_SENTINEL || locale === getContentConfig().defaultLocale\n}\n\n/**\n * `findById` options that read the same locale view the write targets —\n * default locale reads the base row, non-default reads the\n * translation-merged row.\n */\nexport function localeFindOptions(\n  locale: string,\n): { defaultLocale: string } | { locale: string; defaultLocale: string } {\n  const { defaultLocale } = getContentConfig()\n  return isDefaultLocale(locale) ? { defaultLocale } : { locale, defaultLocale }\n}\n\n/**\n * Apply projected entity-field data to the given locale via the SD021\n * choke point. `updateData` MUST already be projected through\n * `projectToEntityFields` — this function only delegates, it does not\n * whitelist.\n *\n * `tx` joins the row write to a caller's transaction. The locale-status writer\n * needs no tx of its own: it is bound to `ctx`, and a caller that passes `tx`\n * builds `ctx` over that same transaction (`publishDraft`), so the status row\n * commits or rolls back with the base row.\n */\nexport async function applyLocaleRoutedUpdate<F extends Record<string, FieldConfig>>(\n  ctx: ContentContext<F>,\n  entityId: string,\n  updateData: Record<string, unknown>,\n  locale: string,\n  tx?: PostgresJsDatabase,\n): Promise<InferEntityDTO<F>> {\n  // Bind the status writer to THIS context's locale-status table when the\n  // entity has one; otherwise let updateForLocale fall back to the base\n  // status column (non-translatable publishables have only the default\n  // locale).\n  //\n  // The writer is the RAW upsert, not `setLocaleStatus`: since the publish gate\n  // moved INTO `setLocaleStatus` (which now delegates to this same\n  // `updateForLocale`), passing it here would re-enter the method one extra\n  // level deep. `updateForLocale` has already asserted the caller's publish\n  // authority from `updateData` before it reaches any writer, so the raw upsert\n  // is gated by the call below — it is not a second ungated door.\n  // The status writer below is bound to `ctx.db`, so a `tx` with a context NOT\n  // built over it would write the row inside the transaction and the status\n  // outside it — a partial publish nothing reports.\n  if (tx !== undefined && ctx.db !== tx) {\n    throw new Error(\"applyLocaleRoutedUpdate: `tx` must be the context's own db handle\")\n  }\n  const localeStatusClient = await getLocaleStatusClient(ctx)\n  return ctx.admin.updateForLocale(entityId, updateData as InferUpdateInput<F>, locale, {\n    defaultLocale: getContentConfig().defaultLocale,\n    ...(tx !== undefined && { tx }),\n    ...(localeStatusClient !== null && {\n      localeStatusWriter: (id: string, loc: string, status: 'draft' | 'published') => {\n        // Same whitelist `setLocaleStatus` applied on this path before — an\n        // unconfigured locale must not mint a status row no reader will merge.\n        validateLocale(loc)\n        return upsertLocaleStatusRow(localeStatusClient, id, loc, status)\n      },\n    }),\n  })\n}\n","/**\n * Field projection + delta helpers shared between drafts and versions.\n *\n * `projectToEntityFields` is the security-critical whitelist filter\n * applied before replaying stored data through `admin.update()` —\n * see audit-security-content.md M#4 (drafts/restore must not pass\n * through forbidden fields like `status: 'published'` or\n * `_workflowStatus: 'approved'`).\n *\n * `valuesEqual` and `calculateDelta` are pure utilities used by both\n * the version-snapshot delta calculator and the block-diff prop\n * comparison — collapsing 3× repeated `JSON.stringify(a) !== JSON.stringify(b)`\n * sites identified in audit-quality-content.md DRY candidates.\n */\n\nimport type { Entity, FieldConfig } from '@murumets-ee/entity'\n\n/**\n * Identity / audit / timestamp fields that exist as real columns on every\n * entity (added by `defineEntity` / `auditable()` / `timestamped()`) and\n * MUST NOT be relayed through `admin.update()` from a draft or version\n * payload. They're either server-set (`createdAt`, `createdBy`,\n * `updatedAt`, `updatedBy`) or immutable identity (`id`).\n *\n * Without this explicit deny-list, `id` would survive `projectToEntityFields`\n * because `defineEntity` injects it into `entity.allFields` and it's not\n * marked `internal: true`. AdminClient.update's Zod schema strips it\n * downstream as a final defense, but security-critical filtering should\n * live in one place — not split across the projection AND the validator.\n */\nconst PROJECTION_DENYLIST = new Set(['id', 'createdAt', 'createdBy', 'updatedAt', 'updatedBy'])\n\n/**\n * Project a draft / version payload through the entity's declared\n * field map before forwarding to `admin.update()`. Used by\n * `publishDraft()` and `restoreVersion()` — both replay stored data\n * that originated from a write, but neither should be allowed to set\n * fields the entity didn't declare.\n *\n * Drops:\n *   - the audit/identity column set above (`id`, `createdAt`,\n *     `createdBy`, `updatedAt`, `updatedBy`)\n *   - any key starting with `_` (behavior internals managed by hooks)\n *   - any field declared `internal: true` (writable only via\n *     AdminClient.updateInternal — never via public CRUD or replay)\n *   - any key not in `entity.allFields` (whitelist for app-defined fields)\n */\nexport function projectToEntityFields(\n  entity: Entity,\n  data: Record<string, unknown>,\n): Record<string, unknown> {\n  const allowed = entity.allFields as Record<string, FieldConfig>\n  const out: Record<string, unknown> = {}\n  for (const key of Object.keys(data)) {\n    if (PROJECTION_DENYLIST.has(key)) continue\n    if (key.startsWith('_')) continue\n    if (!Object.hasOwn(allowed, key)) continue\n    const f = allowed[key]\n    if (f && (f as { internal?: boolean }).internal === true) continue\n    out[key] = data[key]\n  }\n  return out\n}\n\n/**\n * Structural equality via canonical JSON serialization. Coarse, with\n * three known quirks worth flagging at every call site:\n *\n *   1. **Key order matters in pathological cases.** Two objects with\n *      identical keys+values but different insertion order serialize\n *      differently. Safe for entity field values where keys come from\n *      the same field map on both sides; not safe for arbitrary user\n *      JSONB blobs.\n *   2. **Dates compare equal to their ISO string.** `new Date('2026-01-01')`\n *      and `'2026-01-01T00:00:00.000Z'` both stringify to\n *      `\"2026-01-01T00:00:00.000Z\"`. After a round-trip through JSONB\n *      storage, a previously Date-typed field will come back as a\n *      string and compare equal to its origin Date — exactly what we\n *      want for delta calculation.\n *   3. **`undefined` is dropped.** `{ x: undefined }` and `{}` both\n *      serialize to `{}`. If you need to distinguish \"field present\n *      but null\" from \"field missing\", do not use this helper.\n */\nexport function valuesEqual(a: unknown, b: unknown): boolean {\n  return JSON.stringify(a) === JSON.stringify(b)\n}\n\n/**\n * Field-level delta between previous and current entity snapshots.\n * Skips `id` and any underscore-prefixed behavior-internal field.\n * Only changed keys are returned. Used by version-snapshot persistence\n * to store a delta alongside the full snapshot for compact \"what\n * changed since last version\" reads.\n */\nexport function calculateDelta(\n  previous: Record<string, unknown>,\n  current: Record<string, unknown>,\n): Record<string, unknown> {\n  const delta: Record<string, unknown> = {}\n  for (const key of Object.keys(current)) {\n    if (key === 'id' || key.startsWith('_')) continue\n    if (!valuesEqual(previous[key], current[key])) {\n      delta[key] = current[key]\n    }\n  }\n  return delta\n}\n","/**\n * Version-history operations on a content entity.\n *\n * All functions take a {@link ContentContext} as first argument and\n * are wired into ContentClient via thin delegation in `client.ts`.\n *\n * Capability: requires the entity to declare `versionable()`. Read\n * methods return falsy when the entity doesn't support versions\n * (defensive, supports mixed-entity loops in the dashboard); write\n * methods throw `EntityCapabilityError` mapped to HTTP 400 by admin-ui.\n */\n\nimport 'server-only'\n\nimport { schemaRegistry } from '@murumets-ee/db'\nimport type { FieldConfig } from '@murumets-ee/entity'\nimport type { InferEntityDTO } from '@murumets-ee/entity/admin'\nimport { eq } from 'drizzle-orm'\nimport { diffBlocks } from './diff/block-diff.js'\nimport { diffFields } from './diff/field-diff.js'\nimport type { FieldDiff } from './diff/types.js'\nimport { EntityCapabilityError, VersionNotFoundError } from './errors.js'\nimport { applyLocaleRoutedUpdate } from './internal/apply-locale-routed-update.js'\nimport { type ContentContext, getVersionsClient } from './internal/context.js'\nimport { calculateDelta, projectToEntityFields } from './internal/projection.js'\nimport { DEFAULT_LOCALE_SENTINEL, validateLocale } from './locale-utils.js'\nimport type { VersionEntry } from './types.js'\n\n/**\n * List versions for an entity (newest first), filtered by locale.\n * Uses '_' as the locale value for default-locale snapshots.\n */\nexport async function getVersions<F extends Record<string, FieldConfig>>(\n  ctx: ContentContext<F>,\n  entityId: string,\n  options?: { limit?: number; offset?: number; locale?: string },\n): Promise<VersionEntry<InferEntityDTO<F>>[]> {\n  if (options?.locale !== undefined) validateLocale(options.locale)\n  const client = await getVersionsClient(ctx)\n  if (!client) return []\n\n  const rows = await client.findMany({\n    where: { entityId, locale: options?.locale ?? DEFAULT_LOCALE_SENTINEL },\n    orderBy: [{ column: 'version', dir: 'desc' }],\n    ...(options?.limit !== undefined ? { limit: options.limit } : {}),\n    ...(options?.offset !== undefined ? { offset: options.offset } : {}),\n  })\n  return rows as VersionEntry<InferEntityDTO<F>>[]\n}\n\n/**\n * Get a specific version snapshot.\n */\nexport async function getVersion<F extends Record<string, FieldConfig>>(\n  ctx: ContentContext<F>,\n  entityId: string,\n  version: number,\n  locale = DEFAULT_LOCALE_SENTINEL,\n): Promise<VersionEntry<InferEntityDTO<F>> | null> {\n  validateLocale(locale)\n  const client = await getVersionsClient(ctx)\n  if (!client) return null\n  const row = await client.findOne({ entityId, version, locale })\n  return (row ?? null) as VersionEntry<InferEntityDTO<F>> | null\n}\n\n/**\n * Compare two versions and return field-level diff.\n *\n * Returns structured diffs with word-level segments for text fields\n * and structural block diffs for blocks fields.\n */\nexport async function compareVersions<F extends Record<string, FieldConfig>>(\n  ctx: ContentContext<F>,\n  entityId: string,\n  v1: number,\n  v2: number,\n  locale = DEFAULT_LOCALE_SENTINEL,\n): Promise<{\n  diffs: FieldDiff[]\n  fromVersion: VersionEntry<InferEntityDTO<F>>\n  toVersion: VersionEntry<InferEntityDTO<F>>\n} | null> {\n  validateLocale(locale)\n  const [version1, version2] = await Promise.all([\n    getVersion(ctx, entityId, v1, locale),\n    getVersion(ctx, entityId, v2, locale),\n  ])\n  if (!version1 || !version2) return null\n\n  const fieldConfigs = ctx.entity.allFields as Record<string, FieldConfig> | undefined\n  const diffs = diffFields(version1.data, version2.data, fieldConfigs)\n  for (const diff of diffs) {\n    if (diff.type === 'blockTree') {\n      // Normalize a null/undefined side to [] so add/clear of the whole field\n      // (null ↔ blockTree[]) still produces a structural diff, not an opaque one.\n      diff.blockDiffs = diffBlocks(\n        Array.isArray(diff.from) ? diff.from : [],\n        Array.isArray(diff.to) ? diff.to : [],\n      )\n    }\n  }\n  return { diffs, fromVersion: version1, toVersion: version2 }\n}\n\n/**\n * Restore an entity to a previous version. Replays the snapshot data\n * through the locale-routed writer, projected through `entity.allFields`\n * so forbidden fields (workflow internals, behavior-managed underscore\n * fields, fields the entity declared `internal: true`) cannot leak.\n *\n * Snapshots are locale-keyed; the restore reads the snapshot for the\n * given locale and writes it back to the same locale's home —\n * translations for non-default locales, the base row for the default.\n */\nexport async function restoreVersion<F extends Record<string, FieldConfig>>(\n  ctx: ContentContext<F>,\n  entityId: string,\n  version: number,\n  locale = DEFAULT_LOCALE_SENTINEL,\n): Promise<InferEntityDTO<F>> {\n  validateLocale(locale)\n  if (!(await getVersionsClient(ctx))) {\n    throw new EntityCapabilityError(ctx.entity.name, 'versions')\n  }\n  const versionData = await getVersion(ctx, entityId, version, locale)\n  if (!versionData) {\n    throw new VersionNotFoundError(entityId, version, locale)\n  }\n  const data = versionData.data as Record<string, unknown>\n  const updateData = projectToEntityFields(ctx.entity, data)\n  return applyLocaleRoutedUpdate(ctx, entityId, updateData, locale)\n}\n\n/**\n * Enforce maxPerDoc retention by deleting oldest versions for a locale.\n */\nexport async function pruneVersions(\n  ctx: ContentContext,\n  entityId: string,\n  locale = DEFAULT_LOCALE_SENTINEL,\n): Promise<void> {\n  validateLocale(locale)\n  if (!ctx.versionableOptions) return\n  const client = await getVersionsClient(ctx)\n  if (!client) return\n\n  const maxPerDoc = ctx.versionableOptions.maxPerDoc\n\n  // Get IDs of versions to keep (newest N for this locale). The findMany\n  // is capped at `limit: maxPerDoc`, so `keepVersions.length` is\n  // `min(totalRows, maxPerDoc)` — never larger than the limit.\n  const keepVersions = await client.findMany({\n    where: { entityId, locale },\n    orderBy: [{ column: 'version', dir: 'desc' }],\n    limit: maxPerDoc,\n  })\n\n  // Strictly under the limit ⇒ totalRows < maxPerDoc ⇒ nothing to prune.\n  // At the limit (length == maxPerDoc) we cannot distinguish \"exactly\n  // maxPerDoc\" from \"more than maxPerDoc\" without another count query,\n  // so we always run the DELETE — Postgres correctly removes 0-or-more\n  // older rows. Better one always-cheap DELETE per prune than a guard\n  // round trip on every call.\n  if (keepVersions.length < maxPerDoc) return\n\n  const keepIds = keepVersions.map((v) => v.id as string)\n\n  // Delete everything for this entity+locale NOT in the keep list.\n  await client.deleteMany({\n    entityId,\n    locale,\n    id: { notIn: keepIds },\n  })\n}\n\n/**\n * Persist a new version snapshot. Internal helper used by\n * `createVersionSnapshot` and ContentClient.update / .create.\n *\n * Attribution: ONLY the explicit `user` parameter is trusted. The\n * fallback chain that previously read `data.updatedBy` /\n * `data.createdBy` was an audit-log integrity gap (see audit\n * MEDIUM #1) — version history must never absorb a forged actor from\n * the request payload.\n */\nexport async function saveVersionSnapshot(\n  ctx: ContentContext,\n  entityId: string,\n  data: Record<string, unknown>,\n  delta: Record<string, unknown> | null,\n  isAutosave: boolean,\n  locale = DEFAULT_LOCALE_SENTINEL,\n  user?: { id: string; name?: string },\n): Promise<number | undefined> {\n  // All current callers pass a pre-validated locale (or the sentinel).\n  // Defensive check at the boundary so future callers — or anyone who\n  // exposes this helper publicly — still get the validation.\n  validateLocale(locale)\n  const client = await getVersionsClient(ctx)\n  if (!client) return\n\n  // Get the next version number for this locale (max existing + 1).\n  const [maxRow] = await client.aggregate<{ maxVersion: number | null }>({\n    select: { maxVersion: { fn: 'max', column: 'version' } },\n    where: { entityId, locale },\n  })\n  const version = Number(maxRow?.maxVersion ?? 0) + 1\n  const status = (data.status as string) ?? null\n\n  // Autosave: update the existing autosave row at the same version\n  // number, preserving \"autosaves land on the latest slot\" semantics.\n  if (isAutosave) {\n    const existing = await client.findOne({ entityId, isAutosave: true, version, locale })\n    if (existing) {\n      await client.update(\n        { id: existing.id as string },\n        { data, delta, status, createdAt: new Date() },\n      )\n      return version\n    }\n  }\n\n  await client.insert({\n    entityId,\n    version,\n    locale,\n    data,\n    delta,\n    status,\n    createdBy: user?.id ?? null,\n    createdByName: user?.name ?? null,\n    isAutosave,\n  })\n  return version\n}\n\n/**\n * Create a version snapshot for an entity after an external update.\n * Use this when the update was performed by AdminClient directly\n * (e.g. the admin API handler) rather than through ContentClient.update().\n *\n * @param locale - The locale being edited. Use undefined or '_' for the default locale.\n * @param user  - The user who made the change (id + name for display).\n */\nexport async function createVersionSnapshot(\n  ctx: ContentContext,\n  entityId: string,\n  currentData: Record<string, unknown>,\n  previousData?: Record<string, unknown> | null,\n  locale?: string,\n  user?: { id: string; name?: string },\n): Promise<void> {\n  if (locale !== undefined) validateLocale(locale)\n  if (!ctx.versionableOptions) return\n  const snapshotLocale = locale ?? DEFAULT_LOCALE_SENTINEL\n  const delta = previousData ? calculateDelta(previousData, currentData) : null\n  const version = await saveVersionSnapshot(\n    ctx,\n    entityId,\n    currentData,\n    delta,\n    false,\n    snapshotLocale,\n    user,\n  )\n\n  // Update _version on the entity to match (default locale only).\n  if (version !== undefined && snapshotLocale === DEFAULT_LOCALE_SENTINEL) {\n    await writeVersionColumn(ctx, entityId, version)\n  }\n\n  await pruneVersions(ctx, entityId, snapshotLocale)\n}\n\n/**\n * Write the `_version` column on the entity row.\n *\n * KNOWN EXCEPTION: this bypasses AdminClient and goes straight to the\n * entity pgTable via `schemaRegistry` + direct Drizzle. Using\n * `admin.update()` would retrigger the `versionable.beforeUpdate` hook\n * and loop indefinitely. The only ContentClient path that still writes\n * to an entity table directly.\n */\nexport async function writeVersionColumn(\n  ctx: ContentContext,\n  entityId: string,\n  version: number,\n): Promise<void> {\n  const table = schemaRegistry.get(ctx.entity.name)\n  if (!table) return\n  await ctx.db.update(table).set({ _version: version }).where(eq(table.id, entityId))\n}\n"],"mappings":"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"}
+{"version":3,"file":"versions-C5_IJpI8.mjs","names":[],"sources":["../src/diff/text-diff.ts","../src/diff/field-diff.ts","../src/diff/block-diff.ts","../src/internal/apply-locale-routed-update.ts","../src/internal/projection.ts","../src/versions.ts"],"sourcesContent":["/**\n * Word-level text diff using a simplified Myers algorithm.\n *\n * Splits text into words (preserving whitespace), computes the longest common\n * subsequence, and returns an array of diff segments.\n */\n\nimport type { DiffSegment } from './types.js'\n\n/**\n * Split text into tokens — words and whitespace runs — so diffs are\n * human-readable (\"Changed *this* word\") rather than character-level.\n */\nfunction tokenize(text: string): string[] {\n  return text.match(/\\S+|\\s+/g) ?? []\n}\n\n/**\n * Compute word-level diff between two strings.\n *\n * Uses a simple LCS (dynamic programming) approach which is fine for\n * the text sizes we deal with (entity field values, not source code).\n */\nexport function diffText(from: string, to: string): DiffSegment[] {\n  if (from === to) {\n    return from ? [{ type: 'equal', value: from }] : []\n  }\n  if (!from) {\n    return [{ type: 'add', value: to }]\n  }\n  if (!to) {\n    return [{ type: 'remove', value: from }]\n  }\n\n  const fromTokens = tokenize(from)\n  const toTokens = tokenize(to)\n\n  // Build LCS table\n  const m = fromTokens.length\n  const n = toTokens.length\n  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0))\n\n  for (let i = 1; i <= m; i++) {\n    const dpI = dp[i]\n    const dpIm1 = dp[i - 1]\n    if (!dpI || !dpIm1) continue\n    for (let j = 1; j <= n; j++) {\n      if (fromTokens[i - 1] === toTokens[j - 1]) {\n        dpI[j] = (dpIm1[j - 1] ?? 0) + 1\n      } else {\n        dpI[j] = Math.max(dpIm1[j] ?? 0, dpI[j - 1] ?? 0)\n      }\n    }\n  }\n\n  // Backtrack to build diff segments\n  const segments: DiffSegment[] = []\n  let i = m\n  let j = n\n\n  // Collect in reverse, then flip\n  const reversed: DiffSegment[] = []\n\n  while (i > 0 || j > 0) {\n    const fromTok = i > 0 ? fromTokens[i - 1] : undefined\n    const toTok = j > 0 ? toTokens[j - 1] : undefined\n    if (i > 0 && j > 0 && fromTok !== undefined && fromTok === toTok) {\n      reversed.push({ type: 'equal', value: fromTok })\n      i--\n      j--\n    } else if (j > 0 && toTok !== undefined && (i === 0 || (dp[i]?.[j - 1] ?? 0) >= (dp[i - 1]?.[j] ?? 0))) {\n      reversed.push({ type: 'add', value: toTok })\n      j--\n    } else if (fromTok !== undefined) {\n      reversed.push({ type: 'remove', value: fromTok })\n      i--\n    } else {\n      // Defensive: i and j both 0, but loop condition implied otherwise.\n      break\n    }\n  }\n\n  reversed.reverse()\n\n  // Merge consecutive segments of the same type\n  for (const seg of reversed) {\n    const last = segments[segments.length - 1]\n    if (last && last.type === seg.type) {\n      last.value += seg.value\n    } else {\n      segments.push({ ...seg })\n    }\n  }\n\n  return segments\n}\n","/**\n * Field-level diff — dispatches to the appropriate diff strategy per field type.\n */\n\nimport type { FieldConfig } from '@murumets-ee/entity'\nimport { diffText } from './text-diff.js'\nimport type { DiffSegment, FieldDiff } from './types.js'\n\n/** Strip HTML tags for diffing richtext content as plain text. */\nfunction stripHtml(html: string): string {\n  return html\n    .replace(/<[^>]*>/g, ' ')\n    .replace(/\\s+/g, ' ')\n    .trim()\n}\n\n/** Stringify a value for display (dates, objects, etc.). */\nfunction stringify(value: unknown): string {\n  if (value === null || value === undefined) return ''\n  if (value instanceof Date) return value.toISOString()\n  if (typeof value === 'object') return JSON.stringify(value)\n  return String(value)\n}\n\n/**\n * Compute diff for a single field, using the field's type to determine\n * the best diff strategy.\n */\nexport function diffField(\n  fieldName: string,\n  from: unknown,\n  to: unknown,\n  fieldConfig?: FieldConfig,\n): FieldDiff | null {\n  // No change\n  if (JSON.stringify(from) === JSON.stringify(to)) return null\n\n  const type = fieldConfig?.type ?? inferType(from, to)\n\n  switch (type) {\n    case 'text':\n    case 'slug': {\n      const segments = diffText(stringify(from), stringify(to))\n      return { field: fieldName, type: 'text', from, to, segments }\n    }\n\n    case 'richtext': {\n      // Diff on stripped HTML so users see word changes, not tag noise\n      const segments = diffText(stripHtml(stringify(from)), stripHtml(stringify(to)))\n      return { field: fieldName, type: 'richtext', from, to, segments }\n    }\n\n    case 'number':\n      return { field: fieldName, type: 'number', from, to }\n\n    case 'boolean':\n      return { field: fieldName, type: 'boolean', from, to }\n\n    case 'date':\n      return { field: fieldName, type: 'date', from, to }\n\n    case 'select':\n      return { field: fieldName, type: 'select', from, to }\n\n    case 'media':\n      return { field: fieldName, type: 'media', from, to }\n\n    case 'json':\n      return { field: fieldName, type: 'json', from, to }\n\n    case 'blockTree':\n      // Block tree — block-diff.ts computes the structural diff; just mark the\n      // field type so compareVersions/compareDraftWithCurrent populate\n      // `blockDiffs`.\n      return { field: fieldName, type: 'blockTree', from, to }\n\n    default:\n      return { field: fieldName, type: 'unknown', from, to }\n  }\n}\n\n/**\n * Diff all fields between two version snapshots.\n * Pass fieldConfigs to get type-aware diffs; without them, types are inferred.\n */\nexport function diffFields(\n  from: Record<string, unknown>,\n  to: Record<string, unknown>,\n  fieldConfigs?: Record<string, FieldConfig>,\n): FieldDiff[] {\n  const allKeys = new Set([...Object.keys(from), ...Object.keys(to)])\n  const diffs: FieldDiff[] = []\n\n  for (const key of allKeys) {\n    // Skip internal/auto-generated fields\n    if (key === 'id' || key === 'createdAt' || key === 'updatedAt') continue\n\n    const diff = diffField(key, from[key], to[key], fieldConfigs?.[key])\n    if (diff) diffs.push(diff)\n  }\n\n  return diffs\n}\n\n/** Best-effort type inference when no FieldConfig is available. */\nfunction inferType(from: unknown, to: unknown): string {\n  const val = from ?? to\n  if (typeof val === 'number') return 'number'\n  if (typeof val === 'boolean') return 'boolean'\n  if (val instanceof Date) return 'date'\n  if (typeof val === 'string') {\n    if (/^\\d{4}-\\d{2}-\\d{2}/.test(val)) return 'date'\n    return 'text'\n  }\n  if (Array.isArray(val)) {\n    const first = val[0]\n    if (val.length > 0 && typeof first === 'object' && first !== null) {\n      // Block tree: instances discriminated by `type` + `id`.\n      if ('type' in first && 'id' in first) return 'blockTree'\n    }\n    return 'json'\n  }\n  if (typeof val === 'object') return 'json'\n  return 'unknown'\n}\n\n/** Diff two string values and return segments (used by block-diff for string props). */\nexport function diffStringValues(from: unknown, to: unknown): DiffSegment[] | undefined {\n  if (typeof from === 'string' || typeof to === 'string') {\n    return diffText(stringify(from), stringify(to))\n  }\n  return undefined\n}\n","/**\n * Structural diff for block-tree arrays (`field.blockTree()` values).\n *\n * Operates on new-format `BlockInstance`s (`{ id, type, props, traits,\n * children }`) — the only block shape the toolkit stores. Blocks are\n * identified by their `id`. The algorithm detects:\n * - Added blocks (new id in target)\n * - Removed blocks (missing id in target)\n * - Moved blocks (same id, different position)\n * - Changed blocks (same id, different prop/trait/child values)\n * - Unchanged blocks\n */\n\nimport { diffStringValues } from './field-diff.js'\nimport type { BlockDiffEntry, PropDiff } from './types.js'\n\n/** Comparable view of a block instance. */\ninterface NormalizedBlock {\n  id: string\n  type: string\n  /** Comparable content map: `props` + folded-in `traits` / `children`. */\n  props: Record<string, unknown>\n}\n\n/**\n * Normalize a `BlockInstance` to its comparable `{ id, type, props }` view,\n * or null when the value isn't a recognizable block. `traits` and `children`\n * fold into the comparable map so trait edits and nested-tree changes surface\n * as prop diffs (`diffProps` skips JSON-equal values, so empty/unchanged ones\n * add no noise).\n */\nfunction normalizeBlock(val: unknown): NormalizedBlock | null {\n  if (typeof val !== 'object' || val === null) return null\n  const rec = val as Record<string, unknown>\n\n  if (typeof rec.id !== 'string' || typeof rec.type !== 'string') return null\n\n  const props: Record<string, unknown> = { ...((rec.props as Record<string, unknown>) ?? {}) }\n  if (rec.traits !== undefined) props.traits = rec.traits\n  if (rec.children !== undefined) props.children = rec.children\n  return { id: rec.id, type: rec.type, props }\n}\n\n/**\n * Diff two prop objects within a single block, returning per-prop diffs.\n */\nfunction diffProps(\n  fromProps: Record<string, unknown>,\n  toProps: Record<string, unknown>,\n): PropDiff[] {\n  const allKeys = new Set([...Object.keys(fromProps), ...Object.keys(toProps)])\n  const diffs: PropDiff[] = []\n\n  for (const key of allKeys) {\n    const fromVal = fromProps[key]\n    const toVal = toProps[key]\n\n    if (JSON.stringify(fromVal) !== JSON.stringify(toVal)) {\n      diffs.push({\n        field: key,\n        from: fromVal,\n        to: toVal,\n        segments: diffStringValues(fromVal, toVal),\n      })\n    }\n  }\n\n  return diffs\n}\n\n/**\n * Index a block array by id, assigning each block its position AMONG\n * recognizable blocks (not its raw array index). Values that fail\n * normalization are skipped without consuming a position, so a stray\n * non-block entry can't skew move detection for the real blocks around it.\n */\nfunction indexBlocks(blocks: unknown[]): Map<string, { block: NormalizedBlock; index: number }> {\n  const map = new Map<string, { block: NormalizedBlock; index: number }>()\n  let position = 0\n  for (const raw of blocks) {\n    const block = normalizeBlock(raw)\n    if (block) {\n      map.set(block.id, { block, index: position })\n      position++\n    }\n  }\n  return map\n}\n\n/**\n * Compute structural diff between two block arrays.\n *\n * Each block is identified by its id. Position changes, additions, removals,\n * and prop-level changes are all detected.\n */\nexport function diffBlocks(fromBlocks: unknown[], toBlocks: unknown[]): BlockDiffEntry[] {\n  const fromMap = indexBlocks(fromBlocks)\n  const toMap = indexBlocks(toBlocks)\n\n  const entries: BlockDiffEntry[] = []\n  const processedIds = new Set<string>()\n\n  // Walk the \"to\" array to preserve target order\n  for (const [id, { block: toBlock, index: toIndex }] of toMap) {\n    processedIds.add(id)\n    const fromEntry = fromMap.get(id)\n\n    if (!fromEntry) {\n      // Added\n      entries.push({\n        blockId: id,\n        blockType: toBlock.type,\n        status: 'added',\n        toIndex,\n      })\n      continue\n    }\n\n    const fromBlock = fromEntry.block\n    const fromIndex = fromEntry.index\n    const propDiffs = diffProps(fromBlock.props, toBlock.props)\n    const moved = fromIndex !== toIndex\n\n    if (propDiffs.length === 0 && !moved) {\n      entries.push({\n        blockId: id,\n        blockType: toBlock.type,\n        status: 'unchanged',\n        fromIndex,\n        toIndex,\n      })\n    } else if (propDiffs.length > 0) {\n      entries.push({\n        blockId: id,\n        blockType: toBlock.type,\n        status: 'changed',\n        fromIndex,\n        toIndex,\n        propDiffs,\n      })\n    } else {\n      entries.push({\n        blockId: id,\n        blockType: toBlock.type,\n        status: 'moved',\n        fromIndex,\n        toIndex,\n      })\n    }\n  }\n\n  // Removed blocks (in \"from\" but not in \"to\")\n  for (const [id, { block, index }] of fromMap) {\n    if (!processedIds.has(id)) {\n      entries.push({\n        blockId: id,\n        blockType: block.type,\n        status: 'removed',\n        fromIndex: index,\n      })\n    }\n  }\n\n  return entries\n}\n","/**\n * Locale-routed entity write shared by `publishDraft` and `restoreVersion`.\n *\n * Since SD021, the routing itself lives in ONE place —\n * `AdminClient.updateForLocale` (`@murumets-ee/entity`): default locale →\n * base row; non-default → translatable fields to `saveTranslation`,\n * `status` to the per-locale status store, non-translatable remainder to\n * the base row. This module is the thin content-side call: it supplies the\n * plugin's `defaultLocale` and a per-call locale-status writer bound to\n * THIS context's tables, so routing is deterministic regardless of how\n * `ctx.admin` was constructed.\n *\n * Lives in its own internal module because `drafts.ts` imports\n * `versions.ts` (for `createVersionSnapshot`) — exporting this from\n * either of them would close an import cycle.\n */\n\nimport type { FieldConfig } from '@murumets-ee/entity'\nimport type { InferEntityDTO, InferUpdateInput } from '@murumets-ee/entity/admin'\nimport type { PostgresJsDatabase } from 'drizzle-orm/postgres-js'\n// The LEAF definition, not the `../plugin.js` re-export — see `locale-utils.ts`'s\n// identical comment. `plugin.ts` imports this module (indirectly, through\n// `document-version-store.ts`'s contribution), so the barrel would cycle.\nimport { getContentConfig } from '../content-config-store.js'\nimport { upsertLocaleStatusRow } from '../locale-status-slot.js'\nimport { DEFAULT_LOCALE_SENTINEL, validateLocale } from '../locale-utils.js'\nimport { type ContentContext, getLocaleStatusClient } from './context.js'\n\n/** Is this snapshot-key locale the default locale (base-row) one? */\nexport function isDefaultLocale(locale: string): boolean {\n  return locale === DEFAULT_LOCALE_SENTINEL || locale === getContentConfig().defaultLocale\n}\n\n/**\n * `findById` options that read the same locale view the write targets —\n * default locale reads the base row, non-default reads the\n * translation-merged row.\n */\nexport function localeFindOptions(\n  locale: string,\n): { defaultLocale: string } | { locale: string; defaultLocale: string } {\n  const { defaultLocale } = getContentConfig()\n  return isDefaultLocale(locale) ? { defaultLocale } : { locale, defaultLocale }\n}\n\n/**\n * Apply projected entity-field data to the given locale via the SD021\n * choke point. `updateData` MUST already be projected through\n * `projectToEntityFields` — this function only delegates, it does not\n * whitelist.\n *\n * `tx` joins the row write to a caller's transaction. The locale-status writer\n * needs no tx of its own: it is bound to `ctx`, and a caller that passes `tx`\n * builds `ctx` over that same transaction (`publishDraft`), so the status row\n * commits or rolls back with the base row.\n */\nexport async function applyLocaleRoutedUpdate<F extends Record<string, FieldConfig>>(\n  ctx: ContentContext<F>,\n  entityId: string,\n  updateData: Record<string, unknown>,\n  locale: string,\n  tx?: PostgresJsDatabase,\n): Promise<InferEntityDTO<F>> {\n  // Bind the status writer to THIS context's locale-status table when the\n  // entity has one; otherwise let updateForLocale fall back to the base\n  // status column (non-translatable publishables have only the default\n  // locale).\n  //\n  // The writer is the RAW upsert, not `setLocaleStatus`: since the publish gate\n  // moved INTO `setLocaleStatus` (which now delegates to this same\n  // `updateForLocale`), passing it here would re-enter the method one extra\n  // level deep. `updateForLocale` has already asserted the caller's publish\n  // authority from `updateData` before it reaches any writer, so the raw upsert\n  // is gated by the call below — it is not a second ungated door.\n  // The status writer below is bound to `ctx.db`, so a `tx` with a context NOT\n  // built over it would write the row inside the transaction and the status\n  // outside it — a partial publish nothing reports.\n  if (tx !== undefined && ctx.db !== tx) {\n    throw new Error(\"applyLocaleRoutedUpdate: `tx` must be the context's own db handle\")\n  }\n  const localeStatusClient = await getLocaleStatusClient(ctx)\n  return ctx.admin.updateForLocale(entityId, updateData as InferUpdateInput<F>, locale, {\n    defaultLocale: getContentConfig().defaultLocale,\n    ...(tx !== undefined && { tx }),\n    ...(localeStatusClient !== null && {\n      localeStatusWriter: (id: string, loc: string, status: 'draft' | 'published') => {\n        // Same whitelist `setLocaleStatus` applied on this path before — an\n        // unconfigured locale must not mint a status row no reader will merge.\n        validateLocale(loc)\n        return upsertLocaleStatusRow(localeStatusClient, id, loc, status)\n      },\n    }),\n  })\n}\n","/**\n * Field projection + delta helpers shared between drafts and versions.\n *\n * `projectToEntityFields` is the security-critical whitelist filter\n * applied before replaying stored data through `admin.update()` —\n * see audit-security-content.md M#4 (drafts/restore must not pass\n * through forbidden fields like `status: 'published'` or\n * `_workflowStatus: 'approved'`).\n *\n * `valuesEqual` and `calculateDelta` are pure utilities used by both\n * the version-snapshot delta calculator and the block-diff prop\n * comparison — collapsing 3× repeated `JSON.stringify(a) !== JSON.stringify(b)`\n * sites identified in audit-quality-content.md DRY candidates.\n */\n\nimport type { Entity, FieldConfig } from '@murumets-ee/entity'\n\n/**\n * Identity / audit / timestamp fields that exist as real columns on every\n * entity (added by `defineEntity` / `auditable()` / `timestamped()`) and\n * MUST NOT be relayed through `admin.update()` from a draft or version\n * payload. They're either server-set (`createdAt`, `createdBy`,\n * `updatedAt`, `updatedBy`) or immutable identity (`id`).\n *\n * Without this explicit deny-list, `id` would survive `projectToEntityFields`\n * because `defineEntity` injects it into `entity.allFields` and it's not\n * marked `internal: true`. AdminClient.update's Zod schema strips it\n * downstream as a final defense, but security-critical filtering should\n * live in one place — not split across the projection AND the validator.\n */\nconst PROJECTION_DENYLIST = new Set(['id', 'createdAt', 'createdBy', 'updatedAt', 'updatedBy'])\n\n/**\n * Project a draft / version payload through the entity's declared\n * field map before forwarding to `admin.update()`. Used by\n * `publishDraft()` and `restoreVersion()` — both replay stored data\n * that originated from a write, but neither should be allowed to set\n * fields the entity didn't declare.\n *\n * Drops:\n *   - the audit/identity column set above (`id`, `createdAt`,\n *     `createdBy`, `updatedAt`, `updatedBy`)\n *   - any key starting with `_` (behavior internals managed by hooks)\n *   - any field declared `internal: true` (writable only via\n *     AdminClient.updateInternal — never via public CRUD or replay)\n *   - any key not in `entity.allFields` (whitelist for app-defined fields)\n */\nexport function projectToEntityFields(\n  entity: Entity,\n  data: Record<string, unknown>,\n): Record<string, unknown> {\n  const allowed = entity.allFields as Record<string, FieldConfig>\n  const out: Record<string, unknown> = {}\n  for (const key of Object.keys(data)) {\n    if (PROJECTION_DENYLIST.has(key)) continue\n    if (key.startsWith('_')) continue\n    if (!Object.hasOwn(allowed, key)) continue\n    const f = allowed[key]\n    if (f && (f as { internal?: boolean }).internal === true) continue\n    out[key] = data[key]\n  }\n  return out\n}\n\n/**\n * Structural equality via canonical JSON serialization. Coarse, with\n * three known quirks worth flagging at every call site:\n *\n *   1. **Key order matters in pathological cases.** Two objects with\n *      identical keys+values but different insertion order serialize\n *      differently. Safe for entity field values where keys come from\n *      the same field map on both sides; not safe for arbitrary user\n *      JSONB blobs.\n *   2. **Dates compare equal to their ISO string.** `new Date('2026-01-01')`\n *      and `'2026-01-01T00:00:00.000Z'` both stringify to\n *      `\"2026-01-01T00:00:00.000Z\"`. After a round-trip through JSONB\n *      storage, a previously Date-typed field will come back as a\n *      string and compare equal to its origin Date — exactly what we\n *      want for delta calculation.\n *   3. **`undefined` is dropped.** `{ x: undefined }` and `{}` both\n *      serialize to `{}`. If you need to distinguish \"field present\n *      but null\" from \"field missing\", do not use this helper.\n */\nexport function valuesEqual(a: unknown, b: unknown): boolean {\n  return JSON.stringify(a) === JSON.stringify(b)\n}\n\n/**\n * Field-level delta between previous and current entity snapshots.\n * Skips `id` and any underscore-prefixed behavior-internal field.\n * Only changed keys are returned. Used by version-snapshot persistence\n * to store a delta alongside the full snapshot for compact \"what\n * changed since last version\" reads.\n */\nexport function calculateDelta(\n  previous: Record<string, unknown>,\n  current: Record<string, unknown>,\n): Record<string, unknown> {\n  const delta: Record<string, unknown> = {}\n  for (const key of Object.keys(current)) {\n    if (key === 'id' || key.startsWith('_')) continue\n    if (!valuesEqual(previous[key], current[key])) {\n      delta[key] = current[key]\n    }\n  }\n  return delta\n}\n","/**\n * Version-history operations on a content entity.\n *\n * All functions take a {@link ContentContext} as first argument and\n * are wired into ContentClient via thin delegation in `client.ts`.\n *\n * Capability: requires the entity to declare `versionable()`. Read\n * methods return falsy when the entity doesn't support versions\n * (defensive, supports mixed-entity loops in the dashboard); write\n * methods throw `EntityCapabilityError` mapped to HTTP 400 by admin-ui.\n */\n\nimport 'server-only'\n\nimport { schemaRegistry } from '@murumets-ee/db'\nimport type { FieldConfig } from '@murumets-ee/entity'\nimport type { InferEntityDTO } from '@murumets-ee/entity/admin'\nimport { eq } from 'drizzle-orm'\nimport { diffBlocks } from './diff/block-diff.js'\nimport { diffFields } from './diff/field-diff.js'\nimport type { FieldDiff } from './diff/types.js'\nimport { EntityCapabilityError, VersionNotFoundError } from './errors.js'\nimport { applyLocaleRoutedUpdate } from './internal/apply-locale-routed-update.js'\nimport { type ContentContext, getVersionsClient } from './internal/context.js'\nimport { calculateDelta, projectToEntityFields } from './internal/projection.js'\nimport { DEFAULT_LOCALE_SENTINEL, validateLocale } from './locale-utils.js'\nimport type { VersionEntry } from './types.js'\n\n/**\n * List versions for an entity (newest first), filtered by locale.\n * Uses '_' as the locale value for default-locale snapshots.\n */\nexport async function getVersions<F extends Record<string, FieldConfig>>(\n  ctx: ContentContext<F>,\n  entityId: string,\n  options?: { limit?: number; offset?: number; locale?: string },\n): Promise<VersionEntry<InferEntityDTO<F>>[]> {\n  if (options?.locale !== undefined) validateLocale(options.locale)\n  const client = await getVersionsClient(ctx)\n  if (!client) return []\n\n  const rows = await client.findMany({\n    where: { entityId, locale: options?.locale ?? DEFAULT_LOCALE_SENTINEL },\n    orderBy: [{ column: 'version', dir: 'desc' }],\n    ...(options?.limit !== undefined ? { limit: options.limit } : {}),\n    ...(options?.offset !== undefined ? { offset: options.offset } : {}),\n  })\n  return rows as VersionEntry<InferEntityDTO<F>>[]\n}\n\n/**\n * Get a specific version snapshot.\n */\nexport async function getVersion<F extends Record<string, FieldConfig>>(\n  ctx: ContentContext<F>,\n  entityId: string,\n  version: number,\n  locale = DEFAULT_LOCALE_SENTINEL,\n): Promise<VersionEntry<InferEntityDTO<F>> | null> {\n  validateLocale(locale)\n  const client = await getVersionsClient(ctx)\n  if (!client) return null\n  const row = await client.findOne({ entityId, version, locale })\n  return (row ?? null) as VersionEntry<InferEntityDTO<F>> | null\n}\n\n/**\n * Compare two versions and return field-level diff.\n *\n * Returns structured diffs with word-level segments for text fields\n * and structural block diffs for blocks fields.\n */\nexport async function compareVersions<F extends Record<string, FieldConfig>>(\n  ctx: ContentContext<F>,\n  entityId: string,\n  v1: number,\n  v2: number,\n  locale = DEFAULT_LOCALE_SENTINEL,\n): Promise<{\n  diffs: FieldDiff[]\n  fromVersion: VersionEntry<InferEntityDTO<F>>\n  toVersion: VersionEntry<InferEntityDTO<F>>\n} | null> {\n  validateLocale(locale)\n  const [version1, version2] = await Promise.all([\n    getVersion(ctx, entityId, v1, locale),\n    getVersion(ctx, entityId, v2, locale),\n  ])\n  if (!version1 || !version2) return null\n\n  const fieldConfigs = ctx.entity.allFields as Record<string, FieldConfig> | undefined\n  const diffs = diffFields(version1.data, version2.data, fieldConfigs)\n  for (const diff of diffs) {\n    if (diff.type === 'blockTree') {\n      // Normalize a null/undefined side to [] so add/clear of the whole field\n      // (null ↔ blockTree[]) still produces a structural diff, not an opaque one.\n      diff.blockDiffs = diffBlocks(\n        Array.isArray(diff.from) ? diff.from : [],\n        Array.isArray(diff.to) ? diff.to : [],\n      )\n    }\n  }\n  return { diffs, fromVersion: version1, toVersion: version2 }\n}\n\n/**\n * Restore an entity to a previous version. Replays the snapshot data\n * through the locale-routed writer, projected through `entity.allFields`\n * so forbidden fields (workflow internals, behavior-managed underscore\n * fields, fields the entity declared `internal: true`) cannot leak.\n *\n * Snapshots are locale-keyed; the restore reads the snapshot for the\n * given locale and writes it back to the same locale's home —\n * translations for non-default locales, the base row for the default.\n */\nexport async function restoreVersion<F extends Record<string, FieldConfig>>(\n  ctx: ContentContext<F>,\n  entityId: string,\n  version: number,\n  locale = DEFAULT_LOCALE_SENTINEL,\n): Promise<InferEntityDTO<F>> {\n  validateLocale(locale)\n  if (!(await getVersionsClient(ctx))) {\n    throw new EntityCapabilityError(ctx.entity.name, 'versions')\n  }\n  const versionData = await getVersion(ctx, entityId, version, locale)\n  if (!versionData) {\n    throw new VersionNotFoundError(entityId, version, locale)\n  }\n  const data = versionData.data as Record<string, unknown>\n  const updateData = projectToEntityFields(ctx.entity, data)\n  return applyLocaleRoutedUpdate(ctx, entityId, updateData, locale)\n}\n\n/**\n * Enforce maxPerDoc retention by deleting oldest versions for a locale.\n */\nexport async function pruneVersions(\n  ctx: ContentContext,\n  entityId: string,\n  locale = DEFAULT_LOCALE_SENTINEL,\n): Promise<void> {\n  validateLocale(locale)\n  if (!ctx.versionableOptions) return\n  const client = await getVersionsClient(ctx)\n  if (!client) return\n\n  const maxPerDoc = ctx.versionableOptions.maxPerDoc\n\n  // Get IDs of versions to keep (newest N for this locale). The findMany\n  // is capped at `limit: maxPerDoc`, so `keepVersions.length` is\n  // `min(totalRows, maxPerDoc)` — never larger than the limit.\n  const keepVersions = await client.findMany({\n    where: { entityId, locale },\n    orderBy: [{ column: 'version', dir: 'desc' }],\n    limit: maxPerDoc,\n  })\n\n  // Strictly under the limit ⇒ totalRows < maxPerDoc ⇒ nothing to prune.\n  // At the limit (length == maxPerDoc) we cannot distinguish \"exactly\n  // maxPerDoc\" from \"more than maxPerDoc\" without another count query,\n  // so we always run the DELETE — Postgres correctly removes 0-or-more\n  // older rows. Better one always-cheap DELETE per prune than a guard\n  // round trip on every call.\n  if (keepVersions.length < maxPerDoc) return\n\n  const keepIds = keepVersions.map((v) => v.id as string)\n\n  // Delete everything for this entity+locale NOT in the keep list.\n  await client.deleteMany({\n    entityId,\n    locale,\n    id: { notIn: keepIds },\n  })\n}\n\n/**\n * Persist a new version snapshot. Internal helper used by\n * `createVersionSnapshot` and ContentClient.update / .create.\n *\n * Attribution: ONLY the explicit `user` parameter is trusted. The\n * fallback chain that previously read `data.updatedBy` /\n * `data.createdBy` was an audit-log integrity gap (see audit\n * MEDIUM #1) — version history must never absorb a forged actor from\n * the request payload.\n */\nexport async function saveVersionSnapshot(\n  ctx: ContentContext,\n  entityId: string,\n  data: Record<string, unknown>,\n  delta: Record<string, unknown> | null,\n  isAutosave: boolean,\n  locale = DEFAULT_LOCALE_SENTINEL,\n  user?: { id: string; name?: string },\n): Promise<number | undefined> {\n  // All current callers pass a pre-validated locale (or the sentinel).\n  // Defensive check at the boundary so future callers — or anyone who\n  // exposes this helper publicly — still get the validation.\n  validateLocale(locale)\n  const client = await getVersionsClient(ctx)\n  if (!client) return\n\n  // Get the next version number for this locale (max existing + 1).\n  const [maxRow] = await client.aggregate<{ maxVersion: number | null }>({\n    select: { maxVersion: { fn: 'max', column: 'version' } },\n    where: { entityId, locale },\n  })\n  const version = Number(maxRow?.maxVersion ?? 0) + 1\n  const status = (data.status as string) ?? null\n\n  // Autosave: update the existing autosave row at the same version\n  // number, preserving \"autosaves land on the latest slot\" semantics.\n  if (isAutosave) {\n    const existing = await client.findOne({ entityId, isAutosave: true, version, locale })\n    if (existing) {\n      await client.update(\n        { id: existing.id as string },\n        { data, delta, status, createdAt: new Date() },\n      )\n      return version\n    }\n  }\n\n  await client.insert({\n    entityId,\n    version,\n    locale,\n    data,\n    delta,\n    status,\n    createdBy: user?.id ?? null,\n    createdByName: user?.name ?? null,\n    isAutosave,\n  })\n  return version\n}\n\n/**\n * Create a version snapshot for an entity after an external update.\n * Use this when the update was performed by AdminClient directly\n * (e.g. the admin API handler) rather than through ContentClient.update().\n *\n * @param locale - The locale being edited. Use undefined or '_' for the default locale.\n * @param user  - The user who made the change (id + name for display).\n */\nexport async function createVersionSnapshot(\n  ctx: ContentContext,\n  entityId: string,\n  currentData: Record<string, unknown>,\n  previousData?: Record<string, unknown> | null,\n  locale?: string,\n  user?: { id: string; name?: string },\n): Promise<void> {\n  if (locale !== undefined) validateLocale(locale)\n  if (!ctx.versionableOptions) return\n  const snapshotLocale = locale ?? DEFAULT_LOCALE_SENTINEL\n  const delta = previousData ? calculateDelta(previousData, currentData) : null\n  const version = await saveVersionSnapshot(\n    ctx,\n    entityId,\n    currentData,\n    delta,\n    false,\n    snapshotLocale,\n    user,\n  )\n\n  // Update _version on the entity to match (default locale only).\n  if (version !== undefined && snapshotLocale === DEFAULT_LOCALE_SENTINEL) {\n    await writeVersionColumn(ctx, entityId, version)\n  }\n\n  await pruneVersions(ctx, entityId, snapshotLocale)\n}\n\n/**\n * Write the `_version` column on the entity row.\n *\n * KNOWN EXCEPTION: this bypasses AdminClient and goes straight to the\n * entity pgTable via `schemaRegistry` + direct Drizzle. Using\n * `admin.update()` would retrigger the `versionable.beforeUpdate` hook\n * and loop indefinitely. The only ContentClient path that still writes\n * to an entity table directly.\n */\nexport async function writeVersionColumn(\n  ctx: ContentContext,\n  entityId: string,\n  version: number,\n): Promise<void> {\n  const table = schemaRegistry.get(ctx.entity.name)\n  if (!table) return\n  await ctx.db.update(table).set({ _version: version }).where(eq(table.id, entityId))\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@murumets-ee/content",
-  "version": "0.95.0",
+  "version": "0.97.0",
   "license": "Elastic-2.0",
   "type": "module",
   "exports": {
@@ -60,21 +60,21 @@
     "drizzle-orm": "^0.45.2",
     "server-only": "^0.0.1",
     "zod": "^3.24.1",
-    "@murumets-ee/blocks": "0.95.0",
-    "@murumets-ee/core": "0.95.0",
-    "@murumets-ee/db": "0.95.0",
-    "@murumets-ee/i18n": "0.95.0",
-    "@murumets-ee/entity": "0.95.0",
-    "@murumets-ee/logging": "0.95.0",
-    "@murumets-ee/queue": "0.95.0",
-    "@murumets-ee/settings": "0.95.0"
+    "@murumets-ee/blocks": "0.97.0",
+    "@murumets-ee/core": "0.97.0",
+    "@murumets-ee/db": "0.97.0",
+    "@murumets-ee/entity": "0.97.0",
+    "@murumets-ee/i18n": "0.97.0",
+    "@murumets-ee/logging": "0.97.0",
+    "@murumets-ee/queue": "0.97.0",
+    "@murumets-ee/settings": "0.97.0"
   },
   "devDependencies": {
     "@types/node": "^20.19.42",
     "tsdown": "^0.22.2",
     "typescript": "^5.7.3",
     "vitest": "^2.1.8",
-    "@murumets-ee/content-api": "0.95.0"
+    "@murumets-ee/content-api": "0.97.0"
   },
   "typeCoverage": {
     "atLeast": 99.48