@nonext/husk 0.2.3

package/dist/auth/index.d.ts

@@ -0,0 +1,4 @@
+export { A as AuthError, a as AuthErrorCode, C as ClaimSet, b as ClaimSync, c as ClaimSyncError, E as EmulatorClaimSyncOptions, H as HuskAuth, d as HuskAuthDeps, N as NewUser, S as SignUpInput, e as StoredUser, U as UserPatch, f as createEmulatorClaimSync, g as createHuskAuth, h as createUnavailableClaimSync, t as toAuthUser } from '../index-5ylaMBUH.js';
+export { b as AuthUser, R as ROLES, e as Role } from '../auth-B2gBtHl5.js';
+import 'firebase/auth';
+import 'firebase/firestore';

package/dist/auth/index.js

@@ -0,0 +1,9 @@
+export { AuthError, ClaimSyncError, createEmulatorClaimSync, createHuskAuth, createUnavailableClaimSync, toAuthUser } from '../chunk-ZYNBMYJ6.js';
+import '../chunk-ROLKRJWI.js';
+import '../chunk-SOTQ3WP5.js';
+import '../chunk-TCFFHTY3.js';
+import '../chunk-NPDBQBLW.js';
+export { ROLES } from '../chunk-TS7Y7GEZ.js';
+import '../chunk-4Z6P3XCE.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/auth/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/auth-B2gBtHl5.d.ts

@@ -0,0 +1,28 @@
+declare const ROLES: readonly ["admin", "editor", "author"];
+type Role = (typeof ROLES)[number];
+/** Actions performed on the entries of one content type. */
+type EntryAction = "read" | "create" | "update" | "delete";
+/** Actions that are not scoped to a content type. */
+type AdminAction = "manage-schema" | "manage-users" | "manage-settings" | "manage-media";
+type Action = EntryAction | AdminAction;
+declare const ENTRY_ACTIONS: readonly ["read", "create", "update", "delete"];
+/**
+ * Who may do what with one content type. A missing action falls back to the role defaults
+ * in `can()`, so an empty matrix means "use the defaults", not "deny everything".
+ */
+type PermissionMatrix = Partial<Record<EntryAction, readonly Role[]>>;
+/** One resolved permission question, as the UI, the adapter, and the tests all phrase it. */
+interface Permission {
+    action: Action;
+    /** Content type slug. Absent for an `AdminAction`. */
+    contentType?: string;
+}
+interface AuthUser {
+    uid: string;
+    email: string;
+    displayName: string | null;
+    role: Role;
+    disabled: boolean;
+}
+
+export { type Action as A, ENTRY_ACTIONS as E, type Permission as P, ROLES as R, type AdminAction as a, type AuthUser as b, type EntryAction as c, type PermissionMatrix as d, type Role as e };

package/dist/can-Chy7zmx7.d.ts

