@visiolab/effect-firebase 0.0.0-stage → 0.3.0

package/dist/firestore/internal/firestoreSchema.mjs

@@ -0,0 +1,123 @@
+import { isDocumentPath, makeUnchecked } from "./documentPath.mjs";
+import { arrayRemove, arrayUnion, isArrayRemove, isArrayUnion, isDeleteField, isIncrement, isServerTimestamp, serverTimestamp } from "./fieldValue.mjs";
+import { isGeoPoint } from "./geoPoint.mjs";
+import { Timestamp as Timestamp$1 } from "./timestampSchema.mjs";
+import { toCodecFirestore } from "./firestoreValue.mjs";
+import { fromPath, isDocumentReference, pattern } from "./collection.mjs";
+import { Array, Effect, Equal, Schema, SchemaGetter, SchemaIssue, SchemaParser, SchemaTransformation } from "effect";
+// src/firestore/internal/firestoreSchema.ts
+/** @internal */
+const Timestamp = Timestamp$1;
+/** @internal */
+const GeoPoint = Schema.declare(isGeoPoint, {
+	representation: {
+		id: "@visiolab/effect-firebase/firestore/GeoPoint",
+		payload: null
+	},
+	expected: "a Firestore GeoPoint",
+	toEquivalence: () => Equal.equals,
+	toCodecFirestore: () => void 0
+});
+/** @internal */
+const DocumentPath = Schema.declare(isDocumentPath, {
+	representation: {
+		id: "@visiolab/effect-firebase/firestore/DocumentPath",
+		payload: null
+	},
+	expected: "a Firestore document path",
+	toEquivalence: () => Equal.equals,
+	toCodecFirestore: () => void 0
+});
+/** @internal */
+const DocumentReference = (collection) => {
+	const pattern$1 = pattern(collection);
+	return Schema.declare((u) => isDocumentReference(u) && u.collection === collection, {
+		representation: {
+			id: "@visiolab/effect-firebase/firestore/DocumentReference",
+			payload: null
+		},
+		expected: `a reference to a document in ${pattern$1}`,
+		toEquivalence: () => Equal.equals,
+		toCodecFirestore: () => Schema.link()(DocumentPath.annotate({ expected: `a reference to a document in ${pattern$1}` }), {
+			decode: SchemaGetter.transformEffect((value, options) => Effect.fromOption(fromPath(collection, value.path)).pipe(Effect.mapError(() => new SchemaIssue.InvalidValue({ message: `Expected a document in ${pattern$1}, got "${value.path}"` }, value, options)))),
+			encode: SchemaGetter.transform((ref) => makeUnchecked(ref.path))
+		})
+	});
+};
+/** @internal */
+const ServerTimestamp = Schema.declare(isServerTimestamp, {
+	representation: {
+		id: "@visiolab/effect-firebase/firestore/FieldValue/ServerTimestamp",
+		payload: null
+	},
+	expected: "a server timestamp",
+	toCodecFirestore: () => void 0
+}).pipe(Schema.withConstructorDefault(Effect.succeed(serverTimestamp)));
+/** @internal */
+const ServerTimestampOr = (schema) => Schema.Union([schema, ServerTimestamp]);
+/** @internal */
+const Increment = Schema.declare(isIncrement, {
+	representation: {
+		id: "@visiolab/effect-firebase/firestore/FieldValue/Increment",
+		payload: null
+	},
+	expected: "an increment",
+	toEquivalence: () => Equal.equals,
+	toCodecFirestore: () => void 0
+});
+/** @internal */
+const IncrementOr = (schema) => Schema.Union([schema, Increment]);
+/** @internal */
+const DeleteField = Schema.declare(isDeleteField, {
+	representation: {
+		id: "@visiolab/effect-firebase/firestore/FieldValue/DeleteField",
+		payload: null
+	},
+	expected: "a field deletion",
+	toCodecFirestore: () => void 0
+});
+/** @internal */
+const DeleteFieldOr = (schema) => Schema.Union([DeleteField, schema]);
+/**
+* Declares a sentinel that carries elements, each of them run through `item` -
+* decoded on the way in and encoded on the way out, as `Schema.Option` does
+* with what it holds.
+*
+* Its Firestore form is the same sentinel, holding the elements in their own
+* Firestore form: `toCodecFirestore` links it to a sentinel of `item`'s derived
+* codec, so a `DateTimeUtc` among them is stored as a timestamp.
+*/
+const elementsSentinel = (name, is, make) => {
+	const declareSentinel = (item, toCodecFirestore) => Schema.declareConstructor()([item], ([item]) => {
+		const elements = Schema.Array(item);
+		return (input, ast, options) => is(input) ? SchemaParser.decodeEffect(elements)(input.elements, options).pipe(Effect.mapBothEager({
+			onSuccess: (decoded) => make(...decoded),
+			onFailure: (issue) => new SchemaIssue.Pointer(["elements"], issue)
+		})) : Effect.fail(new SchemaIssue.InvalidType(ast, input, options));
+	}, {
+		representation: {
+			id: `@visiolab/effect-firebase/firestore/FieldValue/${name}`,
+			payload: null
+		},
+		expected: `an ${name}`,
+		toCodecFirestore,
+		toEquivalence: ([item]) => {
+			const elements = Array.makeEquivalence(item);
+			return (self, that) => elements(self.elements, that.elements);
+		}
+	});
+	return (item) => declareSentinel(item, ([encoded]) => Schema.link()(declareSentinel(toCodecFirestore(encoded), () => void 0), SchemaTransformation.passthrough()));
+};
+const ArrayUnionSentinel = elementsSentinel("ArrayUnion", isArrayUnion, arrayUnion);
+/** @internal */
+const ArrayUnion = (item) => ArrayUnionSentinel(item);
+const ArrayRemoveSentinel = elementsSentinel("ArrayRemove", isArrayRemove, arrayRemove);
+/** @internal */
+const ArrayRemove = (item) => ArrayRemoveSentinel(item);
+/** @internal */
+const ArrayOr = (item) => Schema.Union([
+	Schema.Array(item),
+	ArrayUnion(item),
+	ArrayRemove(item)
+]);
+export { ArrayOr, ArrayRemove, ArrayUnion, DeleteField, DeleteFieldOr, DocumentPath, DocumentReference, GeoPoint, Increment, IncrementOr, ServerTimestamp, ServerTimestampOr, Timestamp };

