@nonext/husk 0.2.3

package/dist/chunk-6E3ZS5Z5.js

@@ -0,0 +1,1007 @@
+import { fieldKeyState, slugFieldKey, normalizeLimit, buildRegistry, schemaVersionOf } from './chunk-JAE7HHMM.js';
+import { assertValidContentType } from './chunk-ROLKRJWI.js';
+import { RESERVED_FIELD_KEYS } from './chunk-SOTQ3WP5.js';
+import { can } from './chunk-NPDBQBLW.js';
+import { SchemaError, ValidationError, PermissionError, WriteLimitError } from './chunk-4Z6P3XCE.js';
+
+// src/core/cache-tags.ts
+var HUSK_TAG_PREFIX = "husk";
+var MAX_TAG_LENGTH = 256;
+function part(kind, value) {
+  if (value === "") {
+    throw new Error(`A cache tag needs ${kind}. An empty one would match everything.`);
+  }
+  if (value.includes(":")) {
+    throw new Error(
+      `The ${kind} in a cache tag may not contain ":", because that is the separator. Received "${value}".`
+    );
+  }
+  return value;
+}
+function tag(segments) {
+  const built = [HUSK_TAG_PREFIX, ...segments].join(":");
+  if (built.length > MAX_TAG_LENGTH) {
+    throw new Error(
+      `The cache tag "${built}" is ${String(built.length)} characters, over the ${String(MAX_TAG_LENGTH)} character limit. A tag that is rejected invalidates nothing, silently.`
+    );
+  }
+  return built;
+}
+function contentTypeTag(slug) {
+  return tag(["type", part("a content type slug", slug)]);
+}
+function entryTag(slug, entryId) {
+  return tag(["entry", part("a content type slug", slug), part("an entry id", entryId)]);
+}
+function entrySlugTag(slug, value) {
+  return tag(["slug", part("a content type slug", slug), part("a slug value", value)]);
+}
+function entryTags(slug, entryId) {
+  return [contentTypeTag(slug), entryTag(slug, entryId)];
+}
+function mediaTag(mediaId) {
+  return tag(["media", part("a media id", mediaId)]);
+}
+function settingsTag(key) {
+  return tag(["settings", part("a settings key", key)]);
+}
+function isHuskTag(value) {
+  return value.startsWith(`${HUSK_TAG_PREFIX}:`) && value.length <= MAX_TAG_LENGTH;
+}
+
+// src/core/entry-title.ts
+var UNTITLED_ENTRY = "Untitled";
+function entryTitle(type, entry) {
+  const key = type.titleField;
+  if (key === void 0) return UNTITLED_ENTRY;
+  const value = entry[key];
+  if (typeof value !== "string") return UNTITLED_ENTRY;
+  const trimmed = value.trim();
+  return trimmed === "" ? UNTITLED_ENTRY : trimmed;
+}
+
+// src/core/delete-confirmation.ts
+function deleteConfirmationName(type, entry) {
+  const title = entryTitle(type, entry);
+  return title === UNTITLED_ENTRY ? entry.id : title;
+}
+function deleteConfirmationPhrase(type, count) {
+  const noun = count === 1 ? type.label : type.labelPlural ?? `${type.label}s`;
+  return `${String(count)} ${noun.toLowerCase()}`;
+}
+function normalizeConfirmation(value) {
+  return value.normalize("NFC").replace(/\s+/gu, " ").trim();
+}
+function confirmationMatches(expected, typed) {
+  const target = normalizeConfirmation(expected);
+  if (target === "") return false;
+  return normalizeConfirmation(typed) === target;
+}
+
+// src/core/reorder.ts
+function moveItem(items, from, to) {
+  const next = [...items];
+  if (from === to) return next;
+  if (from < 0 || from >= next.length || to < 0 || to >= next.length) return next;
+  const [moved] = next.splice(from, 1);
+  if (moved === void 0) return [...items];
+  next.splice(to, 0, moved);
+  return next;
+}
+
+// src/core/schema-editor.ts
+function orderedFieldKeys(type) {
+  const declared = Array.isArray(type.fieldOrder) ? type.fieldOrder : [];
+  const ordered = [];
+  for (const key of declared) {
+    if (typeof key === "string" && key in type.fields && !ordered.includes(key)) {
+      ordered.push(key);
+    }
+  }
+  for (const key of Object.keys(type.fields)) {
+    if (!ordered.includes(key)) ordered.push(key);
+  }
+  return ordered;
+}
+function orderedFields(type) {
+  const rows = [];
+  for (const key of orderedFieldKeys(type)) {
+    const field = type.fields[key];
+    if (field !== void 0) rows.push({ key, field });
+  }
+  return rows;
+}
+function moveFieldRow(rows, from, to) {
+  return moveItem(rows, from, to);
+}
+function withFieldRows(type, rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const fields = {};
+  for (const row of rows) {
+    if (seen.has(row.key)) {
+      throw new SchemaError(
+        `Content type "${type.slug}" would have two fields called "${row.key}".`
+      );
+    }
+    seen.add(row.key);
+    fields[row.key] = row.field;
+  }
+  const next = {
+    ...type,
+    fields,
+    fieldOrder: rows.map((row) => row.key)
+  };
+  assertValidContentType(next);
+  return next;
+}
+function sameDefinition(left, right) {
+  return canonical(left) === canonical(right);
+}
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (typeof value === "object" && value !== null) {
+    return `{${Object.entries(value).filter(([, member]) => member !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, member]) => `${JSON.stringify(key)}:${canonical(member)}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+var FIELD_KEY_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var KEY_AVAILABLE = { available: true };
+function checkFieldKey(type, key) {
+  if (!FIELD_KEY_PATTERN.test(key)) {
+    return {
+      available: false,
+      reason: "invalid",
+      message: `"${key}" is not a valid field key. Use letters, digits and underscores, starting with a letter, for example "jobTitle".`
+    };
+  }
+  if (RESERVED_FIELD_KEYS.includes(key)) {
+    return {
+      available: false,
+      reason: "reserved",
+      message: `"${key}" is reserved for entry metadata. Reserved keys: ${RESERVED_FIELD_KEYS.join(", ")}.`
+    };
+  }
+  const state = fieldKeyState(type, key);
+  if (state === "live") {
+    return {
+      available: false,
+      reason: "live",
+      message: `"${key}" is already a field of this content type.`
+    };
+  }
+  if (state === "removed") {
+    return {
+      available: false,
+      reason: "removed",
+      message: `"${key}" was removed and its values are still stored. Restore it to get those values back, or purge them first.`
+    };
+  }
+  return KEY_AVAILABLE;
+}
+function checkNestedFieldKey(fields, key) {
+  if (!FIELD_KEY_PATTERN.test(key)) {
+    return {
+      available: false,
+      reason: "invalid",
+      message: `"${key}" is not a valid field key. Use letters, digits and underscores, starting with a letter.`
+    };
+  }
+  return key in fields ? { available: false, reason: "live", message: `"${key}" is already a field here.` } : KEY_AVAILABLE;
+}
+function suggestFieldKey(label) {
+  const words = label.normalize("NFKD").replace(/[^a-zA-Z0-9]+/g, " ").trim().split(/\s+/).filter((word) => word.length > 0);
+  const [first, ...rest] = words;
+  if (first === void 0) return "";
+  const key = first.toLowerCase() + rest.map((word) => `${(word[0] ?? "").toUpperCase()}${word.slice(1).toLowerCase()}`).join("");
+  return /^[0-9]/.test(key) ? `f${key}` : key;
+}
+function newFieldDefinition(registry, type, label) {
+  const spec = registry.require(type);
+  return { ...spec.editor.defaults, type, label };
+}
+function isBlank(value) {
+  if (value === void 0 || value === null) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+function fieldOptionIssues(registry, field) {
+  const spec = registry.get(field.type);
+  if (spec === void 0) return [];
+  const values = field;
+  return spec.editor.options.filter((option) => option.required === true && isBlank(values[option.key])).map((option) => ({
+    option: option.key,
+    message: `${option.label} is required for a ${field.type} field.`
+  }));
+}
+function draftIssues(registry, rows) {
+  return rows.flatMap(
+    (row) => fieldOptionIssues(registry, row.field).map((issue) => ({ key: row.key, ...issue }))
+  );
+}
+var VALIDATION_RULE_CONTROLS = {
+  required: {
+    label: "Required",
+    control: "boolean",
+    help: "An entry cannot be saved while this field is empty."
+  },
+  minLength: {
+    label: "Minimum length",
+    control: "number",
+    help: "Fewest characters allowed."
+  },
+  maxLength: {
+    label: "Maximum length",
+    control: "number",
+    help: "Most characters allowed."
+  },
+  min: { label: "Minimum", control: "number", help: "Smallest value allowed." },
+  max: { label: "Maximum", control: "number", help: "Largest value allowed." },
+  pattern: {
+    label: "Pattern",
+    control: "text",
+    help: "A regular expression the value must match."
+  },
+  unique: {
+    label: "Unique",
+    control: "boolean",
+    help: "No other entry of this content type may hold the same value."
+  }
+};
+function withValidationRule(field, rule, value) {
+  const { validation, ...rest } = field;
+  const next = { ...validation };
+  if (value === void 0 || value === "" || value === false) {
+    delete next[rule];
+  } else {
+    next[rule] = value;
+  }
+  return Object.keys(next).length === 0 ? rest : { ...rest, validation: next };
+}
+function withFieldOption(field, option, value) {
+  const next = { ...field };
+  if (value === void 0 || value === "") {
+    delete next[option];
+  } else {
+    next[option] = value;
+  }
+  return next;
+}
+
+// src/core/entry-form.ts
+function formFields(type) {
+  return orderedFields(type).filter(({ field }) => field.hidden !== true);
+}
+function initialFormValues(type, registry) {
+  const values = {};
+  for (const [key, field] of Object.entries(type.fields)) {
+    const spec = registry.get(field.type);
+    values[key] = spec === void 0 ? null : spec.defaultValue(field);
+  }
+  return values;
+}
+function formValuesFromEntry(type, entry, registry) {
+  const stored = entry;
+  const values = {};
+  for (const [key, field] of Object.entries(type.fields)) {
+    if (key in stored && stored[key] !== void 0) {
+      values[key] = stored[key];
+      continue;
+    }
+    const spec = registry.get(field.type);
+    values[key] = spec === void 0 ? null : spec.defaultValue(field);
+  }
+  return values;
+}
+function errorsUnder(errors, path) {
+  return errors.filter(
+    (error) => error.path === path || error.path.startsWith(`${path}.`)
+  );
+}
+function mergeIssues(client, server) {
+  const claimed = new Set(client.map((error) => error.path));
+  return [
+    ...client.map((error) => ({ ...error, origin: "client" })),
+    ...server.filter((error) => !claimed.has(error.path)).map((error) => ({ ...error, origin: "server" }))
+  ];
+}
+function unroutableIssues(issues, type) {
+  const rendered = new Set(formFields(type).map((entry) => entry.key));
+  return issues.filter((issue) => {
+    const root = issue.path.split(".")[0];
+    return root === void 0 || root === "" || !rendered.has(root);
+  });
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b)) return false;
+    return a.length === b.length && a.every((item, index) => deepEqual(item, b[index]));
+  }
+  const left = a;
+  const right = b;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
+  for (const key of keys) {
+    if (!deepEqual(left[key], right[key])) return false;
+  }
+  return true;
+}
+function valuesChanged(baseline, current) {
+  return !deepEqual(baseline, current);
+}
+function entryChangedSince(baseline, current) {
+  return baseline.updatedAt !== current.updatedAt;
+}
+
+// src/core/entry-status.ts
+var TRANSITIONS = {
+  draft: [
+    {
+      to: "published",
+      label: "Publish",
+      effect: "Makes this entry readable on the public site."
+    },
+    {
+      to: "archived",
+      label: "Archive",
+      effect: "Keeps the entry but takes it out of the public site."
+    }
+  ],
+  published: [
+    {
+      to: "draft",
+      label: "Unpublish",
+      effect: "Takes the entry off the public site and clears its publication date."
+    },
+    {
+      to: "archived",
+      label: "Archive",
+      effect: "Keeps the entry but takes it out of the public site."
+    }
+  ],
+  archived: [
+    {
+      to: "draft",
+      label: "Restore as draft",
+      effect: "Brings the entry back into editing. It stays off the public site."
+    },
+    {
+      to: "published",
+      label: "Publish",
+      effect: "Makes this entry readable on the public site again."
+    }
+  ]
+};
+var STATUS_EFFECT = {
+  draft: "Not visible on the public site.",
+  published: "Visible on the public site.",
+  archived: "Kept out of the public site and out of the way."
+};
+function statusTransitions(user, type, entry) {
+  const from = entry?.status ?? "draft";
+  const shapes = entry === null ? TRANSITIONS.draft.filter((shape) => shape.to === "published") : TRANSITIONS[from];
+  const allowed = entry === null ? can(user, "create", { type }) : can(user, "update", { type, entry: { createdBy: entry.createdBy } });
+  const reason = allowed ? null : denial(user, entry);
+  return shapes.map((shape) => ({ ...shape, allowed, reason }));
+}
+function denial(user, entry) {
+  if (user.role === "author" && entry !== null && entry.createdBy !== user.uid) {
+    return "An author can only change the status of their own entries.";
+  }
+  return "Your role cannot change the status of this entry.";
+}
+function canSaveEntry(user, type, entry) {
+  return entry === null ? can(user, "create", { type }) : can(user, "update", { type, entry: { createdBy: entry.createdBy } });
+}
+
+// src/core/entry-unique.ts
+function entryUniqueCheck(options) {
+  const { adapter, type, entryId } = options;
+  const key = slugFieldKey(type);
+  return async (path, value) => {
+    if (key === null || path !== key) {
+      throw new Error(
+        `Uniqueness of "${path}" cannot be checked from the form. The adapter checks it before the write.`
+      );
+    }
+    const found = await adapter.getBySlug(type.slug, value);
+    return found === null || found.id === entryId;
+  };
+}
+
+// src/core/error-taxonomy.ts
+var ERROR_CATEGORIES = [
+  "validation",
+  "permission",
+  "not-found",
+  "conflict",
+  "transport",
+  "unknown"
+];
+var TREATMENTS = {
+  validation: "field",
+  permission: "banner",
+  "not-found": "state",
+  conflict: "resolve",
+  transport: "retry",
+  unknown: "banner"
+};
+function treatmentFor(category) {
+  return TREATMENTS[category];
+}
+var TRANSPORT_CODES = [
+  "unavailable",
+  "deadline-exceeded",
+  "cancelled",
+  "internal",
+  "resource-exhausted"
+];
+var PERMISSION_CODES = ["permission-denied", "unauthenticated"];
+var NOT_FOUND_CODES = ["not-found"];
+var CONFLICT_CODES = [
+  "aborted",
+  "already-exists",
+  "failed-precondition"
+];
+function codeOf(thrown) {
+  if (typeof thrown !== "object" || thrown === null) return void 0;
+  const code = thrown.code;
+  if (typeof code !== "string") return void 0;
+  const slash = code.lastIndexOf("/");
+  return slash === -1 ? code : code.slice(slash + 1);
+}
+function looksLikeNetworkFailure(thrown) {
+  if (!(thrown instanceof Error)) return false;
+  return /network|fetch failed|failed to fetch|offline|connection/i.test(thrown.message);
+}
+function withRole(sentence, role) {
+  return role === void 0 ? sentence : `${sentence} You are signed in as ${role}.`;
+}
+function classifyError(thrown, context = {}) {
+  const target = context.subject === void 0 ? "" : ` "${context.subject}"`;
+  if (thrown instanceof ValidationError) {
+    return {
+      category: "validation",
+      treatment: TREATMENTS.validation,
+      title: thrown.errors.length === 1 ? "One field needs attention" : `${String(thrown.errors.length)} fields need attention`,
+      message: "The values were refused before anything was saved. Each problem is shown on the field it belongs to.",
+      fieldErrors: thrown.errors,
+      retryable: false,
+      cause: thrown
+    };
+  }
+  if (thrown instanceof PermissionError) {
+    return {
+      category: "permission",
+      treatment: TREATMENTS.permission,
+      title: "You are not allowed to do that",
+      // The brief for this category: say what is denied and by whom. PermissionError
+      // already carries the action and the content type; the role comes from the caller.
+      message: withRole(thrown.message, context.role),
+      fieldErrors: [],
+      retryable: false,
+      cause: thrown
+    };
+  }
+  if (thrown instanceof WriteLimitError) {
+    if (thrown.code === "too-fast") {
+      return {
+        category: "transport",
+        treatment: TREATMENTS.transport,
+        title: "Too many writes at once",
+        message: `${thrown.message} Wait a moment and try again.`,
+        fieldErrors: [],
+        retryable: true,
+        cause: thrown
+      };
+    }
+    return {
+      category: "validation",
+      treatment: TREATMENTS.validation,
+      title: "This is too large to save",
+      message: thrown.message,
+      fieldErrors: [{ path: thrown.path, rule: thrown.code, message: thrown.message }],
+      retryable: false,
+      cause: thrown
+    };
+  }
+  if (thrown instanceof SchemaError) {
+    return {
+      category: "validation",
+      treatment: TREATMENTS.validation,
+      title: "This definition was refused",
+      message: thrown.message,
+      fieldErrors: [],
+      retryable: false,
+      cause: thrown
+    };
+  }
+  const code = codeOf(thrown);
+  if (code !== void 0 && PERMISSION_CODES.includes(code)) {
+    return {
+      category: "permission",
+      treatment: TREATMENTS.permission,
+      title: "You are not allowed to do that",
+      message: withRole(
+        code === "unauthenticated" ? "Your session is no longer valid, so the database refused the request. Sign in again." : `The database refused this request${target}. Your account does not have permission for it.`,
+        context.role
+      ),
+      fieldErrors: [],
+      retryable: false,
+      cause: thrown
+    };
+  }
+  if (code !== void 0 && NOT_FOUND_CODES.includes(code)) {
+    return {
+      category: "not-found",
+      treatment: TREATMENTS["not-found"],
+      title: "Not found",
+      message: `What this page refers to${target} does not exist. It may have been deleted, or the address may be wrong.`,
+      fieldErrors: [],
+      retryable: false,
+      cause: thrown
+    };
+  }
+  if (code !== void 0 && CONFLICT_CODES.includes(code)) {
+    return {
+      category: "conflict",
+      treatment: TREATMENTS.conflict,
+      title: "This changed somewhere else",
+      message: "Someone else wrote to this while you were working on it, so nothing was saved. Reload to see their version, or save again to overwrite it.",
+      fieldErrors: [],
+      retryable: false,
+      cause: thrown
+    };
+  }
+  if (code !== void 0 && TRANSPORT_CODES.includes(code) || looksLikeNetworkFailure(thrown)) {
+    return {
+      category: "transport",
+      treatment: TREATMENTS.transport,
+      title: "Could not reach the database",
+      message: `The request did not get through${context.action === void 0 ? "" : `, so nothing was changed while trying to ${context.action}`}. Check your connection and try again.`,
+      fieldErrors: [],
+      retryable: true,
+      cause: thrown
+    };
+  }
+  return {
+    category: "unknown",
+    treatment: TREATMENTS.unknown,
+    title: context.action === void 0 ? "Something went wrong" : `Could not ${context.action}`,
+    message: thrown instanceof Error && thrown.message !== "" ? thrown.message : "No further detail was reported. Nothing is known to have changed.",
+    fieldErrors: [],
+    retryable: false,
+    cause: thrown
+  };
+}
+function staleWriteError(subject) {
+  return {
+    category: "conflict",
+    treatment: TREATMENTS.conflict,
+    title: "Someone else saved this first",
+    message: `${subject} was changed after you opened it. Reload to see their version, or save again to overwrite it with yours.`,
+    fieldErrors: [],
+    retryable: false,
+    cause: null
+  };
+}
+function missingError(subject) {
+  return {
+    category: "not-found",
+    treatment: TREATMENTS["not-found"],
+    title: `This ${subject} no longer exists`,
+    message: "It was deleted, or the address points at something this project does not hold. Nothing was changed.",
+    fieldErrors: [],
+    retryable: false,
+    cause: null
+  };
+}
+function deniedError(what, role) {
+  return {
+    category: "permission",
+    treatment: TREATMENTS.permission,
+    title: "You are not allowed to do that",
+    message: withRole(`Your account may not ${what}.`, role),
+    fieldErrors: [],
+    retryable: false,
+    cause: null
+  };
+}
+
+// src/core/list-view.ts
+var COLUMN_ALIGN = {
+  text: "text",
+  textarea: "none",
+  number: "numeric",
+  boolean: "text",
+  select: "text",
+  date: "date",
+  slug: "text",
+  richtext: "none",
+  image: "none",
+  file: "none",
+  relation: "none",
+  repeater: "none"
+};
+var FILTERABLE = ["select", "boolean"];
+var FALLBACK_SORT = { field: "updatedAt", direction: "desc" };
+function defaultListSort(type) {
+  return type.defaultSort === void 0 ? FALLBACK_SORT : { field: type.defaultSort.field, direction: type.defaultSort.direction };
+}
+function initialListState(type) {
+  return {
+    search: "",
+    status: "any",
+    filters: {},
+    sort: defaultListSort(type),
+    cursor: null
+  };
+}
+function canSearch(type) {
+  return type.titleField !== void 0;
+}
+function isSearching(state) {
+  return state.search.trim() !== "";
+}
+function sortableFieldKeys(type) {
+  const keys = /* @__PURE__ */ new Set();
+  if (type.titleField !== void 0) keys.add(type.titleField);
+  if (type.defaultSort !== void 0) keys.add(type.defaultSort.field);
+  keys.add("updatedAt");
+  return [...keys];
+}
+var MAX_FIELD_COLUMNS = 2;
+function listColumns(type, { maxFieldColumns = MAX_FIELD_COLUMNS } = {}) {
+  const sortable = new Set(sortableFieldKeys(type));
+  const titleKey = type.titleField;
+  const titleField = titleKey === void 0 ? void 0 : type.fields[titleKey];
+  const columns = [
+    {
+      key: titleKey ?? "title",
+      label: titleField?.label ?? "Title",
+      kind: "title",
+      align: "text",
+      sortable: titleKey !== void 0 && sortable.has(titleKey)
+    }
+  ];
+  for (const { key, field } of orderedFields(type)) {
+    if (columns.length > maxFieldColumns) break;
+    if (key === titleKey || field.hidden === true) continue;
+    const align = COLUMN_ALIGN[field.type];
+    if (align === "none") continue;
+    columns.push({
+      key,
+      label: field.label,
+      kind: "field",
+      align,
+      sortable: sortable.has(key)
+    });
+  }
+  columns.push(
+    { key: "status", label: "Status", kind: "status", align: "text", sortable: false },
+    {
+      key: "updatedAt",
+      label: "Updated",
+      kind: "updated",
+      align: "date",
+      sortable: true
+    }
+  );
+  return columns;
+}
+function isFilterableField(field) {
+  return FILTERABLE.includes(field.type);
+}
+function listFilters(type) {
+  const descriptors = [];
+  for (const { key, field } of orderedFields(type)) {
+    if (field.hidden === true || !isFilterableField(field)) continue;
+    if (field.type === "select") {
+      descriptors.push({
+        key,
+        label: field.label,
+        options: field.options.map((option) => ({
+          value: option.value,
+          label: option.label
+        })),
+        // A multi-select stores an array, so equality would only match an entry whose
+        // whole array is that one value.
+        op: field.multiple === true ? "array-contains" : "==",
+        valueType: "string"
+      });
+      continue;
+    }
+    descriptors.push({
+      key,
+      label: field.label,
+      options: [
+        { value: "true", label: "Yes" },
+        { value: "false", label: "No" }
+      ],
+      op: "==",
+      valueType: "boolean"
+    });
+  }
+  return descriptors;
+}
+function listFilterQuery(type, filters) {
+  const active = [];
+  for (const descriptor of listFilters(type)) {
+    const chosen = filters[descriptor.key];
+    if (chosen === void 0 || chosen === "") continue;
+    if (!descriptor.options.some((option) => option.value === chosen)) continue;
+    active.push({
+      field: descriptor.key,
+      op: descriptor.op,
+      value: descriptor.valueType === "boolean" ? chosen === "true" : chosen
+    });
+  }
+  return active;
+}
+function buildListQuery(type, state, { pageSize } = {}) {
+  const term = state.search.trim();
+  const searching = term !== "" && canSearch(type);
+  return {
+    filters: listFilterQuery(type, state.filters),
+    ...searching ? { search: term } : { sort: state.sort },
+    limit: normalizeLimit(pageSize),
+    cursor: state.cursor,
+    status: state.status
+  };
+}
+function buildCountQuery(type, state) {
+  const term = state.search.trim();
+  return {
+    filters: listFilterQuery(type, state.filters),
+    status: state.status,
+    ...term !== "" && canSearch(type) ? { search: term } : {}
+  };
+}
+function isNarrowed(state) {
+  return isSearching(state) || state.status !== "any" || Object.values(state.filters).some((value) => value !== "");
+}
+function nextSort(current, column, key = column.key) {
+  if (current.field === key) {
+    return { field: key, direction: current.direction === "asc" ? "desc" : "asc" };
+  }
+  return { field: key, direction: column.align === "date" ? "desc" : "asc" };
+}
+
+// src/core/indexes.ts
+var ENTRY_COLLECTION_GROUP = "entries";
+var MAX_ENTRY_INDEXES = 200;
+function order(direction) {
+  return direction === "asc" ? "ASCENDING" : "DESCENDING";
+}
+function subsets(keys) {
+  return keys.reduce(
+    (found, key) => [...found, ...found.map((subset) => [...subset, key])],
+    [[]]
+  );
+}
+function filterableKeys(type) {
+  return Object.entries(type.fields).filter(([, field]) => field.hidden !== true && isFilterableField(field)).map(([key]) => key);
+}
+function keyOf(index) {
+  return index.fields.map((field) => `${field.fieldPath}:${field.order}`).join("|");
+}
+function requiredEntryIndexes(types) {
+  const found = /* @__PURE__ */ new Map();
+  for (const type of types) {
+    if (type.kind !== "collection") continue;
+    for (const filters of subsets(filterableKeys(type))) {
+      for (const sortField of sortableFieldKeys(type)) {
+        for (const direction of ["asc", "desc"]) {
+          for (const withStatus of [true, false]) {
+            if (!withStatus && filters.length === 0) continue;
+            if (filters.includes(sortField)) continue;
+            const index = {
+              collectionGroup: ENTRY_COLLECTION_GROUP,
+              queryScope: "COLLECTION",
+              fields: [
+                ...withStatus ? [{ fieldPath: "status", order: "ASCENDING" }] : [],
+                ...filters.map((key) => ({
+                  fieldPath: key,
+                  order: "ASCENDING"
+                })),
+                { fieldPath: sortField, order: order(direction) },
+                { fieldPath: "__name__", order: order(direction) }
+              ]
+            };
+            found.set(keyOf(index), index);
+          }
+        }
+      }
+    }
+  }
+  const indexes = [...found.values()].sort(
+    (left, right) => keyOf(left).localeCompare(keyOf(right))
+  );
+  if (indexes.length > MAX_ENTRY_INDEXES) {
+    throw new SchemaError(
+      `These content types need ${indexes.length} composite indexes on "entries", and Firestore allows ${MAX_ENTRY_INDEXES} per database. Reduce the number of filterable fields or sort fields.`
+    );
+  }
+  return indexes;
+}
+function indexCovered(file, required) {
+  return (file.indexes ?? []).some(
+    (candidate) => candidate.collectionGroup === required.collectionGroup && keyOf(candidate) === keyOf(required)
+  );
+}
+function missingEntryIndexes(file, types) {
+  return requiredEntryIndexes(types).filter((required) => !indexCovered(file, required));
+}
+
+// src/core/registry-store.ts
+function fingerprint(types) {
+  return JSON.stringify(
+    [...types].sort((left, right) => left.slug.localeCompare(right.slug))
+  );
+}
+function createRegistryStore(code, initialDatabase = []) {
+  let database = [...initialDatabase];
+  let signature = fingerprint(database);
+  let registry = buildRegistry(code, database);
+  let revision = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    get registry() {
+      return registry;
+    },
+    get revision() {
+      return revision;
+    },
+    setDatabaseTypes(types) {
+      const next = fingerprint(types);
+      if (next === signature) return false;
+      database = [...types];
+      signature = next;
+      registry = buildRegistry(code, database);
+      revision += 1;
+      for (const listener of listeners) listener(registry);
+      return true;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+
+// src/core/migrations.ts
+function createMigrationRegistry(migrations) {
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const migration of migrations) {
+    if (migration.to !== migration.from + 1) {
+      throw new SchemaError(
+        `Migration "${migration.slug}" ${String(migration.from)} to ${String(migration.to)} is not a single step. A migration moves an entry one version forward.`
+      );
+    }
+    if (migration.from < 1) {
+      throw new SchemaError(
+        `Migration "${migration.slug}" starts at version ${String(migration.from)}. The first stored version is 1.`
+      );
+    }
+    const found = bySlug.get(migration.slug) ?? [];
+    if (found.some((candidate) => candidate.from === migration.from)) {
+      throw new SchemaError(
+        `Two migrations of "${migration.slug}" both start at version ${String(migration.from)}.`
+      );
+    }
+    found.push(migration);
+    bySlug.set(migration.slug, found);
+  }
+  for (const found of bySlug.values()) found.sort((left, right) => left.from - right.from);
+  return {
+    forType(slug) {
+      return bySlug.get(slug) ?? [];
+    },
+    plan(type, fromVersion) {
+      const target = schemaVersionOf(type);
+      if (fromVersion >= target) return [];
+      const steps = [];
+      const available = bySlug.get(type.slug) ?? [];
+      for (let version = fromVersion; version < target; version += 1) {
+        const step = available.find((candidate) => candidate.from === version);
+        if (step !== void 0) steps.push(step);
+      }
+      return steps;
+    }
+  };
+}
+function applyPlan(plan, values, context) {
+  return plan.reduce(
+    (current, step) => step.migrate(current, { ...context, fromVersion: step.from }),
+    values
+  );
+}
+var MIGRATION_BATCH_SIZE = 50;
+var MIGRATION_MAX_BATCHES = 20;
+async function runMigration(deps, options = {}) {
+  const { migrations, registry, type } = deps;
+  const target = schemaVersionOf(type);
+  const batchSize = Math.min(
+    Math.max(Math.trunc(options.batchSize ?? MIGRATION_BATCH_SIZE), 1),
+    MIGRATION_BATCH_SIZE
+  );
+  const maxBatches = Math.max(Math.trunc(options.maxBatches ?? MIGRATION_MAX_BATCHES), 1);
+  const failed = [];
+  let scanned = 0;
+  let migrated = 0;
+  let skipped = 0;
+  let remaining = false;
+  for (let batch = 0; batch < maxBatches; batch += 1) {
+    const page = await migrations.listBehind(type.slug, target, { limit: batchSize });
+    if (page.items.length === 0) break;
+    let progressed = false;
+    for (const record of page.items) {
+      scanned += 1;
+      const outcome = await migrateOne(migrations, registry, type, target, record);
+      if (outcome === "migrated") {
+        migrated += 1;
+        progressed = true;
+      } else if (outcome === "skipped") {
+        skipped += 1;
+        progressed = true;
+      } else {
+        failed.push(outcome);
+      }
+    }
+    options.onProgress?.({ scanned, migrated });
+    if (!progressed) {
+      remaining = true;
+      break;
+    }
+    if (failed.length > 0) break;
+    if (page.hasMore && batch === maxBatches - 1) remaining = true;
+  }
+  if (failed.length > 0) remaining = true;
+  return {
+    slug: type.slug,
+    targetVersion: target,
+    scanned,
+    migrated,
+    skipped,
+    failed,
+    remaining
+  };
+}
+async function migrateOne(migrations, registry, type, target, record) {
+  try {
+    const plan = registry.plan(type, record.schemaVersion);
+    if (plan.length === 0) {
+      const stamped = await migrations.applyMigration(
+        type.slug,
+        record.id,
+        record.values,
+        {
+          expectedVersion: record.schemaVersion,
+          nextVersion: target
+        }
+      );
+      return stamped ? "migrated" : "skipped";
+    }
+    const values = applyPlan(plan, record.values, { entryId: record.id, slug: type.slug });
+    const written = await migrations.applyMigration(type.slug, record.id, values, {
+      expectedVersion: record.schemaVersion,
+      nextVersion: target
+    });
+    return written ? "migrated" : "skipped";
+  } catch (thrown) {
+    return {
+      entryId: record.id,
+      fromVersion: record.schemaVersion,
+      reason: thrown instanceof Error ? thrown.message : String(thrown)
+    };
+  }
+}
+
+export { ENTRY_COLLECTION_GROUP, ERROR_CATEGORIES, FALLBACK_SORT, HUSK_TAG_PREFIX, MAX_ENTRY_INDEXES, MAX_FIELD_COLUMNS, MIGRATION_BATCH_SIZE, MIGRATION_MAX_BATCHES, STATUS_EFFECT, UNTITLED_ENTRY, VALIDATION_RULE_CONTROLS, applyPlan, buildCountQuery, buildListQuery, canSaveEntry, canSearch, checkFieldKey, checkNestedFieldKey, classifyError, confirmationMatches, contentTypeTag, createMigrationRegistry, createRegistryStore, defaultListSort, deleteConfirmationName, deleteConfirmationPhrase, deniedError, draftIssues, entryChangedSince, entrySlugTag, entryTag, entryTags, entryTitle, entryUniqueCheck, errorsUnder, fieldOptionIssues, formFields, formValuesFromEntry, indexCovered, initialFormValues, initialListState, isFilterableField, isHuskTag, isNarrowed, isSearching, listColumns, listFilterQuery, listFilters, mediaTag, mergeIssues, missingEntryIndexes, missingError, moveFieldRow, moveItem, newFieldDefinition, nextSort, normalizeConfirmation, orderedFieldKeys, orderedFields, requiredEntryIndexes, runMigration, sameDefinition, settingsTag, sortableFieldKeys, staleWriteError, statusTransitions, suggestFieldKey, treatmentFor, unroutableIssues, valuesChanged, withFieldOption, withFieldRows, withValidationRule };
+//# sourceMappingURL=chunk-6E3ZS5Z5.js.map
+//# sourceMappingURL=chunk-6E3ZS5Z5.js.map