@@ -0,0 +1,69 @@
+import { A as Action, e as Role, b as AuthUser, c as EntryAction } from './auth-B2gBtHl5.js';
+import { c as ContentTypeLike, h as EntryMeta } from './entry-D3kiE8T1.js';
+
+/**
+ * The one permission resolver.
+ *
+ * The admin UI calls it to hide what a user may not do, the adapter calls it again to
+ * refuse the call when the UI is bypassed, and the security rules encode the same matrix a
+ * third time. Three layers, one truth table. Keep this pure and synchronous: it has to run
+ * inside a render, inside a write path, and inside a test, with no Firebase and no IO.
+ */
+declare const ADMIN_ACTIONS: readonly ["manage-schema", "manage-users", "manage-settings", "manage-media"];
+/** Every action the resolver answers for. The test cross-checks it against the table. */
+declare const ACTIONS: readonly Action[];
+/**
+ * An allow that still depends on who created the entry. Kept as a third state rather than
+ * resolved to a boolean early, so an ownership-gated action can be told apart from a plain
+ * denial and answered against the entry the caller passed in.
+ */
+type Decision = "allow" | "deny" | "own-entry-only";
+/**
+ * The role defaults, exhaustive by construction: `Record<Role, Record<Action, Decision>>`
+ * fails to typecheck the moment a role or an action is added without a decision here.
+ */
+declare const PERMISSION_DEFAULTS: Readonly<Record<Role, Readonly<Record<Action, Decision>>>>;
+/** Just enough of an entry to answer an ownership question. */
+type EntryOwnership = Pick<EntryMeta, "createdBy">;
+interface PermissionContext {
+    /** The content type the action targets. Carries the per-type permission matrix, if any. */
+    type?: ContentTypeLike;
+    /**
+     * The entry the action targets. Absent means the caller does not know which entry, which
+     * denies an ownership-gated action rather than guessing in the user's favour.
+     */
+    entry?: EntryOwnership;
+}
+declare function isEntryAction(action: Action): action is EntryAction;
+/**
+ * Answers one permission question.
+ *
+ * Ownership is resolved against `context.entry`, not against the content type, because an
+ * author's `update` is a question about one entry and cannot be answered honestly without
+ * it. A caller that does not pass the entry gets `false`: "I cannot tell" has to read as a
+ * denial at the UI layer, since the adapter and the rules will deny it too.
+ *
+ * `context.type.permissions` narrows the role defaults for entry actions on that type. An
+ * absent matrix, and an action absent from it, mean "use the defaults", never "deny
+ * everything", so adding a matrix for one action does not silently lock out the rest.
+ *
+ * A matrix narrows and never widens. Three things follow, and M10 settled all three by
+ * making the security rules agree with them rather than by softening them here. It cannot
+ * restrict an admin. It cannot lift an author's ownership rule, so ticking `author` under
+ * `update` grants that action on the author's own entries only. And it cannot grant an
+ * action the role's own default denies, so ticking `author` under `delete` changes nothing:
+ * firestore.rules resolves the role defaults from the token alone and only consults the
+ * matrix to narrow further, because a rule that widened a privilege from a stored document
+ * would be trusting the document to grant it. See permissions/matrix.ts.
+ */
+declare function can(user: AuthUser, action: Action, context?: PermissionContext): boolean;
+/**
+ * The truth table lookup on its own, without the entry.
+ *
+ * Exported because `permissions/matrix.ts` labels the Developer area's table with it and a
+ * second implementation of the same lookup would be a second place for the three layers to
+ * drift apart. `can()` is this plus the ownership question.
+ */
+declare function resolveDecision(role: Role, action: Action, type: Pick<ContentTypeLike, "permissions"> | undefined): Decision;
+
+export { ACTIONS as A, type Decision as D, type EntryOwnership as E, PERMISSION_DEFAULTS as P, ADMIN_ACTIONS as a, type PermissionContext as b, can as c, isEntryAction as i, resolveDecision as r };

package/dist/chunk-3I6337WJ.js

@@ -0,0 +1,83 @@
+import { assertListable, isSingleton } from './chunk-R4O7APIX.js';
+import { SingletonError, SchemaError } from './chunk-4Z6P3XCE.js';
+
+// src/core/cms.ts
+function statusFor(preview) {
+  return preview ? "any" : "published";
+}
+function visible(entry, preview) {
+  if (entry === null) return null;
+  if (preview) return entry;
+  return entry.status === "published" ? entry : null;
+}
+function assertMapKeysMatch(contentTypes) {
+  for (const [key, type] of Object.entries(contentTypes)) {
+    if (type.slug !== key) {
+      throw new SchemaError(
+        `Content type map key "${key}" holds the content type "${type.slug}". The key is what a read is looked up by, so a mismatch would type one content type and read another.`
+      );
+    }
+  }
+}
+function createCMS(config) {
+  const { adapter } = config;
+  const contentTypes = config.contentTypes ?? {};
+  const preview = config.preview ?? false;
+  const status = statusFor(preview);
+  assertMapKeysMatch(contentTypes);
+  function known(slug) {
+    return contentTypes[slug];
+  }
+  function collection(slug) {
+    const type = known(slug);
+    if (type) assertListable(type);
+    const reader = {
+      async findMany(query = {}) {
+        return adapter.list(slug, { ...query, status });
+      },
+      async findBySlug(value) {
+        return visible(await adapter.getBySlug(slug, value, { status }), preview);
+      },
+      async findById(entryId) {
+        return visible(await adapter.get(slug, entryId), preview);
+      },
+      async count(query = {}) {
+        return adapter.count(slug, { ...query, status });
+      }
+    };
+    return reader;
+  }
+  function single(slug) {
+    const type = known(slug);
+    if (type && !isSingleton(type)) {
+      throw new SingletonError(
+        type.slug,
+        `Content type "${type.slug}" is a collection. Read it with collection("${type.slug}").findMany().`
+      );
+    }
+    const reader = {
+      async get() {
+        return visible(await adapter.getSingle(slug), preview);
+      }
+    };
+    return reader;
+  }
+  const media = {
+    getById: (mediaId) => adapter.media.getById(mediaId),
+    getMany: (mediaIds) => adapter.media.getMany(mediaIds)
+  };
+  const settings = {
+    get: (key) => adapter.settings.get(key)
+  };
+  return {
+    collection,
+    single,
+    media: () => media,
+    settings: () => settings,
+    isPreview: preview
+  };
+}
+
+export { createCMS };
+//# sourceMappingURL=chunk-3I6337WJ.js.map
+//# sourceMappingURL=chunk-3I6337WJ.js.map