package/dist/firestore/internal/firestoreValue.mjs

@@ -0,0 +1,108 @@
+import { fromMillis, toDateTime, toMillis } from "./timestamp.mjs";
+import { isFirestoreValue as isFirestoreValue$1 } from "./firestoreValueWalk.mjs";
+import { applyToSelfOrLastLinkEncodingIdempotent, keywordToCodecJson, keywordToCodecStringTree, mapLink, parameterFromString, recur, replaceContextLastLink, replaceEncoding } from "./schemaAST.mjs";
+import { Timestamp } from "./timestampSchema.mjs";
+import { DateTime, Effect, Predicate, Schema, SchemaAST, SchemaGetter, SchemaIssue, SchemaTransformation } from "effect";
+// src/firestore/internal/firestoreValue.ts
+/** @internal */
+const isFirestoreValue = isFirestoreValue$1;
+/**
+* Accepts only Firestore Values. A declaration with no link to any canonical
+* format falls back to this, so a value Firestore cannot store fails at its own
+* path instead of being stored as a map.
+*/
+const FirestoreValueSchema = Schema.declare(isFirestoreValue, {
+	expected: "a Firestore value",
+	toCodecFirestore: () => void 0
+});
+/** @internal */
+const unknownToFirestore = new SchemaAST.Link(FirestoreValueSchema.ast, SchemaTransformation.passthrough());
+const timestampFromMillis = (millis, options) => {
+	const out = fromMillis(millis);
+	return out._tag === "Some" ? Effect.succeed(out.value) : Effect.fail(new SchemaIssue.InvalidValue({ message: "Expected an instant Firestore can store, between the years 1 and 9999" }, millis, options));
+};
+const dateToTimestamp = Schema.link()(Timestamp, {
+	decode: SchemaGetter.transform((ts) => new Date(toMillis(ts))),
+	encode: SchemaGetter.transformEffect((date, options) => timestampFromMillis(date.getTime(), options))
+});
+const dateTimeUtcToTimestamp = Schema.link()(Timestamp, {
+	decode: SchemaGetter.transform(toDateTime),
+	encode: SchemaGetter.transformEffect((dateTime, options) => timestampFromMillis(DateTime.toEpochMillis(dateTime), options))
+});
+const representationId = (ast) => {
+	const representation = ast.annotations?.representation;
+	return Predicate.hasProperty(representation, "id") ? representation.id : void 0;
+};
+/**
+* Firestore's own types come first, so these win over the declaration's
+* `toCodecJson`, which would write a string.
+*/
+const nativeLink = (ast) => {
+	switch (representationId(ast)) {
+		case "effect/schema/Date": return dateToTimestamp;
+		case "effect/schema/DateTimeUtc": return dateTimeUtcToTimestamp;
+		case "effect/schema/Uint8Array": return null;
+	}
+};
+const declarationStep = (ast, recur) => {
+	const native = nativeLink(ast);
+	if (native === null) return ast;
+	if (native !== void 0) return replaceEncoding(ast, [native]);
+	const annotations = ast.annotations;
+	const getLink = [
+		annotations?.toCodecFirestore,
+		annotations?.toCodecJson,
+		annotations?.toCodec
+	].find(Predicate.isFunction);
+	if (getLink === void 0) return replaceEncoding(ast, [unknownToFirestore]);
+	const link = getLink(ast.typeParameters.map((tp) => Schema.make(SchemaAST.toEncoded(tp))));
+	return link === void 0 ? ast : replaceEncoding(ast, [mapLink(link, recur)]);
+};
+const reorderUnion = (types) => {
+	const priority = (ast) => {
+		switch (SchemaAST.toEncoded(ast)._tag) {
+			case "BigInt":
+			case "Symbol":
+			case "UniqueSymbol": return 0;
+			default: return 1;
+		}
+	};
+	const sorted = [...types].sort((a, b) => priority(a) - priority(b));
+	return sorted.some((ast, i) => ast !== types[i]) ? sorted : types;
+};
+const step = (ast, recur$1) => {
+	switch (ast._tag) {
+		case "Declaration": return declarationStep(ast, recur$1);
+		case "Any":
+		case "Unknown":
+		case "ObjectKeyword": return replaceEncoding(ast, [unknownToFirestore]);
+		case "Undefined":
+		case "Void":
+		case "Literal": return keywordToCodecJson(ast);
+		case "UniqueSymbol":
+		case "Symbol":
+		case "BigInt": return keywordToCodecStringTree(ast);
+		case "Objects":
+			if (ast.propertySignatures.some((ps) => typeof ps.name !== "string")) return replaceEncoding(ast, [unknownToFirestore]);
+			return recur(ast, recur$1, parameterFromString);
+		case "Union": {
+			const types = reorderUnion(ast.types);
+			const union = types === ast.types ? ast : new SchemaAST.Union(types, ast.options, ast.annotations, ast.checks, ast.encoding, ast.context, ast.encodingChecks);
+			return recur(union, recur$1);
+		}
+		case "Arrays":
+		case "Suspend": return recur(ast, recur$1);
+	}
+	return ast;
+};
+const withoutConstructorDefault = (context) => context.constructorDefault === void 0 ? context : new SchemaAST.Context(context.isOptional, context.isMutable, void 0, context.annotations);
+/** @internal */
+const toCodecFirestoreAST = applyToSelfOrLastLinkEncodingIdempotent((ast) => {
+	const out = step(ast, toCodecFirestoreAST);
+	const context = ast.context;
+	if (out === ast || context === void 0) return out;
+	return replaceContextLastLink(out, withoutConstructorDefault(context));
+});
+/** @internal */
+const toCodecFirestore = (schema) => Schema.make(toCodecFirestoreAST(schema.ast), { schema });
+export { isFirestoreValue, toCodecFirestore, toCodecFirestoreAST, unknownToFirestore };

