firestore-proto-codec 0.1.0

package/dist/codec.js

@@ -0,0 +1,484 @@
+import { create, getOption, hasOption, isMessage, ScalarType, } from "@bufbuild/protobuf";
+import { FeatureSet_FieldPresence } from "@bufbuild/protobuf/wkt";
+import { CodecError } from "./errors.js";
+import { DefaultFirestoreTypes, } from "./values.js";
+import { EnumEncoding, Kind, field as fieldOption, } from "./generated/codebinge/firestore/codec/v1/options_pb.js";
+/** Firestore's limit on the depth of fields in a map or array. */
+export const MAX_NESTING_DEPTH = 20;
+const TIMESTAMP = "google.protobuf.Timestamp";
+const DURATION = "google.protobuf.Duration";
+const LAT_LNG = "google.type.LatLng";
+const UNSUPPORTED = new Set([
+    "google.protobuf.Any",
+    "google.protobuf.Struct",
+    "google.protobuf.Value",
+    "google.protobuf.ListValue",
+    "google.protobuf.FieldMask",
+]);
+const CANONICAL_UNSIGNED = /^(0|[1-9][0-9]*)$/;
+const MAX_UINT64 = 2n ** 64n - 1n;
+const MAX_INT64 = 2n ** 63n - 1n;
+const DEFAULT_RULES = {
+    skip: false,
+    enumAsNumber: false,
+    omitWhenDefault: true,
+    unsignedAsInteger: false,
+    geoPoint: false,
+};
+/**
+ * Reads the custom options straight off the descriptor. Unlike the Dart
+ * runtime, protobuf-es keeps them, so no registration step is needed.
+ */
+function rulesFor(field) {
+    if (!hasOption(field, fieldOption))
+        return DEFAULT_RULES;
+    const o = getOption(field, fieldOption);
+    return {
+        skip: o.skip,
+        name: o.name !== "" ? o.name : undefined,
+        enumAsNumber: o.enumAs === EnumEncoding.NUMBER,
+        // Explicit presence: the intended default is true, which an implicit
+        // proto3 bool could not express.
+        omitWhenDefault: o.omitWhenDefault ?? true,
+        unsignedAsInteger: o.kind === Kind.UNSIGNED_AS_INTEGER,
+        geoPoint: o.kind === Kind.GEO_POINT,
+    };
+}
+const storedName = (field, rules) => rules.name ?? field.name;
+const isExplicit = (field) => field.presence !== FeatureSet_FieldPresence.IMPLICIT;
+/** Encodes a protobuf message as a Firestore value, and decodes it back. */
+export class FirestoreProtoCodec {
+    types;
+    constructor(types = new DefaultFirestoreTypes()) {
+        this.types = types;
+    }
+    encode(schema, message) {
+        requireMessage(schema, message);
+        return this.encodeMessage(schema, message, 1, "");
+    }
+    decode(schema, document) {
+        return this.decodeMessage(schema, document, "");
+    }
+    /** Throws if this type, or any type it reaches, cannot be encoded. */
+    validateSchema(schema) {
+        this.validate(schema, new Set(), schema.typeName);
+    }
+    // ---------------------------------------------------------------- encoding
+    encodeMessage(schema, message, depth, path) {
+        checkDepth(depth, path);
+        const out = {};
+        for (const field of schema.fields) {
+            const rules = rulesFor(field);
+            if (rules.skip)
+                continue;
+            const name = storedName(field, rules);
+            const fieldPath = path === "" ? name : `${path}.${name}`;
+            const value = readField(message, field);
+            if (field.fieldKind === "map") {
+                requireStringKeys(field, fieldPath);
+                const entries = Object.entries((value ?? {}));
+                if (entries.length === 0)
+                    continue;
+                // The map is a level of its own, and each value sits inside it.
+                checkDepth(depth + 1, fieldPath);
+                out[name] = Object.fromEntries(entries.map(([k, v]) => [
+                    k,
+                    this.encodeElement(field.scalar, field.enum, field.message, v, DEFAULT_RULES, depth + 1, `${fieldPath}.${k}`),
+                ]));
+            }
+            else if (field.fieldKind === "list") {
+                const items = (value ?? []);
+                if (items.length === 0)
+                    continue;
+                // The array is a level of its own, and each element sits inside it.
+                checkDepth(depth + 1, fieldPath);
+                out[name] = items.map((item, i) => this.encodeElement(field.scalar, field.enum, field.message, item, rules, depth + 1, `${fieldPath}[${i}]`));
+            }
+            else if (isExplicit(field)) {
+                if (value === undefined)
+                    continue;
+                out[name] = this.encodeElement(field.scalar, field.enum, field.message, value, rules, depth, fieldPath);
+            }
+            else {
+                if (rules.omitWhenDefault && isDefault(normalize64(field.scalar, value))) {
+                    continue;
+                }
+                out[name] = this.encodeElement(field.scalar, field.enum, field.message, value, rules, depth, fieldPath);
+            }
+        }
+        return out;
+    }
+    encodeElement(scalar, enumDesc, messageDesc, value, rules, depth, path) {
+        if (messageDesc !== undefined) {
+            return this.encodeMessageValue(messageDesc, value, rules, depth, path);
+        }
+        if (enumDesc !== undefined) {
+            const number = value;
+            if (rules.enumAsNumber)
+                return number;
+            const match = enumDesc.values.find((v) => v.number === number);
+            if (match === undefined) {
+                // A number with no declared name, relayed from a newer writer. Writing
+                // the integer would mix types on a String field; writing a synthetic
+                // name would decode to zero. Both are silent, so refuse (§4).
+                throw new CodecError("ENUM_VALUE_UNKNOWN", `${enumDesc.typeName} has no name for value ${number}`, path);
+            }
+            return match.name;
+        }
+        // A field annotated `jstype = JS_STRING` holds its int64 as a string;
+        // the Firestore type is still Integer (§8).
+        value = normalize64(scalar, value);
+        switch (scalar) {
+            case ScalarType.STRING:
+            case ScalarType.BOOL:
+            case ScalarType.DOUBLE:
+            case ScalarType.INT32:
+            case ScalarType.SINT32:
+            case ScalarType.SFIXED32:
+            case ScalarType.UINT32:
+            case ScalarType.FIXED32:
+                return value;
+            case ScalarType.FLOAT:
+                // protobuf-es holds a float in a number without rounding, so the same
+                // value would encode differently before and after a wire trip, and
+                // differently from Java. Round to binary32 so every path agrees.
+                return Math.fround(value);
+            case ScalarType.BYTES:
+                return this.types.blob(value);
+            case ScalarType.INT64:
+            case ScalarType.SINT64:
+            case ScalarType.SFIXED64:
+                return value;
+            case ScalarType.UINT64:
+            case ScalarType.FIXED64:
+                return this.encodeUnsigned(value, rules, path);
+            default:
+                throw new CodecError("UNSUPPORTED_TYPE", `no encoding for scalar type ${String(scalar)}`, path);
+        }
+    }
+    encodeUnsigned(value, rules, path) {
+        if (!rules.unsignedAsInteger)
+            return value.toString();
+        if (value > MAX_INT64) {
+            throw new CodecError("UNSIGNED_NOT_REPRESENTABLE", `KIND_UNSIGNED_AS_INTEGER cannot represent ${value}; ` +
+                "Firestore integers are signed 64-bit", path);
+        }
+        return value;
+    }
+    encodeMessageValue(schema, value, rules, depth, path) {
+        if (UNSUPPORTED.has(schema.typeName)) {
+            throw new CodecError("UNSUPPORTED_TYPE", `${schema.typeName} has no Firestore representation`, path);
+        }
+        requireMessage(schema, value, path);
+        const sub = value;
+        if (schema.typeName === TIMESTAMP) {
+            return this.types.timestamp(sub.seconds ?? 0n, sub.nanos ?? 0);
+        }
+        if (schema.typeName === DURATION) {
+            const seconds = sub.seconds ?? 0n;
+            const nanos = sub.nanos ?? 0;
+            return seconds * 1000000n + BigInt(Math.trunc(nanos / 1000));
+        }
+        if (schema.typeName === LAT_LNG || rules.geoPoint) {
+            const { latitude, longitude } = readLatLng(schema, sub, path);
+            return this.types.geoPoint(latitude, longitude);
+        }
+        return this.encodeMessage(schema, sub, depth + 1, path);
+    }
+    // ---------------------------------------------------------------- decoding
+    decodeMessage(schema, document, path) {
+        const message = create(schema);
+        for (const field of schema.fields) {
+            const rules = rulesFor(field);
+            if (rules.skip)
+                continue;
+            const name = storedName(field, rules);
+            const fieldPath = path === "" ? name : `${path}.${name}`;
+            if (field.fieldKind === "map")
+                requireStringKeys(field, fieldPath);
+            if (!(name in document))
+                continue;
+            const raw = document[name];
+            if (raw === undefined || raw === null)
+                continue;
+            if (field.fieldKind === "map") {
+                message[field.localName] = Object.fromEntries(Object.entries(raw).map(([k, v]) => [
+                    k,
+                    toDeclared(field, this.decodeElement(field.scalar, field.enum, field.message, v, DEFAULT_RULES, `${fieldPath}.${k}`)),
+                ]));
+            }
+            else if (field.fieldKind === "list") {
+                message[field.localName] = raw.map((item, i) => toDeclared(field, this.decodeElement(field.scalar, field.enum, field.message, item, rules, `${fieldPath}[${i}]`)));
+            }
+            else {
+                const decoded = this.decodeElement(field.scalar, field.enum, field.message, raw, rules, fieldPath);
+                // Leaving an implicit field at its default keeps a decoded message
+                // equal to one that never had it set.
+                if (!isExplicit(field) && isDefault(decoded))
+                    continue;
+                writeField(message, field, toDeclared(field, decoded));
+            }
+        }
+        return message;
+    }
+    decodeElement(scalar, enumDesc, messageDesc, raw, rules, path) {
+        if (messageDesc !== undefined) {
+            return this.decodeMessageValue(messageDesc, raw, rules, path);
+        }
+        if (enumDesc !== undefined) {
+            // An unknown name decodes to the zero value rather than throwing, so an
+            // old reader survives a document written by a newer writer.
+            const zero = enumDesc.values.find((v) => v.number === 0)?.number ?? 0;
+            // An admin SDK configured with `useBigInt: true` hands back every
+            // integer as a bigint, so a numerically-encoded enum arrives that way.
+            if (typeof raw === "number" || typeof raw === "bigint") {
+                const number = Number(raw);
+                return enumDesc.values.some((v) => v.number === number) ? number : zero;
+            }
+            return enumDesc.values.find((v) => v.name === raw)?.number ?? zero;
+        }
+        switch (scalar) {
+            case ScalarType.STRING:
+            case ScalarType.BOOL:
+                return raw;
+            case ScalarType.DOUBLE:
+                return Number(raw);
+            case ScalarType.FLOAT:
+                return Math.fround(Number(raw));
+            case ScalarType.INT32:
+            case ScalarType.SINT32:
+            case ScalarType.SFIXED32:
+            case ScalarType.UINT32:
+            case ScalarType.FIXED32:
+                return Number(raw);
+            case ScalarType.BYTES: {
+                const bytes = this.types.readBlob(raw);
+                if (bytes === undefined) {
+                    throw new CodecError("UNSUPPORTED_TYPE", "expected a blob", path);
+                }
+                return bytes;
+            }
+            case ScalarType.INT64:
+            case ScalarType.SINT64:
+            case ScalarType.SFIXED64:
+                return BigInt(raw);
+            case ScalarType.UINT64:
+            case ScalarType.FIXED64:
+                return rules.unsignedAsInteger
+                    ? BigInt(raw)
+                    : decodeUnsigned(raw, path);
+            default:
+                throw new CodecError("UNSUPPORTED_TYPE", `no decoding for scalar type ${String(scalar)}`, path);
+        }
+    }
+    decodeMessageValue(schema, raw, rules, path) {
+        if (UNSUPPORTED.has(schema.typeName)) {
+            throw new CodecError("UNSUPPORTED_TYPE", `${schema.typeName} has no Firestore representation`, path);
+        }
+        if (schema.typeName === TIMESTAMP) {
+            const ts = this.types.readTimestamp(raw);
+            if (ts === undefined) {
+                throw new CodecError("UNSUPPORTED_TYPE", "expected a timestamp", path);
+            }
+            const sub = create(schema);
+            sub.seconds = ts.seconds;
+            sub.nanos = ts.nanos;
+            return sub;
+        }
+        if (schema.typeName === DURATION) {
+            const micros = BigInt(raw);
+            const sub = create(schema);
+            sub.seconds = micros / 1000000n;
+            sub.nanos = Number(micros % 1000000n) * 1000;
+            return sub;
+        }
+        if (schema.typeName === LAT_LNG || rules.geoPoint) {
+            const point = this.types.readGeoPoint(raw);
+            if (point === undefined) {
+                throw new CodecError("UNSUPPORTED_TYPE", "expected a geo point", path);
+            }
+            const sub = create(schema);
+            for (const f of schema.fields) {
+                if (f.name === "latitude")
+                    sub[f.localName] = point.latitude;
+                if (f.name === "longitude")
+                    sub[f.localName] = point.longitude;
+            }
+            return sub;
+        }
+        return this.decodeMessage(schema, raw, path);
+    }
+    // -------------------------------------------------------------- validation
+    validate(schema, seen, path) {
+        if (seen.has(schema.typeName))
+            return;
+        seen.add(schema.typeName);
+        for (const field of schema.fields) {
+            const rules = rulesFor(field);
+            if (rules.skip)
+                continue;
+            const fieldPath = `${path}.${field.name}`;
+            if (field.fieldKind === "map")
+                requireStringKeys(field, fieldPath);
+            if (field.message !== undefined) {
+                this.validateSub(field.message, seen, fieldPath);
+            }
+        }
+    }
+    validateSub(schema, seen, path) {
+        if (UNSUPPORTED.has(schema.typeName)) {
+            throw new CodecError("UNSUPPORTED_TYPE", `${schema.typeName} has no Firestore representation`, path);
+        }
+        if (schema.typeName === TIMESTAMP ||
+            schema.typeName === DURATION ||
+            schema.typeName === LAT_LNG) {
+            return;
+        }
+        this.validate(schema, seen, path);
+    }
+}
+/** Every map and array is a level; the document itself is level 1. */
+function checkDepth(depth, path) {
+    if (depth > MAX_NESTING_DEPTH) {
+        throw new CodecError("NESTING_TOO_DEEP", `nesting exceeds Firestore's limit of ${MAX_NESTING_DEPTH} levels`, path);
+    }
+}
+/** Checked on every encode and decode, not only in validateSchema, so a
+ * caller who skips validation still cannot write stringified keys. */
+function requireStringKeys(field, path) {
+    if (field.mapKey !== ScalarType.STRING) {
+        throw new CodecError("UNSUPPORTED_MAP_KEY", "map keys must be strings; Firestore has no other key type", path);
+    }
+}
+const is64 = (scalar) => scalar === ScalarType.INT64 ||
+    scalar === ScalarType.SINT64 ||
+    scalar === ScalarType.SFIXED64 ||
+    scalar === ScalarType.UINT64 ||
+    scalar === ScalarType.FIXED64;
+/** protobuf-es holds a `jstype = JS_STRING` 64-bit field as a decimal string.
+ * The encoding is defined on the integer, so coerce before doing anything. */
+function normalize64(scalar, value) {
+    return is64(scalar) && typeof value === "string" ? BigInt(value) : value;
+}
+/** The inverse: hand a decoded 64-bit value back in the type the generated
+ * code declares, so the message compares and serializes like a native one. */
+function toDeclared(field, value) {
+    // longAsString is only declared on the scalar-valued DescField variants.
+    const asString = field.longAsString === true;
+    return asString && typeof value === "bigint" ? value.toString() : value;
+}
+/** protobuf-es models a oneof as one tagged `{ case, value }` property named
+ * after the oneof; the member has no property of its own. Assigning the member
+ * name directly leaves the oneof unset and the value invisible. */
+function writeField(message, field, value) {
+    if (field.oneof !== undefined) {
+        message[field.oneof.localName] = { case: field.localName, value };
+    }
+    else {
+        message[field.localName] = value;
+    }
+}
+/**
+ * protobuf-es stamps every message with `$typeName`. A message from another
+ * runtime has none: `protoc-gen-js` keeps its fields in a private array behind
+ * getters, so every `readField` would return undefined and the message would
+ * encode to an empty document without a word. Refuse it instead -- see the
+ * README on bridging from google-protobuf.
+ */
+function requireMessage(schema, value, path) {
+    if (isMessage(value, schema))
+        return;
+    // Naming the remedy is the point of the guard: this is the case it exists
+    // for, and it is the one case where the fix is known.
+    const remedy = isJspbMessage(value)
+        ? '; convert it first -- see "Bridging from google-protobuf" in the README'
+        : "";
+    throw new CodecError("UNSUPPORTED_TYPE", `expected a protobuf-es ${schema.typeName}, got ${describeValue(value)}${remedy}`, path);
+}
+/**
+ * A `protoc-gen-js` message, detected positively. The generated classes are
+ * anonymous, so there is no name to fall back on, and `displayName` is set
+ * only under `goog.DEBUG && !COMPILED`. These two methods are on every one.
+ */
+function isJspbMessage(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const v = value;
+    return (typeof v.serializeBinary === "function" && typeof v.toObject === "function");
+}
+function describeValue(value) {
+    if (value === null)
+        return "null";
+    if (typeof value !== "object")
+        return typeof value;
+    if (isMessage(value))
+        return value.$typeName;
+    if (isJspbMessage(value))
+        return "a google-protobuf message";
+    // An anonymous class has a name, and it is the empty string -- as
+    // uninformative as having none, and it would read as a dangling "got a ".
+    const name = value.constructor?.name;
+    return name === undefined || name === "" || name === "Object"
+        ? "a plain object"
+        : `a ${name}`;
+}
+function readField(message, field) {
+    if (field.oneof !== undefined) {
+        const holder = message[field.oneof.localName];
+        return holder?.case === field.localName ? holder.value : undefined;
+    }
+    return message[field.localName];
+}
+function readLatLng(schema, message, path) {
+    let latitude;
+    let longitude;
+    for (const f of schema.fields) {
+        if (f.name === "latitude")
+            latitude = message[f.localName] ?? 0;
+        if (f.name === "longitude")
+            longitude = message[f.localName] ?? 0;
+    }
+    if (latitude === undefined || longitude === undefined) {
+        throw new CodecError("UNSUPPORTED_TYPE", "KIND_GEO_POINT requires double fields named latitude and longitude", path);
+    }
+    if (Number.isNaN(latitude) ||
+        Number.isNaN(longitude) ||
+        latitude < -90 ||
+        latitude > 90 ||
+        longitude < -180 ||
+        longitude > 180) {
+        throw new CodecError("LATLNG_OUT_OF_RANGE", "latitude must be within [-90, 90] and longitude within [-180, 180], " +
+            `got (${latitude}, ${longitude})`, path);
+    }
+    return { latitude, longitude };
+}
+function decodeUnsigned(raw, path) {
+    if (typeof raw !== "string") {
+        throw new CodecError("UNSIGNED_MALFORMED", `expected a decimal string, got ${typeof raw}`, path);
+    }
+    if (!CANONICAL_UNSIGNED.test(raw)) {
+        throw new CodecError("UNSIGNED_MALFORMED", `not a canonical unsigned decimal (no sign, no leading zeros): "${raw}"`, path);
+    }
+    const value = BigInt(raw);
+    if (value > MAX_UINT64) {
+        throw new CodecError("UNSIGNED_OUT_OF_RANGE", `${raw} exceeds the maximum unsigned 64-bit value`, path);
+    }
+    return value;
+}
+function isDefault(value) {
+    if (value === undefined || value === null)
+        return true;
+    if (typeof value === "string")
+        return value === "";
+    if (typeof value === "boolean")
+        return !value;
+    if (typeof value === "number")
+        return value === 0;
+    if (typeof value === "bigint")
+        return value === 0n;
+    if (value instanceof Uint8Array)
+        return value.length === 0;
+    if (Array.isArray(value))
+        return value.length === 0;
+    return false;
+}