package/dist/chunk-3I6337WJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/cms.ts"],"names":[],"mappings":"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","file":"chunk-3I6337WJ.js","sourcesContent":["import type { AnyContentTypeShape, Entry } from \"../types/entry.js\"\nimport type { MediaItem } from \"../types/media.js\"\n\nimport type { CmsAdapter, ListQuery, Page } from \"./adapter.js\"\nimport { assertListable, isSingleton } from \"./content-kind.js\"\nimport type { KindShape } from \"./content-kind.js\"\nimport { SchemaError, SingletonError } from \"./errors.js\"\n\n/**\n * The public read SDK. The surface a customer project programs against.\n *\n * Everything here goes through `CmsAdapter`, which is the whole point: the concept document\n * says the SDK will probably outlive the admin, and that a change to the internal Firestore\n * layout should cost a rewrite of the adapter rather than a rewrite of every customer\n * project. Nothing in this file names a collection, a document id, or a field path in\n * storage, so there is no layout knowledge here to invalidate.\n *\n * It is read-only on purpose. Writing is the admin's job, and it goes through the adapter\n * with a signed-in user, permission checks, and validation. Adding a `create` here would\n * mean a second write path with none of that.\n */\n\n/**\n * The code-defined content types an instance knows at compile time, keyed by slug.\n *\n * Keyed rather than a list, because that is what makes `cms.collection(\"projects\")` return\n * a typed entry. `ContentType<TFields>` declares `slug: string`, not the literal, so a list\n * of content types offers the type system nothing to index by. The key is the index.\n *\n * The key must equal the type's own `slug`; `createCMS` rejects a map where it does not,\n * because a mismatch would type one content type and read another.\n */\nexport type ContentTypeMap = { readonly [slug: string]: KindShape & AnyContentTypeShape }\n\n/** The slugs a map declares. */\nexport type KnownSlug<TTypes extends ContentTypeMap> = keyof TTypes & string\n\n/**\n * A known slug, or any other string.\n *\n * Both halves are required. The known slugs are what an editor offers and what carries the\n * inference; the open half is what keeps a database-defined content type readable, since\n * one created in the Schema Builder has no compile-time existence at all.\n */\nexport type SlugOf<TTypes extends ContentTypeMap> =\n  KnownSlug<TTypes> | (string & Record<never, never>)\n\n/**\n * What one slug reads as.\n *\n * A declared slug resolves to its inferred entry, so `project.title` is `string`. Anything\n * else resolves to the erased `Entry`, whose field values are the union of every field\n * type's value, nullable. That is deliberately not a lie: a database-defined type has no\n * shape at compile time, so the honest type is \"some field value or null\", and a consumer\n * has to narrow before using it. Typing it as `any`, or pretending it has the fields of\n * some other type, would make the compiler agree to code that cannot work.\n */\nexport type EntryOf<\n  TTypes extends ContentTypeMap,\n  TSlug extends string,\n> = TSlug extends keyof TTypes ? Entry<TTypes[TSlug]> : Entry\n\n/**\n * What a public read may narrow by.\n *\n * `ListQuery.status` is removed rather than defaulted. A caller on a customer's website\n * cannot ask for drafts at all, which means a leak cannot come from a forwarded query\n * object, a URL parameter that ends up in a filter, or a copied snippet. Status is decided\n * once, by whether the instance is a preview instance.\n */\nexport type CmsQuery = Omit<ListQuery, \"status\">\n\n/** The narrowing a count understands. The rest of a query does not change a total. */\nexport type CmsCountQuery = Pick<CmsQuery, \"filters\" | \"search\">\n\nexport interface CollectionReader<TEntry = Entry> {\n  /** One page of entries. Pass `page.cursor` back as `query.cursor` for the next one. */\n  findMany(query?: CmsQuery): Promise<Page<TEntry>>\n  /** By the value of the content type's slug field, which is what a URL segment carries. */\n  findBySlug(value: string): Promise<TEntry | null>\n  /** By entry id. */\n  findById(entryId: string): Promise<TEntry | null>\n  /** How many entries the same narrowing would return. */\n  count(query?: CmsCountQuery): Promise<number>\n}\n\nexport interface SingleReader<TEntry = Entry> {\n  /** The one entry of a singleton. Null when it has never been saved. */\n  get(): Promise<TEntry | null>\n}\n\nexport interface MediaReader {\n  getById(mediaId: string): Promise<MediaItem | null>\n  /** Missing ids are omitted rather than returned as holes, so the result may be shorter. */\n  getMany(mediaIds: readonly string[]): Promise<readonly MediaItem[]>\n}\n\nexport interface SettingsReader {\n  /** A settings document by key, or null when it has never been written. */\n  get(key: string): Promise<Record<string, unknown> | null>\n}\n\nexport interface Cms<TTypes extends ContentTypeMap = ContentTypeMap> {\n  collection<TSlug extends SlugOf<TTypes>>(\n    slug: TSlug,\n  ): CollectionReader<EntryOf<TTypes, TSlug>>\n  single<TSlug extends SlugOf<TTypes>>(slug: TSlug): SingleReader<EntryOf<TTypes, TSlug>>\n  media(): MediaReader\n  settings(): SettingsReader\n  /** True when this instance reads unpublished entries. False on every public instance. */\n  readonly isPreview: boolean\n}\n\n/**\n * Everything an instance needs except the decision about unpublished content.\n *\n * Split out so the client entry can accept exactly this and nothing more: a config type\n * with no `preview` key makes passing one a compile error rather than a review comment.\n */\nexport interface CmsReadConfig<TTypes extends ContentTypeMap = ContentTypeMap> {\n  /** The storage seam. The SDK holds no other handle on data. */\n  adapter: CmsAdapter\n  /**\n   * The code-defined content types, keyed by slug. Omitting them costs the inference and\n   * nothing else: every read still works and every entry is typed as the erased `Entry`.\n   */\n  contentTypes?: TTypes\n}\n\nexport interface CmsConfig<\n  TTypes extends ContentTypeMap = ContentTypeMap,\n> extends CmsReadConfig<TTypes> {\n  /**\n   * Reads every status instead of published only.\n   *\n   * Off unless it is passed, and there is no way to turn it on after construction: a\n   * preview instance is a different object built by a different call. See\n   * `.docs/decisions/2026-09-19-cms-sdk-surface.md` for why it is not a per-call argument.\n   */\n  preview?: boolean\n}\n\n/**\n * What a read asks the adapter for.\n *\n * `\"published\"` is the whole safety property: a customer who writes\n * `cms.collection(\"posts\").findMany()` on their homepage gets published entries without\n * having known to ask. `\"any\"` is the preview instance, which reads drafts and archived\n * entries as well, because the adapter offers one status or all of them and a preview that\n * hid archived content would be lying about what is stored.\n */\nfunction statusFor(preview: boolean): \"published\" | \"any\" {\n  return preview ? \"any\" : \"published\"\n}\n\n/**\n * Applies the same narrowing to a single-document read.\n *\n * The list path narrows in the query, because a query has a where clause. A read by id or\n * by slug field returns one document and there is nothing to narrow in, so the check\n * happens here. Missing it would be the exact leak the default exists to prevent: a draft\n * is invisible in the index but reachable by guessing its URL.\n */\nfunction visible(entry: Entry | null, preview: boolean): Entry | null {\n  if (entry === null) return null\n  if (preview) return entry\n  return entry.status === \"published\" ? entry : null\n}\n\nfunction assertMapKeysMatch(contentTypes: ContentTypeMap): void {\n  for (const [key, type] of Object.entries(contentTypes)) {\n    if (type.slug !== key) {\n      throw new SchemaError(\n        `Content type map key \"${key}\" holds the content type \"${type.slug}\". The key is what a read is looked up by, so a mismatch would type one content type and read another.`,\n      )\n    }\n  }\n}\n\n/**\n * Builds a CMS instance over an adapter.\n *\n * Server and client variants live in `@nonext/husk/server` and `@nonext/husk/client`; this is\n * the shared implementation both are built from, and it is exported so a test or a custom\n * runtime can construct one directly over a test double.\n */\nexport function createCMS<TTypes extends ContentTypeMap = ContentTypeMap>(\n  config: CmsConfig<TTypes>,\n): Cms<TTypes> {\n  const { adapter } = config\n  const contentTypes: ContentTypeMap = config.contentTypes ?? {}\n  const preview = config.preview ?? false\n  const status = statusFor(preview)\n\n  assertMapKeysMatch(contentTypes)\n\n  /**\n   * The compile-time definition of a slug, when there is one.\n   *\n   * A database-defined type is absent here by construction, which is why the kind guards\n   * below only fire for a known type. The adapter guards the rest: it holds the live\n   * registry and knows the kind of every type, code-defined or not.\n   */\n  function known(slug: string): (KindShape & AnyContentTypeShape) | undefined {\n    return contentTypes[slug]\n  }\n\n  function collection<TSlug extends SlugOf<TTypes>>(\n    slug: TSlug,\n  ): CollectionReader<EntryOf<TTypes, TSlug>> {\n    const type = known(slug)\n    // Fails at the call rather than inside the first read, so the message names the verb\n    // that was wrong instead of a query that could not be built.\n    if (type) assertListable(type)\n\n    const reader: CollectionReader<Entry> = {\n      async findMany(query: CmsQuery = {}) {\n        return adapter.list(slug, { ...query, status })\n      },\n      async findBySlug(value: string) {\n        // The status goes into the lookup as well as through `visible` below. The second\n        // check is what makes a draft unreachable by guessing its URL; the first is what\n        // makes the query legal for an unauthenticated visitor, whose security rules only\n        // allow a query that says which status it wants.\n        return visible(await adapter.getBySlug(slug, value, { status }), preview)\n      },\n      async findById(entryId: string) {\n        return visible(await adapter.get(slug, entryId), preview)\n      },\n      async count(query: CmsCountQuery = {}) {\n        return adapter.count(slug, { ...query, status })\n      },\n    }\n\n    return reader as CollectionReader<EntryOf<TTypes, TSlug>>\n  }\n\n  function single<TSlug extends SlugOf<TTypes>>(\n    slug: TSlug,\n  ): SingleReader<EntryOf<TTypes, TSlug>> {\n    const type = known(slug)\n    if (type && !isSingleton(type)) {\n      throw new SingletonError(\n        type.slug,\n        `Content type \"${type.slug}\" is a collection. Read it with collection(\"${type.slug}\").findMany().`,\n      )\n    }\n\n    const reader: SingleReader<Entry> = {\n      async get() {\n        return visible(await adapter.getSingle(slug), preview)\n      },\n    }\n\n    return reader as SingleReader<EntryOf<TTypes, TSlug>>\n  }\n\n  const media: MediaReader = {\n    getById: (mediaId) => adapter.media.getById(mediaId),\n    getMany: (mediaIds) => adapter.media.getMany(mediaIds),\n  }\n\n  const settings: SettingsReader = {\n    get: (key) => adapter.settings.get(key),\n  }\n\n  return {\n    collection,\n    single,\n    media: () => media,\n    settings: () => settings,\n    isPreview: preview,\n  }\n}\n"]}