package/dist/firestore/internal/firestoreValueWalk.d.mts

@@ -0,0 +1,58 @@
+import "./firestoreError.mjs";
+import { isDocumentPath } from "./documentPath.mjs";
+import { isArrayRemove, isArrayUnion, isDeleteField, isIncrement, isServerTimestamp } from "./fieldValue.mjs";
+import { isGeoPoint } from "./geoPoint.mjs";
+import { isTimestamp } from "./timestamp.mjs";
+import { FirestoreValue } from "../FirestoreValue.mjs";
+import { Result } from "effect";
+/** @internal */
+export type FieldPath = ReadonlyArray<string | number>;
+/**
+ * The kinds of Firestore Value other than scalars, arrays and maps, each with
+ * the guard that recognises it. Adding a kind here makes every SDK's
+ * {@link Writer} name it too.
+ */
+declare const kinds: {
+  readonly bytes: (u: unknown) => u is Uint8Array;
+  readonly timestamp: typeof isTimestamp;
+  readonly geoPoint: typeof isGeoPoint;
+  readonly documentPath: typeof isDocumentPath;
+  readonly serverTimestamp: typeof isServerTimestamp;
+  readonly increment: typeof isIncrement;
+  readonly deleteField: typeof isDeleteField;
+  readonly arrayUnion: typeof isArrayUnion;
+  readonly arrayRemove: typeof isArrayRemove;
+};
+type Guarded<F> = F extends ((u: unknown) => u is infer A) ? A : never;
+/**
+ * Each kind of Firestore Value that is not a scalar, array or map, by name.
+ *
+ * @internal
+ */
+export type Kinds = { readonly [K in keyof typeof kinds]: Guarded<(typeof kinds)[K]>; };
+/**
+ * Walks the value a kind holds, such as an array union's elements: `key` is
+ * where `child` sits within it.
+ *
+ * @internal
+ */
+export type Walk = (child: unknown, key: string | number) => unknown;
+/**
+ * How one SDK writes each kind of Firestore Value that is not a scalar, array
+ * or map.
+ *
+ * @internal
+ */
+export type Writer = { readonly [K in keyof Kinds]: (value: Kinds[K], walk: Walk) => unknown; };
+/**
+ * How one SDK's values read back as Firestore Values. It hands back
+ * `undefined` for a value it leaves to the walk - a scalar, array or map -
+ * and calls `fail` for one of its own it cannot read.
+ *
+ * @internal
+ */
+export type Reader = (value: object, context: {
+  readonly walk: (child: unknown, key: string | number) => FirestoreValue;
+  readonly fail: (kind: string) => never;
+}) => FirestoreValue | undefined;
+export {};