package/dist/errors.d.ts

@@ -0,0 +1,11 @@
+/** Error codes shared with the conformance suite (`testdata/manifest.json`). */
+export type CodecErrorCode = "UNSIGNED_MALFORMED" | "UNSIGNED_OUT_OF_RANGE" | "UNSIGNED_NOT_REPRESENTABLE" | "LATLNG_OUT_OF_RANGE" | "NESTING_TOO_DEEP" | "UNSUPPORTED_MAP_KEY" | "UNSUPPORTED_TYPE" | "ENUM_VALUE_UNKNOWN";
+/** Thrown for anything the encoding refuses to represent. */
+export declare class CodecError extends Error {
+    readonly code: CodecErrorCode;
+    /** Dotted field path to the offending value, when there is one. */
+    readonly path?: string | undefined;
+    constructor(code: CodecErrorCode, message: string, 
+    /** Dotted field path to the offending value, when there is one. */
+    path?: string | undefined);
+}

package/dist/errors.js

@@ -0,0 +1,13 @@
+/** Thrown for anything the encoding refuses to represent. */
+export class CodecError extends Error {
+    code;
+    path;
+    constructor(code, message, 
+    /** Dotted field path to the offending value, when there is one. */
+    path) {
+        super(path === undefined ? message : `${message} (at ${path})`);
+        this.code = code;
+        this.path = path;
+        this.name = "CodecError";
+    }
+}

