@nonext/husk 0.2.3

package/dist/firebase/index.js

@@ -0,0 +1,991 @@
+import { validateEntry, uniqueFieldPaths } from '../chunk-FHYWJCG6.js';
+import { ENTRY_STATUSES } from '../chunk-ORMYARXD.js';
+import { entryPath, metaFromStored, entryFromStored, storageObjectPath, entriesPath, valuesToStored, ENTRIES, MEDIA, mediaPath, schemaPath, contentPath, SCHEMAS, BOOTSTRAP_KEY, settingsPath, toIso } from '../chunk-ZYNBMYJ6.js';
+export { AuthError, ClaimSyncError, createEmulatorClaimSync, createHuskAuth, createUnavailableClaimSync, patchUser, readUser, toAuthUser, writeUser } from '../chunk-ZYNBMYJ6.js';
+import { createWriteRateLimiter, slugFieldKey, normalizeLimit, safeFileName, MEDIA_REFS_KEY, collectMediaIds, retargetMediaUrls, MEDIA_USAGE_LIMIT, nextSchemaVersion, schemaVersionOf, MAX_FIELD_PURGE, checkWritePayload, MAX_ENTRY_FIELDS, checkMediaFile, normalizeMediaType, assertSchemaWritable, MAX_CONTENT_TYPE_FIELDS, mediaTypeRule, MAX_SETTINGS_FIELDS } from '../chunk-JAE7HHMM.js';
+import { assertValidContentType, assertTypeSlugAvailable } from '../chunk-ROLKRJWI.js';
+import '../chunk-SOTQ3WP5.js';
+import { assertDeletable, assertSingletonEntryId, isSingleton, singletonEntryId, assertSingletonCreatable, assertListable } from '../chunk-R4O7APIX.js';
+import { normalizePermissionMatrix } from '../chunk-TCFFHTY3.js';
+import { can, resolveDecision } from '../chunk-NPDBQBLW.js';
+import '../chunk-TS7Y7GEZ.js';
+import { SchemaError, PermissionError, ValidationError, WriteLimitError } from '../chunk-4Z6P3XCE.js';
+import { where, getCountFromServer, query, doc, getDoc, deleteDoc, limit, getDocs, startAfter, collection, orderBy, setDoc, serverTimestamp, updateDoc, collectionGroup, getAggregateFromServer, sum, count, onSnapshot, writeBatch, deleteField, runTransaction } from 'firebase/firestore';
+import { deleteObject, ref, uploadBytesResumable, getDownloadURL } from 'firebase/storage';
+
+var MAX_MEDIA_REFRESH = 500;
+var DEFAULT_SORT = { field: "updatedAt", direction: "desc" };
+var PREFIX_END = "\uF8FF";
+function searchRange(type, search) {
+  const term = (search ?? "").trim();
+  if (term === "") return null;
+  const field = type.titleField;
+  if (field === void 0) {
+    throw new SchemaError(
+      `Content type "${type.slug}" has no title field, so its entries cannot be searched.`
+    );
+  }
+  return { field, term };
+}
+function assertTopLevelKey(slug, key) {
+  if (key.includes(".") || key.length === 0) {
+    throw new SchemaError(
+      `Field key "${key}" of content type "${slug}" is not a top-level field. The values of a field nested inside a repeater are counted and purged with its row, not on their own.`
+    );
+  }
+}
+function fieldError(path, rule, message) {
+  return { path, rule, message };
+}
+function createFirestoreAdapter(deps) {
+  const { db, registry, currentUser, fieldTypes } = deps;
+  const limiter = deps.rateLimiter === void 0 ? createWriteRateLimiter() : deps.rateLimiter;
+  function resolveType(slug) {
+    return registry().require(slug).type;
+  }
+  function assertCan(user, action, context = {}) {
+    if (can(user, action, context)) return;
+    throw new PermissionError(action, context.type?.slug);
+  }
+  function assertNotDenied(user, action, type) {
+    if (user.role === "admin") return;
+    if (resolveDecision(user.role, action, type) !== "deny") return;
+    throw new PermissionError(action, type.slug);
+  }
+  function assertCanRead(type) {
+    const user = deps.session?.() ?? null;
+    if (user === null) return;
+    assertCan(user, "read", { type });
+  }
+  function refuse(rejection) {
+    if (rejection !== null) throw new WriteLimitError(rejection);
+  }
+  function guardWrite(values, maxFields) {
+    refuse(checkWritePayload(values, { maxFields }));
+    if (limiter !== null) refuse(limiter.check());
+  }
+  function guardSchemaWrite(type) {
+    guardWrite(type.fields, MAX_CONTENT_TYPE_FIELDS);
+  }
+  function assertMediaInput(input, mediaId) {
+    const rejection = checkMediaFile({
+      name: input.name,
+      type: input.type,
+      size: input.size
+    });
+    if (rejection !== null) {
+      throw new ValidationError([fieldError("file", rejection.code, rejection.message)]);
+    }
+    if (!input.path.startsWith(`${MEDIA}/${mediaId}/`)) {
+      throw new ValidationError([
+        fieldError(
+          "path",
+          "media-path",
+          `A media object path must start with "${MEDIA}/${mediaId}/", and "${input.path}" does not.`
+        )
+      ]);
+    }
+    if (input.url.trim() === "") {
+      throw new ValidationError([
+        fieldError("url", "required", "A media document needs a download url.")
+      ]);
+    }
+  }
+  function withNormalizedMatrix(type) {
+    const matrix = normalizePermissionMatrix(type.permissions);
+    const { permissions: _dropped, ...rest } = type;
+    return matrix === void 0 ? rest : { ...rest, permissions: matrix };
+  }
+  function assertStatus(status) {
+    if (!ENTRY_STATUSES.includes(status)) {
+      throw new SchemaError(
+        `Entry status "${status}" is not one of: ${ENTRY_STATUSES.join(", ")}.`
+      );
+    }
+  }
+  function entriesCollection(slug) {
+    return collection(db, entriesPath(slug));
+  }
+  async function snapshotFor(slug, entryId) {
+    return getDoc(doc(db, entryPath(slug, entryId)));
+  }
+  function toEntry(type, snapshot) {
+    return entryFromStored(type, snapshot.id, snapshot.data(), fieldTypes);
+  }
+  function constraintsFor(type, listQuery) {
+    const constraints = [];
+    const status = listQuery.status ?? "any";
+    if (status !== "any") {
+      constraints.push(where("status", "==", status));
+    }
+    for (const filter of listQuery.filters ?? []) {
+      constraints.push(where(filter.field, filter.op, filter.value));
+    }
+    const range = searchRange(type, listQuery.search);
+    if (range !== null) {
+      constraints.push(where(range.field, ">=", range.term));
+      constraints.push(where(range.field, "<=", `${range.term}${PREFIX_END}`));
+    }
+    const sort = range === null ? listQuery.sort ?? DEFAULT_SORT : { field: range.field, direction: "asc" };
+    constraints.push(orderBy(sort.field, sort.direction));
+    if (sort.field !== "__name__") {
+      constraints.push(orderBy("__name__", sort.direction));
+    }
+    return constraints;
+  }
+  async function assertUnique(type, values, selfId) {
+    const keys = uniqueFieldPaths(type);
+    if (keys.length === 0) return;
+    const errors = [];
+    for (const key of keys) {
+      const value = values[key];
+      if (value === null || value === void 0 || value === "") continue;
+      const found = await getDocs(
+        query(entriesCollection(type.slug), where(key, "==", value), limit(2))
+      );
+      const taken = found.docs.some((candidate) => candidate.id !== selfId);
+      if (taken) {
+        const label = type.fields[key]?.label ?? key;
+        errors.push(
+          fieldError(
+            key,
+            "unique",
+            `${label} must be unique, and "${String(value)}" is taken.`
+          )
+        );
+      }
+    }
+    if (errors.length > 0) throw new ValidationError(errors);
+  }
+  async function ensureContentDoc(type) {
+    const reference = doc(db, contentPath(type.slug));
+    const stored = await getDoc(reference);
+    const matrix = normalizePermissionMatrix(type.permissions);
+    if (stored.exists()) {
+      await syncContentMeta(reference, stored.data(), type, matrix);
+      return;
+    }
+    try {
+      await setDoc(reference, {
+        slug: type.slug,
+        kind: type.kind,
+        locked: type.locked ?? false,
+        schemaVersion: type.schemaVersion ?? 1,
+        // The rules read the matrix from here, not from `schemas/{slug}`, because a
+        // code-defined type has no document under `schemas/` at all and its matrix still
+        // has to reach the rules. Stored as an empty map rather than omitted so the two
+        // states a rule can see, "not narrowed" and "narrowed to nobody", stay distinct.
+        permissions: matrix ?? {},
+        updatedAt: serverTimestamp()
+      });
+    } catch (thrown) {
+      if (thrown.code !== "permission-denied") throw thrown;
+    }
+  }
+  async function syncContentMeta(reference, stored, type, matrix) {
+    const next = matrix ?? {};
+    if (sameMatrix(stored["permissions"], next)) return;
+    try {
+      await updateDoc(reference, { permissions: next, updatedAt: serverTimestamp() });
+    } catch (thrown) {
+      if (thrown.code !== "permission-denied") throw thrown;
+    }
+  }
+  async function writeEntry(type, entryId, input, mode) {
+    const status = input.status ?? "draft";
+    const user = currentUser();
+    const reference = doc(db, entryPath(type.slug, entryId));
+    if (mode === "update") assertNotDenied(user, "update", type);
+    const existing = mode === "update" ? await getDoc(reference) : null;
+    if (mode === "create") {
+      assertCan(user, "create", { type });
+    } else {
+      const owner = existing?.exists() === true ? metaFromStored(entryId, existing.data()) : void 0;
+      assertCan(user, "update", {
+        type,
+        ...owner === void 0 ? {} : { entry: { createdBy: owner.createdBy } }
+      });
+    }
+    assertStatus(status);
+    guardWrite(input.values, MAX_ENTRY_FIELDS);
+    const errors = validateEntry(type, input.values, {
+      skipRequired: status === "draft",
+      ...fieldTypes === void 0 ? {} : { fieldTypes }
+    });
+    if (errors.length > 0) throw new ValidationError(errors);
+    await assertUnique(type, input.values, mode === "update" ? entryId : null);
+    const stored = valuesToStored(type.fields, input.values, fieldTypes);
+    const mediaRefs = { [MEDIA_REFS_KEY]: collectMediaIds(stored) };
+    if (mode === "create") {
+      await ensureContentDoc(type);
+      await setDoc(reference, {
+        ...stored,
+        ...mediaRefs,
+        status,
+        schemaVersion: type.schemaVersion ?? 1,
+        createdAt: serverTimestamp(),
+        createdBy: user.uid,
+        updatedAt: serverTimestamp(),
+        updatedBy: user.uid,
+        publishedAt: status === "published" ? serverTimestamp() : null
+      });
+    } else {
+      if (existing === null || !existing.exists()) {
+        throw new SchemaError(
+          `Entry "${entryId}" of content type "${type.slug}" does not exist.`
+        );
+      }
+      const previous = metaFromStored(entryId, existing.data());
+      await updateDoc(reference, {
+        ...stored,
+        ...mediaRefs,
+        status,
+        schemaVersion: type.schemaVersion ?? 1,
+        updatedAt: serverTimestamp(),
+        updatedBy: user.uid,
+        // First publish stamps the date; republishing keeps the original, and unpublishing
+        // clears it, so publishedAt always answers "since when has this been public".
+        publishedAt: status === "published" ? previous.publishedAt ?? serverTimestamp() : status === "draft" ? null : previous.publishedAt
+      });
+    }
+    const written = await getDoc(reference);
+    return entryFromStored(type, entryId, written.data() ?? {}, fieldTypes);
+  }
+  function usageTitle(slug, data) {
+    let titleField;
+    try {
+      titleField = resolveType(slug).titleField;
+    } catch {
+      return null;
+    }
+    if (titleField === void 0) return null;
+    const value = data[titleField];
+    if (typeof value !== "string" || value.trim() === "") return null;
+    return value.trim();
+  }
+  const media = {
+    async list(mediaQuery = {}) {
+      const size = normalizeLimit(mediaQuery.limit);
+      const constraints = [];
+      if (mediaQuery.type !== void 0) {
+        constraints.push(where("type", ">=", mediaQuery.type));
+        constraints.push(where("type", "<", `${mediaQuery.type}\uF8FF`));
+        constraints.push(orderBy("type", "asc"));
+      }
+      constraints.push(orderBy("createdAt", "desc"), orderBy("__name__", "desc"));
+      if (mediaQuery.cursor) {
+        const anchor = await getDoc(doc(db, mediaPath(mediaQuery.cursor)));
+        if (anchor.exists()) constraints.push(startAfter(anchor));
+      }
+      constraints.push(limit(size + 1));
+      const found = await getDocs(query(collection(db, MEDIA), ...constraints));
+      const docs = found.docs.slice(0, size);
+      return {
+        items: docs.map((snapshot) => mediaFromStored(snapshot.id, snapshot.data())),
+        cursor: found.docs.length > size ? docs.at(-1)?.id ?? null : null,
+        hasMore: found.docs.length > size
+      };
+    },
+    async getById(mediaId) {
+      const snapshot = await getDoc(doc(db, mediaPath(mediaId)));
+      return snapshot.exists() ? mediaFromStored(snapshot.id, snapshot.data()) : null;
+    },
+    async getMany(mediaIds) {
+      const found = await Promise.all(mediaIds.map((mediaId) => media.getById(mediaId)));
+      return found.filter((item) => item !== null);
+    },
+    reserveId() {
+      return doc(collection(db, MEDIA)).id;
+    },
+    async create(input, mediaId) {
+      const reference = mediaId === void 0 ? doc(collection(db, MEDIA)) : doc(db, mediaPath(mediaId));
+      const user = currentUser();
+      assertMediaInput(input, reference.id);
+      if (limiter !== null) refuse(limiter.check());
+      await setDoc(reference, {
+        name: input.name,
+        type: input.type,
+        size: input.size,
+        url: input.url,
+        path: input.path,
+        alt: input.alt ?? null,
+        width: input.width ?? null,
+        height: input.height ?? null,
+        createdAt: serverTimestamp(),
+        createdBy: user.uid
+      });
+      const written = await getDoc(reference);
+      return mediaFromStored(reference.id, written.data() ?? {});
+    },
+    async update(mediaId, patch) {
+      const reference = doc(db, mediaPath(mediaId));
+      const current = await media.getById(mediaId);
+      if (current === null) {
+        throw new SchemaError(`Media item "${mediaId}" does not exist.`);
+      }
+      assertMediaInput({ ...current, ...patch }, mediaId);
+      if (limiter !== null) refuse(limiter.check());
+      await updateDoc(reference, { ...patch });
+      const written = await getDoc(reference);
+      return mediaFromStored(mediaId, written.data() ?? {});
+    },
+    async delete(mediaId) {
+      await deleteDoc(doc(db, mediaPath(mediaId)));
+    },
+    async usage() {
+      const snapshot = await getAggregateFromServer(collection(db, MEDIA), {
+        count: count(),
+        bytes: sum("size")
+      });
+      const data = snapshot.data();
+      return { count: data.count, bytes: data.bytes };
+    },
+    /**
+     * Entries referencing this media item, from the reverse index.
+     *
+     * One collection-group query over `entries`, answered by the automatic single-field
+     * index on the `mediaRefs` array. The cost is the number of referencing entries, not
+     * the size of the database, which is the whole reason the index is written: the
+     * alternative was reading every entry of every content type on every delete.
+     *
+     * The blind spot is named rather than hidden: an entry written before the index
+     * existed, or written straight into the console, has no `mediaRefs` field and does not
+     * appear here until it is saved once. See core/media-references.ts.
+     */
+    async usages(mediaId, usageQuery = {}) {
+      const size = normalizeLimit(usageQuery.limit ?? MEDIA_USAGE_LIMIT);
+      const found = await getDocs(
+        query(
+          collectionGroup(db, ENTRIES),
+          where(MEDIA_REFS_KEY, "array-contains", mediaId),
+          limit(size)
+        )
+      );
+      return found.docs.map((snapshot) => {
+        const contentType = snapshot.ref.parent.parent?.id ?? "";
+        return {
+          contentType,
+          entryId: snapshot.id,
+          title: usageTitle(contentType, snapshot.data())
+        };
+      });
+    },
+    /**
+     * Points every referencing entry at the new url after a replace.
+     *
+     * Best effort by construction. Each entry is its own write, an author may hold no
+     * permission over somebody else's entry, and a failure here costs a stale convenience
+     * rather than a broken reference, because `mediaId` is the source of truth and the
+     * admin resolves through it. What fails is returned by name; nothing is swallowed.
+     */
+    async refreshReferences(mediaId, url) {
+      const references = await media.usages(mediaId, { limit: MAX_MEDIA_REFRESH });
+      const user = currentUser();
+      const failed = [];
+      let updated = 0;
+      for (const reference of references) {
+        try {
+          const target = doc(db, entryPath(reference.contentType, reference.entryId));
+          const snapshot = await getDoc(target);
+          if (!snapshot.exists()) continue;
+          const rewritten = retargetMediaUrls(snapshot.data(), mediaId, url);
+          if (rewritten === null) continue;
+          await updateDoc(target, {
+            ...rewritten,
+            updatedAt: serverTimestamp(),
+            updatedBy: user.uid
+          });
+          updated += 1;
+        } catch {
+          failed.push(reference);
+        }
+      }
+      return { updated, failed };
+    }
+  };
+  async function assertSchemaWrite(slug) {
+    const current = registry();
+    if (current.has(slug)) {
+      assertSchemaWritable(current, slug);
+      return;
+    }
+    if (!(await getDoc(doc(db, schemaPath(slug)))).exists()) {
+      throw new SchemaError(`Unknown content type "${slug}".`);
+    }
+  }
+  const schemas = {
+    async list() {
+      const found = await getDocs(collection(db, SCHEMAS));
+      return found.docs.map((snapshot) => snapshot.data());
+    },
+    async get(slug) {
+      const snapshot = await getDoc(doc(db, schemaPath(slug)));
+      return snapshot.exists() ? snapshot.data() : null;
+    },
+    watch(listener, onError) {
+      return onSnapshot(
+        collection(db, SCHEMAS),
+        (found) => {
+          listener(found.docs.map((snapshot) => snapshot.data()));
+        },
+        (error) => {
+          onError?.(error);
+        }
+      );
+    },
+    async create(type) {
+      assertCan(currentUser(), "manage-schema");
+      assertTypeSlugAvailable(registry(), type.slug);
+      assertValidContentType(type);
+      guardSchemaWrite(type);
+      const reference = doc(db, schemaPath(type.slug));
+      if ((await getDoc(reference)).exists()) {
+        throw new SchemaError(
+          `Content type "${type.slug}" already exists in the database.`
+        );
+      }
+      const created = {
+        ...withNormalizedMatrix(type),
+        schemaVersion: nextSchemaVersion(null, type)
+      };
+      await setDoc(reference, { ...created, updatedAt: serverTimestamp() });
+      await ensureContentDoc(created);
+      return created;
+    },
+    async update(slug, type) {
+      assertCan(currentUser(), "manage-schema");
+      await assertSchemaWrite(slug);
+      assertValidContentType(type);
+      guardSchemaWrite(type);
+      if (type.slug !== slug) {
+        throw new SchemaError(
+          `Content type "${slug}" cannot be renamed to "${type.slug}" in place. A slug change moves every entry and is a migration.`
+        );
+      }
+      const reference = doc(db, schemaPath(slug));
+      const stored = await getDoc(reference);
+      const previous = stored.exists() ? stored.data() : null;
+      const written = {
+        ...withNormalizedMatrix(type),
+        schemaVersion: nextSchemaVersion(previous, type)
+      };
+      await setDoc(reference, { ...written, updatedAt: serverTimestamp() });
+      await ensureContentDoc(written);
+      if (previous !== null && schemaVersionOf(previous) !== written.schemaVersion) {
+        await updateDoc(doc(db, contentPath(slug)), {
+          schemaVersion: written.schemaVersion,
+          updatedAt: serverTimestamp()
+        });
+      }
+      return written;
+    },
+    async delete(slug) {
+      assertCan(currentUser(), "manage-schema");
+      await assertSchemaWrite(slug);
+      await deleteDoc(doc(db, schemaPath(slug)));
+    }
+  };
+  const fieldData = {
+    async count(slug, key) {
+      assertTopLevelKey(slug, key);
+      const type = resolveType(slug);
+      if (!(key in type.fields) && type.removedFields?.[key] === void 0) {
+        throw new SchemaError(
+          `Content type "${type.slug}" has no field "${key}", live or removed.`
+        );
+      }
+      const found = await getCountFromServer(
+        query(entriesCollection(slug), where(key, "!=", null))
+      );
+      return found.data().count;
+    },
+    async purge(slug, key, options = {}) {
+      const user = currentUser();
+      if (!can(user, "manage-schema")) {
+        throw new PermissionError(
+          "manage-schema",
+          slug,
+          `Purging the values of field "${key}" requires the manage-schema permission.`
+        );
+      }
+      assertTopLevelKey(slug, key);
+      const type = resolveType(slug);
+      if (key in type.fields) {
+        throw new SchemaError(
+          `Field "${key}" of content type "${type.slug}" is still part of the schema. Remove it first; removing keeps the values, purging destroys them.`
+        );
+      }
+      if (type.removedFields?.[key] === void 0) {
+        throw new SchemaError(
+          `Content type "${type.slug}" has no removed field "${key}" to purge.`
+        );
+      }
+      const size = Math.min(
+        Math.max(Math.trunc(options.limit ?? MAX_FIELD_PURGE), 1),
+        MAX_FIELD_PURGE
+      );
+      const found = await getDocs(
+        query(entriesCollection(slug), where(key, "!=", null), limit(size + 1))
+      );
+      const targets = found.docs.slice(0, size);
+      if (targets.length === 0) return { purged: 0, remaining: false };
+      const batch = writeBatch(db);
+      for (const snapshot of targets) {
+        batch.update(snapshot.ref, {
+          [key]: deleteField(),
+          updatedAt: serverTimestamp(),
+          updatedBy: user.uid
+        });
+      }
+      await batch.commit();
+      return { purged: targets.length, remaining: found.docs.length > size };
+    }
+  };
+  const migrations = {
+    async countBehind(slug, targetVersion) {
+      assertCan(currentUser(), "manage-schema", { type: resolveType(slug) });
+      const found = await getCountFromServer(
+        query(entriesCollection(slug), where("schemaVersion", "<", targetVersion))
+      );
+      return found.data().count;
+    },
+    async listBehind(slug, targetVersion, migrationQuery = {}) {
+      assertCan(currentUser(), "manage-schema", { type: resolveType(slug) });
+      const size = normalizeLimit(migrationQuery.limit);
+      const found = await getDocs(
+        query(
+          entriesCollection(slug),
+          where("schemaVersion", "<", targetVersion),
+          orderBy("schemaVersion", "asc"),
+          orderBy("__name__", "asc"),
+          limit(size + 1)
+        )
+      );
+      const docs = found.docs.slice(0, size);
+      return {
+        items: docs.map((snapshot) => toStoredRecord(snapshot.id, snapshot.data())),
+        cursor: null,
+        hasMore: found.docs.length > size
+      };
+    },
+    async applyMigration(slug, entryId, values, write) {
+      const user = currentUser();
+      assertCan(user, "manage-schema", { type: resolveType(slug) });
+      refuse(checkWritePayload(values, { maxFields: MAX_ENTRY_FIELDS }));
+      const reference = doc(db, entryPath(slug, entryId));
+      return await runTransaction(db, async (transaction) => {
+        const snapshot = await transaction.get(reference);
+        if (!snapshot.exists()) return false;
+        const stored = snapshot.data();
+        const version = typeof stored["schemaVersion"] === "number" ? stored["schemaVersion"] : 1;
+        if (version !== write.expectedVersion) return false;
+        const dropped = {};
+        for (const key of Object.keys(stored)) {
+          if (ADAPTER_OWNED_KEYS.has(key)) continue;
+          if (!(key in values)) dropped[key] = deleteField();
+        }
+        transaction.update(reference, {
+          ...values,
+          ...dropped,
+          [MEDIA_REFS_KEY]: collectMediaIds(values),
+          schemaVersion: write.nextVersion,
+          updatedAt: serverTimestamp(),
+          updatedBy: user.uid
+        });
+        return true;
+      });
+    }
+  };
+  const settings = {
+    async get(key) {
+      const snapshot = await getDoc(doc(db, settingsPath(key)));
+      return snapshot.exists() ? snapshot.data() : null;
+    },
+    async set(key, value) {
+      assertCan(currentUser(), "manage-settings");
+      if (key === BOOTSTRAP_KEY) {
+        throw new SchemaError(
+          `"${BOOTSTRAP_KEY}" is the first-run marker, not a settings document. It is written once at setup and never again.`
+        );
+      }
+      guardWrite(value, MAX_SETTINGS_FIELDS);
+      await setDoc(
+        doc(db, settingsPath(key)),
+        { ...value, updatedAt: serverTimestamp() },
+        { merge: true }
+      );
+    }
+  };
+  return {
+    async list(slug, listQuery = {}) {
+      const type = resolveType(slug);
+      assertCanRead(type);
+      assertListable(type);
+      const size = normalizeLimit(listQuery.limit);
+      const constraints = constraintsFor(type, listQuery);
+      if (listQuery.cursor) {
+        const anchor = await snapshotFor(slug, listQuery.cursor);
+        if (anchor.exists()) constraints.push(startAfter(anchor));
+      }
+      constraints.push(limit(size + 1));
+      const found = await getDocs(
+        query(entriesCollection(slug), ...constraints)
+      );
+      const docs = found.docs.slice(0, size);
+      const hasMore = found.docs.length > size;
+      return {
+        items: docs.map((snapshot) => toEntry(type, snapshot)),
+        cursor: hasMore ? docs.at(-1)?.id ?? null : null,
+        hasMore
+      };
+    },
+    async get(slug, entryId) {
+      const type = resolveType(slug);
+      assertCanRead(type);
+      const snapshot = await snapshotFor(slug, entryId);
+      return snapshot.exists() ? entryFromStored(type, snapshot.id, snapshot.data(), fieldTypes) : null;
+    },
+    async getBySlug(slug, value, options = {}) {
+      const type = resolveType(slug);
+      assertCanRead(type);
+      const key = slugFieldKey(type);
+      if (key === null) {
+        throw new SchemaError(
+          `Content type "${slug}" has no slug field, so it cannot be looked up by slug.`
+        );
+      }
+      const status = options.status ?? "any";
+      const constraints = [where(key, "==", value)];
+      if (status !== "any") constraints.push(where("status", "==", status));
+      constraints.push(limit(1));
+      const found = await getDocs(query(entriesCollection(slug), ...constraints));
+      const first = found.docs[0];
+      return first ? toEntry(type, first) : null;
+    },
+    async getSingle(slug) {
+      const type = resolveType(slug);
+      assertCanRead(type);
+      if (!isSingleton(type)) {
+        throw new SchemaError(
+          `Content type "${slug}" is a collection. Read it with list() or get().`
+        );
+      }
+      const entryId = singletonEntryId(slug);
+      const snapshot = await snapshotFor(slug, entryId);
+      return snapshot.exists() ? entryFromStored(type, entryId, snapshot.data(), fieldTypes) : null;
+    },
+    async create(slug, input) {
+      const type = resolveType(slug);
+      if (isSingleton(type)) {
+        const entryId = singletonEntryId(slug);
+        const existing = await snapshotFor(slug, entryId);
+        assertSingletonCreatable(type, existing.exists());
+        return writeEntry(type, entryId, input, "create");
+      }
+      const reference = doc(entriesCollection(slug));
+      return writeEntry(type, reference.id, input, "create");
+    },
+    async update(slug, entryId, input) {
+      const type = resolveType(slug);
+      assertSingletonEntryId(type, entryId);
+      return writeEntry(type, entryId, input, "update");
+    },
+    async delete(slug, entryId) {
+      const type = resolveType(slug);
+      assertDeletable(type);
+      const user = currentUser();
+      assertNotDenied(user, "delete", type);
+      const reference = doc(db, entryPath(slug, entryId));
+      const existing = await getDoc(reference);
+      assertCan(user, "delete", {
+        type,
+        ...existing.exists() ? { entry: { createdBy: metaFromStored(entryId, existing.data()).createdBy } } : {}
+      });
+      await deleteDoc(reference);
+    },
+    async count(slug, countQuery = {}) {
+      const type = resolveType(slug);
+      assertCanRead(type);
+      const constraints = [];
+      const status = countQuery.status ?? "any";
+      if (status !== "any") constraints.push(where("status", "==", status));
+      for (const filter of countQuery.filters ?? []) {
+        constraints.push(where(filter.field, filter.op, filter.value));
+      }
+      const range = searchRange(type, countQuery.search);
+      if (range !== null) {
+        constraints.push(where(range.field, ">=", range.term));
+        constraints.push(where(range.field, "<=", `${range.term}${PREFIX_END}`));
+      }
+      const snapshot = await getCountFromServer(
+        query(entriesCollection(slug), ...constraints)
+      );
+      return snapshot.data().count;
+    },
+    media,
+    schemas,
+    fieldData,
+    migrations,
+    settings
+  };
+}
+function sameMatrix(stored, next) {
+  const current = typeof stored === "object" && stored !== null && !Array.isArray(stored) ? stored : {};
+  const keys = /* @__PURE__ */ new Set([...Object.keys(current), ...Object.keys(next)]);
+  for (const key of keys) {
+    const left = current[key];
+    const right = next[key];
+    if (!Array.isArray(left) || right === void 0) return false;
+    if (left.length !== right.length) return false;
+    if (!right.every((role) => left.includes(role))) return false;
+  }
+  return true;
+}
+var ADAPTER_OWNED_KEYS = /* @__PURE__ */ new Set([
+  "status",
+  "schemaVersion",
+  "createdAt",
+  "createdBy",
+  "updatedAt",
+  "updatedBy",
+  "publishedAt",
+  MEDIA_REFS_KEY
+]);
+function toStoredRecord(entryId, data) {
+  const values = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (!ADAPTER_OWNED_KEYS.has(key)) values[key] = value;
+  }
+  return {
+    id: entryId,
+    schemaVersion: typeof data["schemaVersion"] === "number" ? data["schemaVersion"] : 1,
+    values
+  };
+}
+function mediaFromStored(mediaId, data) {
+  return {
+    id: mediaId,
+    name: typeof data["name"] === "string" ? data["name"] : "",
+    type: typeof data["type"] === "string" ? data["type"] : "application/octet-stream",
+    size: typeof data["size"] === "number" ? data["size"] : 0,
+    url: typeof data["url"] === "string" ? data["url"] : "",
+    path: typeof data["path"] === "string" ? data["path"] : "",
+    alt: typeof data["alt"] === "string" ? data["alt"] : null,
+    width: typeof data["width"] === "number" ? data["width"] : null,
+    height: typeof data["height"] === "number" ? data["height"] : null,
+    createdAt: toIso(data["createdAt"]) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    createdBy: typeof data["createdBy"] === "string" ? data["createdBy"] : ""
+  };
+}
+var MediaUploadError = class extends Error {
+  name = "MediaUploadError";
+  code;
+  /** Set when the file itself was refused, so the UI can point at the offending rule. */
+  rejection;
+  /**
+   * The Storage object that outlived the failed upload, when cleanup could not remove it.
+   * Null means nothing was left behind, which is the ordinary case.
+   */
+  orphanedPath;
+  constructor(code, message, detail = {}) {
+    super(message, detail.cause === void 0 ? void 0 : { cause: detail.cause });
+    this.code = code;
+    this.rejection = detail.rejection ?? null;
+    this.orphanedPath = detail.orphanedPath ?? null;
+  }
+};
+function createMediaUpload(deps, file, options = {}) {
+  return prepare(deps, file, options, null);
+}
+function createMediaReplace(deps, existing, file, options = {}) {
+  return prepare(deps, file, options, existing);
+}
+function prepare(deps, file, options, existing) {
+  const readImageSize = deps.readImageSize ?? browserImageSize;
+  const mediaId = existing?.id ?? deps.media.reserveId();
+  const fileName = existing === null ? safeFileName(file.name, file.type) : lastSegment(existing.path);
+  const path = existing?.path ?? storageObjectPath(mediaId, fileName);
+  let attempt = 0;
+  let task = null;
+  let cancelled = false;
+  let state = {
+    phase: "idle",
+    bytesTransferred: 0,
+    totalBytes: file.size,
+    fraction: 0,
+    attempt: 0
+  };
+  function report(next) {
+    state = { ...state, ...next };
+    options.onProgress?.(state);
+  }
+  async function run() {
+    const rejection = checkMediaFile({
+      name: file.name,
+      type: file.type,
+      size: file.size
+    });
+    if (rejection !== null) {
+      report({ phase: "failed", attempt: attempt + 1 });
+      throw new MediaUploadError("rejected", rejection.message, { rejection });
+    }
+    if (existing !== null && normalizeMediaType(file.type) !== existing.type) {
+      const message = `A ${existing.type} file can only be replaced by another ${existing.type} file. Upload ${file.type || "this file"} as a new item instead.`;
+      report({ phase: "failed", attempt: attempt + 1 });
+      throw new MediaUploadError("rejected", message, {
+        rejection: { code: "type-not-allowed", message }
+      });
+    }
+    attempt += 1;
+    cancelled = false;
+    report({
+      phase: "uploading",
+      bytesTransferred: 0,
+      fraction: 0,
+      attempt,
+      totalBytes: file.size
+    });
+    const uploadTask = uploadBytesResumable(ref(deps.storage, path), file, {
+      contentType: file.type,
+      // The bucket has no idea who wrote an object unless it is told. The rules read this
+      // back on update and delete, which is what lets the uploader clean up after
+      // themselves without granting an author delete rights over everybody's files.
+      customMetadata: { uploadedBy: deps.currentUser().uid, mediaId }
+    });
+    task = uploadTask;
+    uploadTask.on("state_changed", (snapshot) => {
+      const total = snapshot.totalBytes === 0 ? file.size : snapshot.totalBytes;
+      report({
+        phase: "uploading",
+        bytesTransferred: snapshot.bytesTransferred,
+        totalBytes: total,
+        fraction: total === 0 ? 0 : snapshot.bytesTransferred / total
+      });
+    });
+    try {
+      await uploadTask;
+    } catch (thrown) {
+      task = null;
+      const code = thrown.code ?? "";
+      if (cancelled || code === "storage/canceled") {
+        report({ phase: "cancelled" });
+        throw new MediaUploadError("cancelled", "The upload was cancelled.", {
+          cause: thrown
+        });
+      }
+      report({ phase: "failed" });
+      throw new MediaUploadError(
+        "storage-failed",
+        "The file could not be uploaded. Nothing was stored, so retrying is safe.",
+        { cause: thrown }
+      );
+    }
+    task = null;
+    report({
+      phase: "storing",
+      bytesTransferred: file.size,
+      totalBytes: file.size,
+      fraction: 1
+    });
+    const url = await getDownloadURL(uploadTask.snapshot.ref);
+    const size = await imageSize(file, readImageSize);
+    try {
+      const item = existing === null ? await deps.media.create(
+        {
+          name: file.name,
+          type: file.type,
+          size: file.size,
+          url,
+          path,
+          alt: options.alt ?? null,
+          width: size?.width ?? null,
+          height: size?.height ?? null
+        },
+        mediaId
+      ) : (
+        // Alt text is not in the patch. It describes what the picture shows and it is
+        // the editor's sentence, not the file's, so a replace keeps it and the library
+        // says so, rather than discarding a description nobody asked it to discard.
+        await deps.media.update(mediaId, {
+          name: file.name,
+          size: file.size,
+          url,
+          width: size?.width ?? null,
+          height: size?.height ?? null
+        })
+      );
+      report({ phase: "done" });
+      return item;
+    } catch (thrown) {
+      if (existing !== null) {
+        report({ phase: "failed" });
+        throw new MediaUploadError(
+          "metadata-failed",
+          `The new file was stored but the library record still describes the old one, and the old link no longer works. Reload the library and replace "${existing.name}" again.`,
+          { cause: thrown }
+        );
+      }
+      const removed = await removeOrphan(deps.storage, path);
+      report({ phase: "failed" });
+      throw new MediaUploadError(
+        "metadata-failed",
+        removed ? "The file was uploaded but could not be recorded, so the upload was undone. Try again." : `The file was uploaded but could not be recorded, and the uploaded copy at ${path} could not be removed. It is not in the library and has to be cleaned up.`,
+        removed ? { cause: thrown } : { cause: thrown, orphanedPath: path }
+      );
+    }
+  }
+  return {
+    mediaId,
+    path,
+    fileName,
+    progress: () => state,
+    start: run,
+    retry: run,
+    cancel() {
+      cancelled = true;
+      task?.cancel();
+    }
+  };
+}
+function lastSegment(path) {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+function uploadMedia(deps, file, options = {}) {
+  return createMediaUpload(deps, file, options).start();
+}
+async function removeOrphan(storage, path) {
+  try {
+    await deleteObject(ref(storage, path));
+    return true;
+  } catch (thrown) {
+    return thrown.code === "storage/object-not-found";
+  }
+}
+async function imageSize(file, reader) {
+  if (mediaTypeRule(file.type)?.category !== "image") return null;
+  try {
+    return await reader(file, file.type);
+  } catch {
+    return null;
+  }
+}
+var browserImageSize = async (file) => {
+  const decode = globalThis.createImageBitmap;
+  if (decode === void 0) return null;
+  const bitmap = await decode(file);
+  try {
+    return { width: bitmap.width, height: bitmap.height };
+  } finally {
+    bitmap.close();
+  }
+};
+function createMediaUploader(deps) {
+  return {
+    create: (file, options) => createMediaUpload(deps, file, options),
+    replace: (existing, file, options) => createMediaReplace(deps, existing, file, options)
+  };
+}
+
+export { MediaUploadError, browserImageSize, createFirestoreAdapter, createMediaReplace, createMediaUpload, createMediaUploader, removeOrphan, uploadMedia };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map