package/dist/firestore/internal/firestoreValueWalk.mjs

@@ -0,0 +1,223 @@
+import { FirestoreError } from "./firestoreError.mjs";
+import { isDocumentPath } from "./documentPath.mjs";
+import { isArrayRemove, isArrayUnion, isDeleteField, isIncrement, isServerTimestamp } from "./fieldValue.mjs";
+import { isGeoPoint } from "./geoPoint.mjs";
+import { isTimestamp } from "./timestamp.mjs";
+import { Equal, Result } from "effect";
+// src/firestore/internal/firestoreValueWalk.ts
+/**
+* The one walk over Firestore Values that the guard and both SDK mappings
+* share: the path to each value, the scalars, arrays and maps, and how a
+* value outside the union is reported. What differs per SDK is only how each
+* kind of value in {@link kinds} becomes the SDK's own, and back.
+*/
+/** @internal */
+const formatFieldPath = (path) => path.length === 0 ? "the document" : `"${path.map((key, i) => typeof key === "number" ? `[${key}]` : i === 0 ? key : `.${key}`).join("")}"`;
+/**
+* The kinds of Firestore Value other than scalars, arrays and maps, each with
+* the guard that recognises it. Adding a kind here makes every SDK's
+* {@link Writer} name it too.
+*/
+const kinds = {
+	bytes: (u) => u instanceof Uint8Array,
+	timestamp: isTimestamp,
+	geoPoint: isGeoPoint,
+	documentPath: isDocumentPath,
+	serverTimestamp: isServerTimestamp,
+	increment: isIncrement,
+	deleteField: isDeleteField,
+	arrayUnion: isArrayUnion,
+	arrayRemove: isArrayRemove
+};
+const kindNames = Object.keys(kinds);
+const kindOf = (u) => kindNames.find((kind) => kinds[kind](u));
+/** A map: a plain object whose keys are all strings. */
+const isMap = (u) => {
+	const proto = Object.getPrototypeOf(u);
+	return (proto === Object.prototype || proto === null) && Object.getOwnPropertySymbols(u).length === 0;
+};
+const describe = (u) => {
+	const name = u.constructor?.name;
+	return name === void 0 ? "an object with no prototype" : `a ${name}`;
+};
+/** A value outside the Firestore Value union, at `path`. */
+var Outside = class {
+	kind;
+	value;
+	path;
+	constructor(kind, value, path) {
+		this.kind = kind;
+		this.value = value;
+		this.path = path;
+	}
+};
+const unhandled = Symbol("unhandled");
+/**
+* Walks `value`, handing every object to `visit` first and then walking
+* arrays and maps itself. Throws {@link Outside} at the first value that is
+* none of these, or that contains itself.
+*/
+const walk = (value, visit) => {
+	const path = [];
+	const ancestors = /* @__PURE__ */ new Set();
+	const within = (child, key) => {
+		path.push(key);
+		try {
+			return go(child);
+		} finally {
+			path.pop();
+		}
+	};
+	const go = (u) => {
+		switch (typeof u) {
+			case "boolean":
+			case "number":
+			case "string": return u;
+			case "object": break;
+			default: throw new Outside(`a value of type ${typeof u}`, u, [...path]);
+		}
+		if (u === null) return u;
+		const fail = (kind) => {
+			throw new Outside(kind, u, [...path]);
+		};
+		if (ancestors.has(u)) return fail("a value that contains itself");
+		ancestors.add(u);
+		try {
+			const out = visit(u, within, fail);
+			if (out !== unhandled) return out;
+			if (Array.isArray(u)) return u.map((e, i) => within(e, i));
+			if (isMap(u)) {
+				const map = {};
+				for (const key of Object.keys(u)) map[key] = within(u[key], key);
+				return map;
+			}
+			return fail(describe(u));
+		} finally {
+			ancestors.delete(u);
+		}
+	};
+	return go(value);
+};
+const write = (value, writer) => walk(value, (u, within) => {
+	const kind = kindOf(u);
+	return kind === void 0 ? unhandled : writer[kind](u, within);
+});
+const keep = (value) => value;
+/** Builds nothing: walking with it only checks a value is a Firestore Value. */
+const checker = {
+	bytes: keep,
+	timestamp: keep,
+	geoPoint: keep,
+	documentPath: keep,
+	serverTimestamp: keep,
+	increment: keep,
+	deleteField: keep,
+	arrayUnion: (u, within) => u.elements.forEach(within),
+	arrayRemove: (u, within) => u.elements.forEach(within)
+};
+/** @internal */
+const isFirestoreValue = (u) => {
+	try {
+		write(u, checker);
+		return true;
+	} catch (e) {
+		if (e instanceof Outside) return false;
+		throw e;
+	}
+};
+/**
+* Whether two Firestore Values are the same, as Firestore would store them:
+* scalars by value, arrays and maps element by element and key by key, bytes
+* byte by byte, and every other kind as that kind tells its values apart.
+*
+* @internal
+*/
+const equals = (self, that) => {
+	if (Object.is(self, that)) return true;
+	if (typeof self !== "object" || typeof that !== "object" || self === null || that === null) return false;
+	if (Array.isArray(self) || Array.isArray(that)) return Array.isArray(self) && Array.isArray(that) && self.length === that.length && self.every((element, i) => equals(element, that[i]));
+	const kind = kindOf(self);
+	if (kind !== kindOf(that)) return false;
+	switch (kind) {
+		case void 0: return isMap(self) && isMap(that) && Object.keys(self).length === Object.keys(that).length && Object.keys(self).every((key) => Object.hasOwn(that, key) && equals(self[key], that[key]));
+		case "bytes": {
+			const a = self;
+			const b = that;
+			return a.length === b.length && a.every((byte, i) => byte === b[i]);
+		}
+		case "arrayUnion":
+		case "arrayRemove": return equals(self.elements, that.elements);
+		default: return Equal.equals(self, that);
+	}
+};
+/**
+* Turns a Firestore Value into an SDK's own value through `writer`. A value
+* outside the union is a defect, since `toCodecFirestore` only ever encodes
+* Firestore Values.
+*
+* @internal
+*/
+const toSdk = (value, writer) => {
+	try {
+		return write(value, writer);
+	} catch (e) {
+		if (!(e instanceof Outside)) throw e;
+		throw new globalThis.Error(`Cannot write ${e.kind} at ${formatFieldPath(e.path)}, which is not a Firestore Value`, { cause: e.value });
+	}
+};
+/**
+* Turns what an SDK read into a Firestore Value through `reader`, failing on
+* a value outside the union, such as a vector, and naming the field that
+* holds it.
+*
+* @internal
+*/
+const fromSdk = (value, reader) => {
+	try {
+		return Result.succeed(walk(value, (u, within, fail) => {
+			const out = reader(u, {
+				walk: within,
+				fail
+			});
+			return out === void 0 ? unhandled : out;
+		}));
+	} catch (e) {
+		if (!(e instanceof Outside)) throw e;
+		return Result.fail(new FirestoreError({
+			message: `Firestore holds ${e.kind} at ${formatFieldPath(e.path)}, which is not a Firestore Value`,
+			code: void 0,
+			cause: e.value
+		}));
+	}
+};
+/**
+* Reads what an SDK holds for the document at `path` as Firestore Values
+* through `reader`, keeping `undefined` - a document that is not there - as
+* it is.
+*
+* @internal
+*/
+const readDocument = (path, data, reader) => data === void 0 ? Result.succeed(void 0) : Result.mapError(fromSdk(data, reader), (error) => new FirestoreError({
+	message: `Failed to read the document "${path}": ${error.message}`,
+	code: void 0,
+	cause: error.cause
+}));
+/**
+* Reads Firestore Values as they are, walking into the values a kind holds,
+* so that only a value outside the union fails.
+*/
+const asIs = (u, { walk }) => {
+	const kind = kindOf(u);
+	if (kind === "arrayUnion" || kind === "arrayRemove") u.elements.forEach((element, i) => walk(element, i));
+	return kind === void 0 ? void 0 : u;
+};
+/**
+* Checks that what a backend read for the document at `path` is made of
+* Firestore Values, failing as {@link readDocument} does on one that is not.
+* It hands back `data` itself, so `undefined` - a document that is not there -
+* stays as it is.
+*
+* @internal
+*/
+const checkDocument = (path, data) => Result.map(readDocument(path, data, asIs), () => data);
+export { checkDocument, equals, formatFieldPath, fromSdk, isFirestoreValue, readDocument, toSdk };