package/dist/generated/codebinge/firestore/codec/v1/options_pb.d.ts

@@ -0,0 +1,105 @@
+import type { GenEnum, GenExtension, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import type { FieldOptions } from "@bufbuild/protobuf/wkt";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file codebinge/firestore/codec/v1/options.proto.
+ */
+export declare const file_codebinge_firestore_codec_v1_options: GenFile;
+/**
+ * @generated from message codebinge.firestore.codec.v1.Field
+ */
+export type Field = Message<"codebinge.firestore.codec.v1.Field"> & {
+    /**
+     * Never encoded.
+     *
+     * @generated from field: bool skip = 1;
+     */
+    skip: boolean;
+    /**
+     * Stored-name override. Exists only for adopting an existing collection;
+     * the default is the proto field name verbatim (§1).
+     *
+     * @generated from field: string name = 2;
+     */
+    name: string;
+    /**
+     * Default: encode enum values as their name string (§4).
+     *
+     * @generated from field: codebinge.firestore.codec.v1.EnumEncoding enum_as = 3;
+     */
+    enumAs: EnumEncoding;
+    /**
+     * Default true: omit singular scalar fields holding their default value (§6).
+     * Set false where an index or security rule depends on the field existing.
+     *
+     * Explicit presence is required. The intended default is true, and a proto3
+     * implicit-presence bool would not serialize `false`, leaving "set to false"
+     * indistinguishable from "not set".
+     *
+     * @generated from field: optional bool omit_when_default = 4;
+     */
+    omitWhenDefault?: boolean | undefined;
+    /**
+     * Overrides the encoding inferred from the proto type.
+     *
+     * @generated from field: codebinge.firestore.codec.v1.Kind kind = 5;
+     */
+    kind: Kind;
+};
+/**
+ * Describes the message codebinge.firestore.codec.v1.Field.
+ * Use `create(FieldSchema)` to create a new message.
+ */
+export declare const FieldSchema: GenMessage<Field>;
+/**
+ * @generated from enum codebinge.firestore.codec.v1.Kind
+ */
+export declare enum Kind {
+    /**
+     * Infer from the proto type. The default for every field.
+     *
+     * @generated from enum value: KIND_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * A project's own lat/lng message -> GeoPoint (§3.3). Not needed for
+     * google.type.LatLng, which is recognized automatically. The annotated
+     * message must have exactly two double fields named `latitude` and
+     * `longitude`.
+     *
+     * @generated from enum value: KIND_GEO_POINT = 1;
+     */
+    GEO_POINT = 1,
+    /**
+     * uint64/fixed64 -> Integer rather than String, keeping the field ordered
+     * and queryable. Throws at encode time above 2^63-1 (§2.1).
+     *
+     * @generated from enum value: KIND_UNSIGNED_AS_INTEGER = 2;
+     */
+    UNSIGNED_AS_INTEGER = 2
+}
+/**
+ * Describes the enum codebinge.firestore.codec.v1.Kind.
+ */
+export declare const KindSchema: GenEnum<Kind>;
+/**
+ * @generated from enum codebinge.firestore.codec.v1.EnumEncoding
+ */
+export declare enum EnumEncoding {
+    /**
+     * @generated from enum value: ENUM_ENCODING_NAME = 0;
+     */
+    NAME = 0,
+    /**
+     * @generated from enum value: ENUM_ENCODING_NUMBER = 1;
+     */
+    NUMBER = 1
+}
+/**
+ * Describes the enum codebinge.firestore.codec.v1.EnumEncoding.
+ */
+export declare const EnumEncodingSchema: GenEnum<EnumEncoding>;
+/**
+ * @generated from extension: codebinge.firestore.codec.v1.Field field = 50000;
+ */
+export declare const field: GenExtension<FieldOptions, Field>;

package/dist/generated/codebinge/firestore/codec/v1/options_pb.js

@@ -0,0 +1,66 @@
+// Copyright 2026 Code Binge LLC
+import { enumDesc, extDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2";
+import { file_google_protobuf_descriptor } from "@bufbuild/protobuf/wkt";
+/**
+ * Describes the file codebinge/firestore/codec/v1/options.proto.
+ */
+export const file_codebinge_firestore_codec_v1_options = /*@__PURE__*/ fileDesc("Cipjb2RlYmluZ2UvZmlyZXN0b3JlL2NvZGVjL3YxL29wdGlvbnMucHJvdG8SHGNvZGViaW5nZS5maXJlc3RvcmUuY29kZWMudjEiyAEKBUZpZWxkEgwKBHNraXAYASABKAgSDAoEbmFtZRgCIAEoCRI7CgdlbnVtX2FzGAMgASgOMiouY29kZWJpbmdlLmZpcmVzdG9yZS5jb2RlYy52MS5FbnVtRW5jb2RpbmcSHgoRb21pdF93aGVuX2RlZmF1bHQYBCABKAhIAIgBARIwCgRraW5kGAUgASgOMiIuY29kZWJpbmdlLmZpcmVzdG9yZS5jb2RlYy52MS5LaW5kQhQKEl9vbWl0X3doZW5fZGVmYXVsdCpOCgRLaW5kEhQKEEtJTkRfVU5TUEVDSUZJRUQQABISCg5LSU5EX0dFT19QT0lOVBABEhwKGEtJTkRfVU5TSUdORURfQVNfSU5URUdFUhACKkAKDEVudW1FbmNvZGluZxIWChJFTlVNX0VOQ09ESU5HX05BTUUQABIYChRFTlVNX0VOQ09ESU5HX05VTUJFUhABOloKBWZpZWxkEh0uZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucxjQhgMgASgLMiMuY29kZWJpbmdlLmZpcmVzdG9yZS5jb2RlYy52MS5GaWVsZFIFZmllbGRCJAogY29tLmNvZGViaW5nZS5maXJlc3RvcmUuY29kZWMudjFQAWIGcHJvdG8z", [file_google_protobuf_descriptor]);
+/**
+ * Describes the message codebinge.firestore.codec.v1.Field.
+ * Use `create(FieldSchema)` to create a new message.
+ */
+export const FieldSchema = /*@__PURE__*/ messageDesc(file_codebinge_firestore_codec_v1_options, 0);
+/**
+ * @generated from enum codebinge.firestore.codec.v1.Kind
+ */
+export var Kind;
+(function (Kind) {
+    /**
+     * Infer from the proto type. The default for every field.
+     *
+     * @generated from enum value: KIND_UNSPECIFIED = 0;
+     */
+    Kind[Kind["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * A project's own lat/lng message -> GeoPoint (§3.3). Not needed for
+     * google.type.LatLng, which is recognized automatically. The annotated
+     * message must have exactly two double fields named `latitude` and
+     * `longitude`.
+     *
+     * @generated from enum value: KIND_GEO_POINT = 1;
+     */
+    Kind[Kind["GEO_POINT"] = 1] = "GEO_POINT";
+    /**
+     * uint64/fixed64 -> Integer rather than String, keeping the field ordered
+     * and queryable. Throws at encode time above 2^63-1 (§2.1).
+     *
+     * @generated from enum value: KIND_UNSIGNED_AS_INTEGER = 2;
+     */
+    Kind[Kind["UNSIGNED_AS_INTEGER"] = 2] = "UNSIGNED_AS_INTEGER";
+})(Kind || (Kind = {}));
+/**
+ * Describes the enum codebinge.firestore.codec.v1.Kind.
+ */
+export const KindSchema = /*@__PURE__*/ enumDesc(file_codebinge_firestore_codec_v1_options, 0);
+/**
+ * @generated from enum codebinge.firestore.codec.v1.EnumEncoding
+ */
+export var EnumEncoding;
+(function (EnumEncoding) {
+    /**
+     * @generated from enum value: ENUM_ENCODING_NAME = 0;
+     */
+    EnumEncoding[EnumEncoding["NAME"] = 0] = "NAME";
+    /**
+     * @generated from enum value: ENUM_ENCODING_NUMBER = 1;
+     */
+    EnumEncoding[EnumEncoding["NUMBER"] = 1] = "NUMBER";
+})(EnumEncoding || (EnumEncoding = {}));
+/**
+ * Describes the enum codebinge.firestore.codec.v1.EnumEncoding.
+ */
+export const EnumEncodingSchema = /*@__PURE__*/ enumDesc(file_codebinge_firestore_codec_v1_options, 1);
+/**
+ * @generated from extension: codebinge.firestore.codec.v1.Field field = 50000;
+ */
+export const field = /*@__PURE__*/ extDesc(file_codebinge_firestore_codec_v1_options, 0);

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { FirestoreProtoCodec, MAX_NESTING_DEPTH } from "./codec.js";
+export type { FirestoreDocument } from "./codec.js";
+export { CodecError } from "./errors.js";
+export type { CodecErrorCode } from "./errors.js";
+export { DefaultFirestoreTypes, FsBlob, FsGeoPoint, FsTimestamp, } from "./values.js";
+export type { FirestoreTypes } from "./values.js";