package/dist/chunk-4Z6P3XCE.js

@@ -0,0 +1,62 @@
+// src/core/errors.ts
+var SchemaError = class extends Error {
+  name = "SchemaError";
+  constructor(message) {
+    super(message);
+  }
+};
+var ValidationError = class extends Error {
+  name = "ValidationError";
+  errors;
+  constructor(errors) {
+    super(
+      errors.length === 1 && errors[0] ? `${errors[0].path}: ${errors[0].message}` : `${errors.length} fields failed validation`
+    );
+    this.errors = errors;
+  }
+};
+var LockedTypeError = class extends Error {
+  name = "LockedTypeError";
+  slug;
+  constructor(slug, reason) {
+    super(
+      reason ?? `Content type "${slug}" is locked. It is defined in code and cannot be changed through the Schema Builder or the adapter.`
+    );
+    this.slug = slug;
+  }
+};
+var SingletonError = class extends Error {
+  name = "SingletonError";
+  slug;
+  constructor(slug, message) {
+    super(message);
+    this.slug = slug;
+  }
+};
+var PermissionError = class extends Error {
+  name = "PermissionError";
+  action;
+  /** Content type slug. Absent for an action that is not scoped to one. */
+  contentType;
+  constructor(action, contentType, message) {
+    super(
+      message ?? (contentType === void 0 ? `This account may not ${action}.` : `This account may not ${action} entries of "${contentType}".`)
+    );
+    this.action = action;
+    this.contentType = contentType;
+  }
+};
+var WriteLimitError = class extends Error {
+  name = "WriteLimitError";
+  code;
+  path;
+  constructor(rejection) {
+    super(rejection.message);
+    this.code = rejection.code;
+    this.path = rejection.path;
+  }
+};
+
+export { LockedTypeError, PermissionError, SchemaError, SingletonError, ValidationError, WriteLimitError };
+//# sourceMappingURL=chunk-4Z6P3XCE.js.map
+//# sourceMappingURL=chunk-4Z6P3XCE.js.map