package/dist/firestore/internal/geoPoint.d.mts

@@ -0,0 +1,4 @@
+import { GeoPoint } from "../GeoPoint.mjs";
+import { Option } from "effect";
+/** @internal */
+export declare const isGeoPoint: (u: unknown) => u is GeoPoint;

package/dist/firestore/internal/geoPoint.mjs

@@ -0,0 +1,39 @@
+import { Equal, Hash, Inspectable, Option, Predicate } from "effect";
+// src/firestore/internal/geoPoint.ts
+/** @internal */
+const TypeId = "~@visiolab/effect-firebase/firestore/GeoPoint";
+/** Kept apart from the guards below, which narrow a `number` to `never`. */
+const inLatitudeRange = (n) => Number.isFinite(n) && n >= -90 && n <= 90;
+const inLongitudeRange = (n) => Number.isFinite(n) && n >= -180 && n <= 180;
+/** @internal */
+const isGeoPoint = (u) => Predicate.hasProperty(u, "~@visiolab/effect-firebase/firestore/GeoPoint") && u["~@visiolab/effect-firebase/firestore/GeoPoint"] === "~@visiolab/effect-firebase/firestore/GeoPoint" && Predicate.hasProperty(u, "latitude") && Predicate.hasProperty(u, "longitude") && Predicate.isNumber(u.latitude) && Predicate.isNumber(u.longitude) && inLatitudeRange(u.latitude) && inLongitudeRange(u.longitude);
+const Proto = {
+	...Inspectable.BaseProto,
+	[TypeId]: TypeId,
+	toJSON() {
+		return {
+			_id: "GeoPoint",
+			latitude: this.latitude,
+			longitude: this.longitude
+		};
+	},
+	[Equal.symbol](that) {
+		return isGeoPoint(that) && this.latitude === that.latitude && this.longitude === that.longitude;
+	},
+	[Hash.symbol]() {
+		return Hash.combine(Hash.number(this.latitude), Hash.number(this.longitude));
+	}
+};
+const makeUnchecked = (latitude, longitude) => Object.assign(Object.create(Proto), {
+	latitude,
+	longitude
+});
+/** @internal */
+const makeUnsafe = (latitude, longitude) => {
+	if (!inLatitudeRange(latitude)) throw new Error(`Invalid Firestore geopoint: latitude must be a number between -90 and 90, got ${latitude}`);
+	if (!inLongitudeRange(longitude)) throw new Error(`Invalid Firestore geopoint: longitude must be a number between -180 and 180, got ${longitude}`);
+	return makeUnchecked(latitude, longitude);
+};
+/** @internal */
+const make = (latitude, longitude) => inLatitudeRange(latitude) && inLongitudeRange(longitude) ? Option.some(makeUnchecked(latitude, longitude)) : Option.none();
+export { TypeId, isGeoPoint, make, makeUnsafe };

package/dist/firestore/internal/patch.mjs

@@ -0,0 +1,19 @@
+import { Inspectable, Predicate } from "effect";
+// src/firestore/internal/patch.ts
+/** @internal */
+const ReplaceTypeId = "~@visiolab/effect-firebase/firestore/Patch/Replace";
+const ReplaceProto = {
+	...Inspectable.BaseProto,
+	[ReplaceTypeId]: ReplaceTypeId,
+	toJSON() {
+		return {
+			_id: "Replace",
+			value: Inspectable.toJson(this.value)
+		};
+	}
+};
+/** @internal */
+const isReplace = (u) => Predicate.hasProperty(u, ReplaceTypeId);
+/** @internal */
+const replace = (value) => Object.assign(Object.create(ReplaceProto), { value });
+export { ReplaceTypeId, isReplace, replace };

package/dist/firestore/internal/querySnapshot.mjs

@@ -0,0 +1,24 @@
+import { attach, extraToJson } from "./snapshotExtra.mjs";
+import { Inspectable, Predicate } from "effect";
+// src/firestore/internal/querySnapshot.ts
+/** @internal */
+const TypeId = "~@visiolab/effect-firebase/firestore/QuerySnapshot";
+/** @internal */
+const isQuerySnapshot = (u) => Predicate.hasProperty(u, TypeId);
+const QuerySnapshotProto = {
+	...Inspectable.BaseProto,
+	[TypeId]: TypeId,
+	toJSON() {
+		return {
+			_id: "QuerySnapshot",
+			docs: this.docs.map((doc) => doc.toJSON()),
+			...extraToJson(this)
+		};
+	}
+};
+/** @internal */
+const make = (docs, extra) => {
+	const self = Object.assign(Object.create(QuerySnapshotProto), { docs });
+	return attach(self, extra);
+};
+export { TypeId, isQuerySnapshot, make };