package/dist/chunk-4Z6P3XCE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/errors.ts"],"names":[],"mappings":";AAOO,IAAM,WAAA,GAAN,cAA0B,KAAA,CAAM;AAAA,EACnB,IAAA,GAAO,aAAA;AAAA,EAEzB,YAAY,OAAA,EAAiB;AAC3B,IAAA,KAAA,CAAM,OAAO,CAAA;AAAA,EACf;AACF;AAGO,IAAM,eAAA,GAAN,cAA8B,KAAA,CAAM;AAAA,EACvB,IAAA,GAAO,iBAAA;AAAA,EAChB,MAAA;AAAA,EAET,YAAY,MAAA,EAA+B;AACzC,IAAA,KAAA;AAAA,MACE,OAAO,MAAA,KAAW,CAAA,IAAK,OAAO,CAAC,CAAA,GAC3B,GAAG,MAAA,CAAO,CAAC,EAAE,IAAI,CAAA,EAAA,EAAK,OAAO,CAAC,CAAA,CAAE,OAAO,CAAA,CAAA,GACvC,CAAA,EAAG,OAAO,MAAM,CAAA,yBAAA;AAAA,KACtB;AACA,IAAA,IAAA,CAAK,MAAA,GAAS,MAAA;AAAA,EAChB;AACF;AAGO,IAAM,eAAA,GAAN,cAA8B,KAAA,CAAM;AAAA,EACvB,IAAA,GAAO,iBAAA;AAAA,EAChB,IAAA;AAAA,EAET,WAAA,CAAY,MAAc,MAAA,EAAiB;AACzC,IAAA,KAAA;AAAA,MACE,MAAA,IACE,iBAAiB,IAAI,CAAA,mGAAA;AAAA,KACzB;AACA,IAAA,IAAA,CAAK,IAAA,GAAO,IAAA;AAAA,EACd;AACF;AAGO,IAAM,cAAA,GAAN,cAA6B,KAAA,CAAM;AAAA,EACtB,IAAA,GAAO,gBAAA;AAAA,EAChB,IAAA;AAAA,EAET,WAAA,CAAY,MAAc,OAAA,EAAiB;AACzC,IAAA,KAAA,CAAM,OAAO,CAAA;AACb,IAAA,IAAA,CAAK,IAAA,GAAO,IAAA;AAAA,EACd;AACF;AAUO,IAAM,eAAA,GAAN,cAA8B,KAAA,CAAM;AAAA,EACvB,IAAA,GAAO,iBAAA;AAAA,EAChB,MAAA;AAAA;AAAA,EAEA,WAAA;AAAA,EAET,WAAA,CAAY,MAAA,EAAgB,WAAA,EAAsB,OAAA,EAAkB;AAClE,IAAA,KAAA;AAAA,MACE,OAAA,KACG,gBAAgB,MAAA,GACb,CAAA,qBAAA,EAAwB,MAAM,CAAA,CAAA,CAAA,GAC9B,CAAA,qBAAA,EAAwB,MAAM,CAAA,aAAA,EAAgB,WAAW,CAAA,EAAA,CAAA;AAAA,KACjE;AACA,IAAA,IAAA,CAAK,MAAA,GAAS,MAAA;AACd,IAAA,IAAA,CAAK,WAAA,GAAc,WAAA;AAAA,EACrB;AACF;AAOO,IAAM,eAAA,GAAN,cAA8B,KAAA,CAAM;AAAA,EACvB,IAAA,GAAO,iBAAA;AAAA,EAChB,IAAA;AAAA,EACA,IAAA;AAAA,EAET,YAAY,SAAA,EAA4D;AACtE,IAAA,KAAA,CAAM,UAAU,OAAO,CAAA;AACvB,IAAA,IAAA,CAAK,OAAO,SAAA,CAAU,IAAA;AACtB,IAAA,IAAA,CAAK,OAAO,SAAA,CAAU,IAAA;AAAA,EACxB;AACF","file":"chunk-4Z6P3XCE.js","sourcesContent":["import type { FieldError } from \"../types/entry.js\"\n\n/**\n * A content type, field map, or registry is malformed. Thrown at definition time, which\n * for a code-defined type means at module load, so the mistake surfaces before any data\n * is written.\n */\nexport class SchemaError extends Error {\n  override readonly name = \"SchemaError\"\n\n  constructor(message: string) {\n    super(message)\n  }\n}\n\n/** Entry data failed the compiled validator. Carries one error per offending field path. */\nexport class ValidationError extends Error {\n  override readonly name = \"ValidationError\"\n  readonly errors: readonly FieldError[]\n\n  constructor(errors: readonly FieldError[]) {\n    super(\n      errors.length === 1 && errors[0]\n        ? `${errors[0].path}: ${errors[0].message}`\n        : `${errors.length} fields failed validation`,\n    )\n    this.errors = errors\n  }\n}\n\n/** A schema write was attempted against a content type that does not accept one. */\nexport class LockedTypeError extends Error {\n  override readonly name = \"LockedTypeError\"\n  readonly slug: string\n\n  constructor(slug: string, reason?: string) {\n    super(\n      reason ??\n        `Content type \"${slug}\" is locked. It is defined in code and cannot be changed through the Schema Builder or the adapter.`,\n    )\n    this.slug = slug\n  }\n}\n\n/** A singleton was asked to hold more than the one entry it is allowed. */\nexport class SingletonError extends Error {\n  override readonly name = \"SingletonError\"\n  readonly slug: string\n\n  constructor(slug: string, message: string) {\n    super(message)\n    this.slug = slug\n  }\n}\n\n/**\n * The caller is not allowed to do this. Thrown by the adapter, from the same `can()` the\n * UI asked before it drew the button and the same matrix firestore.rules enforces.\n *\n * It exists as its own class because \"you may not\" and \"that is malformed\" need different\n * answers: a permission refusal is never fixed by editing the value. Carrying the action\n * and the content type lets a caller say which one without parsing the message.\n */\nexport class PermissionError extends Error {\n  override readonly name = \"PermissionError\"\n  readonly action: string\n  /** Content type slug. Absent for an action that is not scoped to one. */\n  readonly contentType: string | undefined\n\n  constructor(action: string, contentType?: string, message?: string) {\n    super(\n      message ??\n        (contentType === undefined\n          ? `This account may not ${action}.`\n          : `This account may not ${action} entries of \"${contentType}\".`),\n    )\n    this.action = action\n    this.contentType = contentType\n  }\n}\n\n/**\n * A write was refused for its size, its shape, or its timing rather than its content.\n * See core/write-limits.ts for which of these the security rules enforce as well and\n * which are the adapter's alone.\n */\nexport class WriteLimitError extends Error {\n  override readonly name = \"WriteLimitError\"\n  readonly code: string\n  readonly path: string\n\n  constructor(rejection: { code: string; path: string; message: string }) {\n    super(rejection.message)\n    this.code = rejection.code\n    this.path = rejection.path\n  }\n}\n"]}