package/dist/firestore/internal/schemaAST.mjs

@@ -0,0 +1,35 @@
+import { SchemaAST } from "effect";
+// src/firestore/internal/schemaAST.ts
+/**
+* The one place this package reaches into Effect's `@internal` `SchemaAST`
+* helpers.
+*
+* Effect has no public way to define a canonical format, so deriving
+* `toCodecFirestore` the way `toCodecJson` is derived needs the same internal
+* helpers Effect uses for it (ADR 0002). They exist at runtime but are stripped
+* from Effect's type declarations, so each is typed here by hand, against the
+* pinned `effect` version. Keeping them together means a future public API for
+* canonical formats is a swap of this module only.
+*/
+const internals = SchemaAST;
+/** Replaces the encoding chain of `ast`, leaving `ast` alone when it is the same. */
+const replaceEncoding = internals.replaceEncoding;
+/** Maps the target of `link`, leaving `link` alone when the target is unchanged. */
+const mapLink = internals.mapLink;
+/** Replaces the context of the last link's target. */
+const replaceContextLastLink = internals.replaceContextLastLink;
+/**
+* Applies `f` to the node itself when it has no encoding, or to the target of
+* its last encoding link otherwise, so user transformations run first. The
+* result is memoized per node.
+*/
+const applyToSelfOrLastLinkEncodingIdempotent = internals.applyToSelfOrLastLinkEncodingIdempotent;
+/** How a canonical format reads index-signature and property keys back from strings. */
+const parameterFromString = internals.parameterFromString;
+/** The keyword's own canonical JSON codec, as `toCodecJson` derives it. */
+const keywordToCodecJson = (ast) => ast.toCodecJson();
+/** The keyword's own canonical StringTree codec, as `toCodecStringTree` derives it. */
+const keywordToCodecStringTree = (ast) => ast.toCodecStringTree();
+/** Recurs into the members of a composite node. */
+const recur = (ast, f, onKey) => ast.recur(f, onKey);
+export { applyToSelfOrLastLinkEncodingIdempotent, keywordToCodecJson, keywordToCodecStringTree, mapLink, parameterFromString, recur, replaceContextLastLink, replaceEncoding };

package/dist/firestore/internal/snapshotExtra.mjs

@@ -0,0 +1,35 @@
+import { Inspectable } from "effect";
+// src/firestore/internal/snapshotExtra.ts
+/**
+* Where a snapshot keeps the extra an SDK built it with, so that it can show
+* that extra when it prints without telling the extra's fields from its own.
+*/
+const ExtraKey = "~@visiolab/effect-firebase/firestore/SnapshotExtra";
+/**
+* `self` with the fields of `extra` on it, remembered as its extra so that
+* {@link extraToJson} shows them.
+*
+* The extra itself is held on a key that is not enumerable, so that it does
+* not show up twice: its fields are already on the snapshot.
+*
+* @internal
+*/
+const attach = (self, extra) => {
+	if (extra === void 0) return self;
+	Object.defineProperty(self, ExtraKey, { value: extra });
+	return Object.assign(self, extra);
+};
+/**
+* How the extra `self` was built with prints: each of its fields as it would
+* print on its own, or nothing when it was built without one.
+*
+* @internal
+*/
+const extraToJson = (self) => {
+	const extra = self[ExtraKey];
+	if (extra === void 0) return {};
+	const json = {};
+	for (const [key, value] of Object.entries(extra)) json[key] = Inspectable.toJson(value);
+	return json;
+};
+export { attach, extraToJson };