joist-core 2.3.0 → 2.4.0

package/build/serde/temporal.d.mts

@@ -0,0 +1,44 @@
+/// <reference types="temporal-spec/global" preserve="true" />
+//#region src/serde/temporal.d.ts
+type TemporalModule = typeof import("temporal-spec");
+/**
+ * Lazily exposes Joist's native-first / polyfill-fallback Temporal detection.
+ *
+ * This is useful while the joist-orm repo itself has both pre-Node 26, and post-Node 26
+ * test coverage, b/c our CI test suite needs the same a) codegen output and b) test suites
+ * to "just work" with either Node 24/25 or Node 26, which means they can't have an explicit
+ * import to either `temporal-polyfill` or the `Temporal` global.
+ *
+ * This is exactly what Joist's internal temporal resolution was already working around, so
+ * this just exposes an `import { Temporal } from joist-orm` that lets the codegen & tests
+ * reuse the same abstraction.
+ */
+declare const Temporal: typeof globalThis.Temporal;
+/**
+ * A type-only `Temporal` namespace that merges with the `const Temporal` above.
+ *
+ * The `const` is only a value, so using `Temporal.PlainDate` / `Temporal.ZonedDateTime` as a
+ * type needs a namespace to resolve against. Node 26 has that as a global, but older Node
+ * versions don't, so `temporal-spec/global` supplies the same global namespace as a fallback.
+ */
+declare namespace Temporal {
+  type Instant = globalThis.Temporal.Instant;
+  type ZonedDateTime = globalThis.Temporal.ZonedDateTime;
+  type PlainDate = globalThis.Temporal.PlainDate;
+  type PlainTime = globalThis.Temporal.PlainTime;
+  type PlainDateTime = globalThis.Temporal.PlainDateTime;
+  type PlainYearMonth = globalThis.Temporal.PlainYearMonth;
+  type PlainMonthDay = globalThis.Temporal.PlainMonthDay;
+  type Duration = globalThis.Temporal.Duration;
+}
+/**
+ * Conditionally/dynamically requires `temporal-polyfill`.
+ *
+ * We want to avoid directly importing/requiring `temporal-polyfill` because
+ * it will introduce the dependency to all users of Joist.
+ */
+declare function maybeRequireTemporal(): TemporalModule | undefined;
+declare function requireTemporal(): TemporalModule;
+//#endregion
+export { Temporal, maybeRequireTemporal, requireTemporal };
+//# sourceMappingURL=temporal.d.mts.map

package/build/serde/temporal.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal.d.mts","names":[],"sources":["../../src/serde/temporal.ts"],"mappings":";;KAOK;;;;;;;;;;;;;cAeQ,iBAOD,WAAW;;;;;;;;kBASE;OACX,UAAU,WAAW,SAAS;OAC9B,gBAAgB,WAAW,SAAS;OACpC,YAAY,WAAW,SAAS;OAChC,YAAY,WAAW,SAAS;OAChC,gBAAgB,WAAW,SAAS;OACpC,iBAAiB,WAAW,SAAS;OACrC,gBAAgB,WAAW,SAAS;OACpC,WAAW,WAAW,SAAS;;;;;;;;iBAS7B,wBAAwB;iBA6BxB,mBAAmB"}

package/build/serde/temporal.js

@@ -0,0 +1,55 @@
+import { createRequire } from "node:module";
+//#region src/serde/temporal.ts
+const runtimeRequire = createRequire(import.meta.url);
+let temporal;
+/**
+* Lazily exposes Joist's native-first / polyfill-fallback Temporal detection.
+*
+* This is useful while the joist-orm repo itself has both pre-Node 26, and post-Node 26
+* test coverage, b/c our CI test suite needs the same a) codegen output and b) test suites
+* to "just work" with either Node 24/25 or Node 26, which means they can't have an explicit
+* import to either `temporal-polyfill` or the `Temporal` global.
+*
+* This is exactly what Joist's internal temporal resolution was already working around, so
+* this just exposes an `import { Temporal } from joist-orm` that lets the codegen & tests
+* reuse the same abstraction.
+*/
+const Temporal = new Proxy({}, { get(_target, property, receiver) {
+	return Reflect.get(requireTemporal().Temporal, property, receiver);
+} });
+/**
+* Conditionally/dynamically requires `temporal-polyfill`.
+*
+* We want to avoid directly importing/requiring `temporal-polyfill` because
+* it will introduce the dependency to all users of Joist.
+*/
+function maybeRequireTemporal() {
+	if (temporal === false) return void 0;
+	if (temporal) return temporal;
+	if ("Temporal" in global && "Intl" in global) {
+		temporal = {
+			Temporal: global.Temporal,
+			toTemporalInstant: Date.prototype.toTemporalInstant,
+			Intl: global.Intl
+		};
+		return temporal;
+	}
+	try {
+		temporal = runtimeRequire("temporal-polyfill");
+		return temporal;
+	} catch (e) {}
+	try {
+		temporal = runtimeRequire("@js-temporal/polyfill");
+		return temporal;
+	} catch (e) {}
+	temporal = false;
+}
+function requireTemporal() {
+	const temporal = maybeRequireTemporal();
+	if (!temporal) throw new Error("Unable to find a Temporal implementation");
+	return temporal;
+}
+//#endregion
+export { Temporal, maybeRequireTemporal, requireTemporal };
+
+//# sourceMappingURL=temporal.js.map

package/build/serde/temporal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal.js","names":[],"sources":["../../src/serde/temporal.ts"],"sourcesContent":["/// <reference types=\"temporal-spec/global\" preserve=\"true\" />\n\nimport { createRequire } from \"node:module\";\n\nconst runtimeRequire = createRequire(import.meta.url);\n\n// Native Temporal and both supported polyfills expose this shape; use the shared spec types instead of duplicating it.\ntype TemporalModule = typeof import(\"temporal-spec\");\nlet temporal: TemporalModule | undefined | false;\n\n/**\n * Lazily exposes Joist's native-first / polyfill-fallback Temporal detection.\n *\n * This is useful while the joist-orm repo itself has both pre-Node 26, and post-Node 26\n * test coverage, b/c our CI test suite needs the same a) codegen output and b) test suites\n * to \"just work\" with either Node 24/25 or Node 26, which means they can't have an explicit\n * import to either `temporal-polyfill` or the `Temporal` global.\n *\n * This is exactly what Joist's internal temporal resolution was already working around, so\n * this just exposes an `import { Temporal } from joist-orm` that lets the codegen & tests\n * reuse the same abstraction.\n */\nexport const Temporal = new Proxy(\n  {},\n  {\n    get(_target, property, receiver) {\n      return Reflect.get(requireTemporal().Temporal, property, receiver);\n    },\n  },\n) as typeof globalThis.Temporal;\n\n/**\n * A type-only `Temporal` namespace that merges with the `const Temporal` above.\n *\n * The `const` is only a value, so using `Temporal.PlainDate` / `Temporal.ZonedDateTime` as a\n * type needs a namespace to resolve against. Node 26 has that as a global, but older Node\n * versions don't, so `temporal-spec/global` supplies the same global namespace as a fallback.\n */\nexport declare namespace Temporal {\n  export type Instant = globalThis.Temporal.Instant;\n  export type ZonedDateTime = globalThis.Temporal.ZonedDateTime;\n  export type PlainDate = globalThis.Temporal.PlainDate;\n  export type PlainTime = globalThis.Temporal.PlainTime;\n  export type PlainDateTime = globalThis.Temporal.PlainDateTime;\n  export type PlainYearMonth = globalThis.Temporal.PlainYearMonth;\n  export type PlainMonthDay = globalThis.Temporal.PlainMonthDay;\n  export type Duration = globalThis.Temporal.Duration;\n}\n\n/**\n * Conditionally/dynamically requires `temporal-polyfill`.\n *\n * We want to avoid directly importing/requiring `temporal-polyfill` because\n * it will introduce the dependency to all users of Joist.\n */\nexport function maybeRequireTemporal(): TemporalModule | undefined {\n  // if we've already failed to find a temporal implementation before, early exit\n  if (temporal === false) return undefined;\n  // if we already required temporal, just return that\n  if (temporal) return temporal;\n  // use built in temporal if present\n  if (\"Temporal\" in global && \"Intl\" in global) {\n    temporal = {\n      Temporal: global.Temporal as typeof globalThis.Temporal,\n      toTemporalInstant: Date.prototype.toTemporalInstant,\n      Intl: global.Intl,\n    };\n    return temporal;\n  }\n  // preferentially try to use temporal-polyfill\n  try {\n    temporal = runtimeRequire(\"temporal-polyfill\");\n    return temporal as TemporalModule;\n  } catch (e) {}\n  // last resort, try to use @js-temporal/polyfill\n  try {\n    temporal = runtimeRequire(\"@js-temporal/polyfill\");\n    return temporal as TemporalModule;\n  } catch (e) {}\n  // don't try to load temporal again\n  temporal = false;\n  return undefined;\n}\n\nexport function requireTemporal(): TemporalModule {\n  const temporal = maybeRequireTemporal();\n  if (!temporal) throw new Error(\"Unable to find a Temporal implementation\");\n  return temporal;\n}\n"],"mappings":";;AAIA,MAAM,iBAAiB,cAAc,YAAY,GAAG;AAIpD,IAAI;;;;;;;;;;;;;AAcJ,MAAa,WAAW,IAAI,MAC1B,CAAC,GACD,EACE,IAAI,SAAS,UAAU,UAAU;CAC/B,OAAO,QAAQ,IAAI,gBAAgB,CAAC,CAAC,UAAU,UAAU,QAAQ;AACnE,EACF,CACF;;;;;;;AA0BA,SAAgB,uBAAmD;CAEjE,IAAI,aAAa,OAAO,OAAO,KAAA;CAE/B,IAAI,UAAU,OAAO;CAErB,IAAI,cAAc,UAAU,UAAU,QAAQ;EAC5C,WAAW;GACT,UAAU,OAAO;GACjB,mBAAmB,KAAK,UAAU;GAClC,MAAM,OAAO;EACf;EACA,OAAO;CACT;CAEA,IAAI;EACF,WAAW,eAAe,mBAAmB;EAC7C,OAAO;CACT,SAAS,GAAG,CAAC;CAEb,IAAI;EACF,WAAW,eAAe,uBAAuB;EACjD,OAAO;CACT,SAAS,GAAG,CAAC;CAEb,WAAW;AAEb;AAEA,SAAgB,kBAAkC;CAChD,MAAM,WAAW,qBAAqB;CACtC,IAAI,CAAC,UAAU,MAAM,IAAI,MAAM,0CAA0C;CACzE,OAAO;AACT"}

package/build/serde/temporalMappers.cjs

@@ -0,0 +1,62 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_serde_temporal = require("./temporal.cjs");
+const require_utils = require("../utils.cjs");
+//#region src/serde/temporalMappers.ts
+const { Temporal: t } = require_serde_temporal.maybeRequireTemporal() ?? {};
+const temporalNotAvailable = {
+	fromDb: () => require_utils.fail("Temporal not available"),
+	toDb: () => require_utils.fail("Temporal not available")
+};
+/**
+* Converts Postgres `DATE` to/from Temporal.PlainDate.
+*
+* `fromDb` accepts either pg's text form (classic/knex text queries, json_agg preloads) or an
+* already-constructed `PlainDate` (lazy binary queries decode wire bytes -> Temporal directly).
+*/
+const plainDateMapper = t ? {
+	fromDb: (value) => value instanceof t.PlainDate ? value : t.PlainDate.from(value),
+	toDb: (p) => p.toString()
+} : temporalNotAvailable;
+/** Converts Postgres `TIME` to/from Temporal.PlainTime; `fromDb` also passes binary-decoded instances through. */
+const plainTimeMapper = t ? {
+	fromDb: (value) => value instanceof t.PlainTime ? value : t.PlainTime.from(value),
+	toDb: (pt) => pt.toString()
+} : temporalNotAvailable;
+/**
+* Converts Postgres `TIMESTAMP` / `TIMESTAMP WITHOUT TIME ZONE` to/from Temporal.PlainDateTime;
+* `fromDb` also passes binary-decoded instances through.
+*/
+const plainDateTimeMapper = t ? {
+	fromDb: (value) => value instanceof t.PlainDateTime ? value : t.PlainDateTime.from(value),
+	toDb: (p) => p.toString()
+} : temporalNotAvailable;
+/**
+* Converts Postgres `TIMESTAMPTZ`, `TIMESTAMPTZ WITH TIME ZONE` to/from Temporal.ZonedDateTime.
+*
+* Specifically, Postgres uses ISO 8601, which Temporal supports as well, except that PG ouputs a space instead of `T`
+* between the date/time for output.
+*
+* Additionally, `Temporal.ZonedDateTime.from` expects a time zone literal name to be supplied as part of the string,
+* but this is not stored by postgres.
+*
+* As such, we parse the offset and append it to string passed to `from` as the time zone.  This means that if we did a
+* round trip of generating a db value then parsing it, then it may not strictly equal the original zdt.
+*
+* Finally, PG stores dates as UTC and converts them to its local time zone for output, so we could get any offset
+* theoretically.  If, somehow, we don't get an offset, then we assume UTC.
+*/
+const zonedDateTimeMapper = t ? {
+	fromDb: (value) => {
+		if (typeof value !== "string") return value;
+		const [offset] = value.match(/([+-]\d{2}(?::?\d{2})?)$/) ?? [];
+		return t.ZonedDateTime.from(`${value}[${!offset || /^\+00(:?00)?$/.test(offset) ? "UTC" : offset}]`);
+	},
+	toDb: (zdt) => zdt.toString({ timeZoneName: "never" })
+} : temporalNotAvailable;
+//#endregion
+exports.plainDateMapper = plainDateMapper;
+exports.plainDateTimeMapper = plainDateTimeMapper;
+exports.plainTimeMapper = plainTimeMapper;
+exports.zonedDateTimeMapper = zonedDateTimeMapper;
+
+//# sourceMappingURL=temporalMappers.cjs.map

package/build/serde/temporalMappers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporalMappers.cjs","names":["maybeRequireTemporal","fail"],"sources":["../../src/serde/temporalMappers.ts"],"sourcesContent":["import type { CustomSerde } from \"src/serde/serde.ts\";\nimport { type Temporal, maybeRequireTemporal } from \"src/serde/temporal.ts\";\nimport { fail } from \"src/utils.ts\";\n\nconst { Temporal: t } = maybeRequireTemporal() ?? {};\nconst temporalNotAvailable = {\n  fromDb: () => fail(\"Temporal not available\"),\n  toDb: () => fail(\"Temporal not available\"),\n};\n\n/**\n * Converts Postgres `DATE` to/from Temporal.PlainDate.\n *\n * `fromDb` accepts either pg's text form (classic/knex text queries, json_agg preloads) or an\n * already-constructed `PlainDate` (lazy binary queries decode wire bytes -> Temporal directly).\n */\nexport const plainDateMapper: CustomSerde<Temporal.PlainDate, string> = t\n  ? {\n      fromDb: (value: string | Temporal.PlainDate) => (value instanceof t.PlainDate ? value : t.PlainDate.from(value)),\n      toDb: (p) => p.toString(),\n    }\n  : temporalNotAvailable;\n\n/** Converts Postgres `TIME` to/from Temporal.PlainTime; `fromDb` also passes binary-decoded instances through. */\nexport const plainTimeMapper: CustomSerde<Temporal.PlainTime, string> = t\n  ? {\n      fromDb: (value: string | Temporal.PlainTime) => (value instanceof t.PlainTime ? value : t.PlainTime.from(value)),\n      toDb: (pt) => pt.toString(),\n    }\n  : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMP` / `TIMESTAMP WITHOUT TIME ZONE` to/from Temporal.PlainDateTime;\n * `fromDb` also passes binary-decoded instances through.\n */\nexport const plainDateTimeMapper: CustomSerde<Temporal.PlainDateTime, string> = t\n  ? {\n      // Text values look like `2018-01-01 10:00:00`\n      fromDb: (value: string | Temporal.PlainDateTime) =>\n        value instanceof t.PlainDateTime ? value : t.PlainDateTime.from(value),\n      toDb: (p) => p.toString(),\n    }\n  : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMPTZ`, `TIMESTAMPTZ WITH TIME ZONE` to/from Temporal.ZonedDateTime.\n *\n * Specifically, Postgres uses ISO 8601, which Temporal supports as well, except that PG ouputs a space instead of `T`\n * between the date/time for output.\n *\n * Additionally, `Temporal.ZonedDateTime.from` expects a time zone literal name to be supplied as part of the string,\n * but this is not stored by postgres.\n *\n * As such, we parse the offset and append it to string passed to `from` as the time zone.  This means that if we did a\n * round trip of generating a db value then parsing it, then it may not strictly equal the original zdt.\n *\n * Finally, PG stores dates as UTC and converts them to its local time zone for output, so we could get any offset\n * theoretically.  If, somehow, we don't get an offset, then we assume UTC.\n */\nexport const zonedDateTimeMapper: CustomSerde<Temporal.ZonedDateTime, string> = t\n  ? {\n      // Produce a ZDT from a PG output like \"2021-01-01 12:00:00-05:00\"; binary-decoded\n      // instances (lazy queries construct ZonedDateTimes directly) pass through\n      fromDb: (value: string | Temporal.ZonedDateTime) => {\n        if (typeof value !== \"string\") return value;\n        const [offset] = value.match(/([+-]\\d{2}(?::?\\d{2})?)$/) ?? [];\n        return t.ZonedDateTime.from(`${value}[${!offset || /^\\+00(:?00)?$/.test(offset) ? \"UTC\" : offset}]`);\n      },\n      // Match a PG `TIMESTAMPTZ` input format, i.e. \"2021-01-01T12:00:00-05:00\"\n      toDb: (zdt) => zdt.toString({ timeZoneName: \"never\" }),\n    }\n  : temporalNotAvailable;\n"],"mappings":";;;;AAIA,MAAM,EAAE,UAAU,MAAMA,uBAAAA,qBAAqB,KAAK,CAAC;AACnD,MAAM,uBAAuB;CAC3B,cAAcC,cAAAA,KAAK,wBAAwB;CAC3C,YAAYA,cAAAA,KAAK,wBAAwB;AAC3C;;;;;;;AAQA,MAAa,kBAA2D,IACpE;CACE,SAAS,UAAwC,iBAAiB,EAAE,YAAY,QAAQ,EAAE,UAAU,KAAK,KAAK;CAC9G,OAAO,MAAM,EAAE,SAAS;AAC1B,IACA;;AAGJ,MAAa,kBAA2D,IACpE;CACE,SAAS,UAAwC,iBAAiB,EAAE,YAAY,QAAQ,EAAE,UAAU,KAAK,KAAK;CAC9G,OAAO,OAAO,GAAG,SAAS;AAC5B,IACA;;;;;AAMJ,MAAa,sBAAmE,IAC5E;CAEE,SAAS,UACP,iBAAiB,EAAE,gBAAgB,QAAQ,EAAE,cAAc,KAAK,KAAK;CACvE,OAAO,MAAM,EAAE,SAAS;AAC1B,IACA;;;;;;;;;;;;;;;;AAiBJ,MAAa,sBAAmE,IAC5E;CAGE,SAAS,UAA2C;EAClD,IAAI,OAAO,UAAU,UAAU,OAAO;EACtC,MAAM,CAAC,UAAU,MAAM,MAAM,0BAA0B,KAAK,CAAC;EAC7D,OAAO,EAAE,cAAc,KAAK,GAAG,MAAM,GAAG,CAAC,UAAU,gBAAgB,KAAK,MAAM,IAAI,QAAQ,OAAO,EAAE;CACrG;CAEA,OAAO,QAAQ,IAAI,SAAS,EAAE,cAAc,QAAQ,CAAC;AACvD,IACA"}

package/build/serde/temporalMappers.d.cts

@@ -0,0 +1,36 @@
+import { Temporal } from "./temporal.cjs";
+import { CustomSerde } from "./serde.cjs";
+//#region src/serde/temporalMappers.d.ts
+/**
+ * Converts Postgres `DATE` to/from Temporal.PlainDate.
+ *
+ * `fromDb` accepts either pg's text form (classic/knex text queries, json_agg preloads) or an
+ * already-constructed `PlainDate` (lazy binary queries decode wire bytes -> Temporal directly).
+ */
+declare const plainDateMapper: CustomSerde<Temporal.PlainDate, string>;
+/** Converts Postgres `TIME` to/from Temporal.PlainTime; `fromDb` also passes binary-decoded instances through. */
+declare const plainTimeMapper: CustomSerde<Temporal.PlainTime, string>;
+/**
+ * Converts Postgres `TIMESTAMP` / `TIMESTAMP WITHOUT TIME ZONE` to/from Temporal.PlainDateTime;
+ * `fromDb` also passes binary-decoded instances through.
+ */
+declare const plainDateTimeMapper: CustomSerde<Temporal.PlainDateTime, string>;
+/**
+ * Converts Postgres `TIMESTAMPTZ`, `TIMESTAMPTZ WITH TIME ZONE` to/from Temporal.ZonedDateTime.
+ *
+ * Specifically, Postgres uses ISO 8601, which Temporal supports as well, except that PG ouputs a space instead of `T`
+ * between the date/time for output.
+ *
+ * Additionally, `Temporal.ZonedDateTime.from` expects a time zone literal name to be supplied as part of the string,
+ * but this is not stored by postgres.
+ *
+ * As such, we parse the offset and append it to string passed to `from` as the time zone.  This means that if we did a
+ * round trip of generating a db value then parsing it, then it may not strictly equal the original zdt.
+ *
+ * Finally, PG stores dates as UTC and converts them to its local time zone for output, so we could get any offset
+ * theoretically.  If, somehow, we don't get an offset, then we assume UTC.
+ */
+declare const zonedDateTimeMapper: CustomSerde<Temporal.ZonedDateTime, string>;
+//#endregion
+export { plainDateMapper, plainDateTimeMapper, plainTimeMapper, zonedDateTimeMapper };
+//# sourceMappingURL=temporalMappers.d.cts.map

package/build/serde/temporalMappers.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporalMappers.d.cts","names":[],"sources":["../../src/serde/temporalMappers.ts"],"mappings":";;;;;;;;;cAgBa,iBAAiB,YAAY,SAAS;;cAQtC,iBAAiB,YAAY,SAAS;;;;;cAWtC,qBAAqB,YAAY,SAAS;;;;;;;;;;;;;;;;cAwB1C,qBAAqB,YAAY,SAAS"}

package/build/serde/temporalMappers.d.mts

@@ -0,0 +1,36 @@
+import { Temporal } from "./temporal.mjs";
+import { CustomSerde } from "./serde.mjs";
+//#region src/serde/temporalMappers.d.ts
+/**
+ * Converts Postgres `DATE` to/from Temporal.PlainDate.
+ *
+ * `fromDb` accepts either pg's text form (classic/knex text queries, json_agg preloads) or an
+ * already-constructed `PlainDate` (lazy binary queries decode wire bytes -> Temporal directly).
+ */
+declare const plainDateMapper: CustomSerde<Temporal.PlainDate, string>;
+/** Converts Postgres `TIME` to/from Temporal.PlainTime; `fromDb` also passes binary-decoded instances through. */
+declare const plainTimeMapper: CustomSerde<Temporal.PlainTime, string>;
+/**
+ * Converts Postgres `TIMESTAMP` / `TIMESTAMP WITHOUT TIME ZONE` to/from Temporal.PlainDateTime;
+ * `fromDb` also passes binary-decoded instances through.
+ */
+declare const plainDateTimeMapper: CustomSerde<Temporal.PlainDateTime, string>;
+/**
+ * Converts Postgres `TIMESTAMPTZ`, `TIMESTAMPTZ WITH TIME ZONE` to/from Temporal.ZonedDateTime.
+ *
+ * Specifically, Postgres uses ISO 8601, which Temporal supports as well, except that PG ouputs a space instead of `T`
+ * between the date/time for output.
+ *
+ * Additionally, `Temporal.ZonedDateTime.from` expects a time zone literal name to be supplied as part of the string,
+ * but this is not stored by postgres.
+ *
+ * As such, we parse the offset and append it to string passed to `from` as the time zone.  This means that if we did a
+ * round trip of generating a db value then parsing it, then it may not strictly equal the original zdt.
+ *
+ * Finally, PG stores dates as UTC and converts them to its local time zone for output, so we could get any offset
+ * theoretically.  If, somehow, we don't get an offset, then we assume UTC.
+ */
+declare const zonedDateTimeMapper: CustomSerde<Temporal.ZonedDateTime, string>;
+//#endregion
+export { plainDateMapper, plainDateTimeMapper, plainTimeMapper, zonedDateTimeMapper };
+//# sourceMappingURL=temporalMappers.d.mts.map

package/build/serde/temporalMappers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporalMappers.d.mts","names":[],"sources":["../../src/serde/temporalMappers.ts"],"mappings":";;;;;;;;;cAgBa,iBAAiB,YAAY,SAAS;;cAQtC,iBAAiB,YAAY,SAAS;;;;;cAWtC,qBAAqB,YAAY,SAAS;;;;;;;;;;;;;;;;cAwB1C,qBAAqB,YAAY,SAAS"}

package/build/serde/temporalMappers.js

@@ -0,0 +1,58 @@
+import { maybeRequireTemporal } from "./temporal.js";
+import { fail } from "../utils.js";
+//#region src/serde/temporalMappers.ts
+const { Temporal: t } = maybeRequireTemporal() ?? {};
+const temporalNotAvailable = {
+	fromDb: () => fail("Temporal not available"),
+	toDb: () => fail("Temporal not available")
+};
+/**
+* Converts Postgres `DATE` to/from Temporal.PlainDate.
+*
+* `fromDb` accepts either pg's text form (classic/knex text queries, json_agg preloads) or an
+* already-constructed `PlainDate` (lazy binary queries decode wire bytes -> Temporal directly).
+*/
+const plainDateMapper = t ? {
+	fromDb: (value) => value instanceof t.PlainDate ? value : t.PlainDate.from(value),
+	toDb: (p) => p.toString()
+} : temporalNotAvailable;
+/** Converts Postgres `TIME` to/from Temporal.PlainTime; `fromDb` also passes binary-decoded instances through. */
+const plainTimeMapper = t ? {
+	fromDb: (value) => value instanceof t.PlainTime ? value : t.PlainTime.from(value),
+	toDb: (pt) => pt.toString()
+} : temporalNotAvailable;
+/**
+* Converts Postgres `TIMESTAMP` / `TIMESTAMP WITHOUT TIME ZONE` to/from Temporal.PlainDateTime;
+* `fromDb` also passes binary-decoded instances through.
+*/
+const plainDateTimeMapper = t ? {
+	fromDb: (value) => value instanceof t.PlainDateTime ? value : t.PlainDateTime.from(value),
+	toDb: (p) => p.toString()
+} : temporalNotAvailable;
+/**
+* Converts Postgres `TIMESTAMPTZ`, `TIMESTAMPTZ WITH TIME ZONE` to/from Temporal.ZonedDateTime.
+*
+* Specifically, Postgres uses ISO 8601, which Temporal supports as well, except that PG ouputs a space instead of `T`
+* between the date/time for output.
+*
+* Additionally, `Temporal.ZonedDateTime.from` expects a time zone literal name to be supplied as part of the string,
+* but this is not stored by postgres.
+*
+* As such, we parse the offset and append it to string passed to `from` as the time zone.  This means that if we did a
+* round trip of generating a db value then parsing it, then it may not strictly equal the original zdt.
+*
+* Finally, PG stores dates as UTC and converts them to its local time zone for output, so we could get any offset
+* theoretically.  If, somehow, we don't get an offset, then we assume UTC.
+*/
+const zonedDateTimeMapper = t ? {
+	fromDb: (value) => {
+		if (typeof value !== "string") return value;
+		const [offset] = value.match(/([+-]\d{2}(?::?\d{2})?)$/) ?? [];
+		return t.ZonedDateTime.from(`${value}[${!offset || /^\+00(:?00)?$/.test(offset) ? "UTC" : offset}]`);
+	},
+	toDb: (zdt) => zdt.toString({ timeZoneName: "never" })
+} : temporalNotAvailable;
+//#endregion
+export { plainDateMapper, plainDateTimeMapper, plainTimeMapper, zonedDateTimeMapper };
+
+//# sourceMappingURL=temporalMappers.js.map

package/build/serde/temporalMappers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporalMappers.js","names":[],"sources":["../../src/serde/temporalMappers.ts"],"sourcesContent":["import type { CustomSerde } from \"src/serde/serde.ts\";\nimport { type Temporal, maybeRequireTemporal } from \"src/serde/temporal.ts\";\nimport { fail } from \"src/utils.ts\";\n\nconst { Temporal: t } = maybeRequireTemporal() ?? {};\nconst temporalNotAvailable = {\n  fromDb: () => fail(\"Temporal not available\"),\n  toDb: () => fail(\"Temporal not available\"),\n};\n\n/**\n * Converts Postgres `DATE` to/from Temporal.PlainDate.\n *\n * `fromDb` accepts either pg's text form (classic/knex text queries, json_agg preloads) or an\n * already-constructed `PlainDate` (lazy binary queries decode wire bytes -> Temporal directly).\n */\nexport const plainDateMapper: CustomSerde<Temporal.PlainDate, string> = t\n  ? {\n      fromDb: (value: string | Temporal.PlainDate) => (value instanceof t.PlainDate ? value : t.PlainDate.from(value)),\n      toDb: (p) => p.toString(),\n    }\n  : temporalNotAvailable;\n\n/** Converts Postgres `TIME` to/from Temporal.PlainTime; `fromDb` also passes binary-decoded instances through. */\nexport const plainTimeMapper: CustomSerde<Temporal.PlainTime, string> = t\n  ? {\n      fromDb: (value: string | Temporal.PlainTime) => (value instanceof t.PlainTime ? value : t.PlainTime.from(value)),\n      toDb: (pt) => pt.toString(),\n    }\n  : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMP` / `TIMESTAMP WITHOUT TIME ZONE` to/from Temporal.PlainDateTime;\n * `fromDb` also passes binary-decoded instances through.\n */\nexport const plainDateTimeMapper: CustomSerde<Temporal.PlainDateTime, string> = t\n  ? {\n      // Text values look like `2018-01-01 10:00:00`\n      fromDb: (value: string | Temporal.PlainDateTime) =>\n        value instanceof t.PlainDateTime ? value : t.PlainDateTime.from(value),\n      toDb: (p) => p.toString(),\n    }\n  : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMPTZ`, `TIMESTAMPTZ WITH TIME ZONE` to/from Temporal.ZonedDateTime.\n *\n * Specifically, Postgres uses ISO 8601, which Temporal supports as well, except that PG ouputs a space instead of `T`\n * between the date/time for output.\n *\n * Additionally, `Temporal.ZonedDateTime.from` expects a time zone literal name to be supplied as part of the string,\n * but this is not stored by postgres.\n *\n * As such, we parse the offset and append it to string passed to `from` as the time zone.  This means that if we did a\n * round trip of generating a db value then parsing it, then it may not strictly equal the original zdt.\n *\n * Finally, PG stores dates as UTC and converts them to its local time zone for output, so we could get any offset\n * theoretically.  If, somehow, we don't get an offset, then we assume UTC.\n */\nexport const zonedDateTimeMapper: CustomSerde<Temporal.ZonedDateTime, string> = t\n  ? {\n      // Produce a ZDT from a PG output like \"2021-01-01 12:00:00-05:00\"; binary-decoded\n      // instances (lazy queries construct ZonedDateTimes directly) pass through\n      fromDb: (value: string | Temporal.ZonedDateTime) => {\n        if (typeof value !== \"string\") return value;\n        const [offset] = value.match(/([+-]\\d{2}(?::?\\d{2})?)$/) ?? [];\n        return t.ZonedDateTime.from(`${value}[${!offset || /^\\+00(:?00)?$/.test(offset) ? \"UTC\" : offset}]`);\n      },\n      // Match a PG `TIMESTAMPTZ` input format, i.e. \"2021-01-01T12:00:00-05:00\"\n      toDb: (zdt) => zdt.toString({ timeZoneName: \"never\" }),\n    }\n  : temporalNotAvailable;\n"],"mappings":";;;AAIA,MAAM,EAAE,UAAU,MAAM,qBAAqB,KAAK,CAAC;AACnD,MAAM,uBAAuB;CAC3B,cAAc,KAAK,wBAAwB;CAC3C,YAAY,KAAK,wBAAwB;AAC3C;;;;;;;AAQA,MAAa,kBAA2D,IACpE;CACE,SAAS,UAAwC,iBAAiB,EAAE,YAAY,QAAQ,EAAE,UAAU,KAAK,KAAK;CAC9G,OAAO,MAAM,EAAE,SAAS;AAC1B,IACA;;AAGJ,MAAa,kBAA2D,IACpE;CACE,SAAS,UAAwC,iBAAiB,EAAE,YAAY,QAAQ,EAAE,UAAU,KAAK,KAAK;CAC9G,OAAO,OAAO,GAAG,SAAS;AAC5B,IACA;;;;;AAMJ,MAAa,sBAAmE,IAC5E;CAEE,SAAS,UACP,iBAAiB,EAAE,gBAAgB,QAAQ,EAAE,cAAc,KAAK,KAAK;CACvE,OAAO,MAAM,EAAE,SAAS;AAC1B,IACA;;;;;;;;;;;;;;;;AAiBJ,MAAa,sBAAmE,IAC5E;CAGE,SAAS,UAA2C;EAClD,IAAI,OAAO,UAAU,UAAU,OAAO;EACtC,MAAM,CAAC,UAAU,MAAM,MAAM,0BAA0B,KAAK,CAAC;EAC7D,OAAO,EAAE,cAAc,KAAK,GAAG,MAAM,GAAG,CAAC,UAAU,gBAAgB,KAAK,MAAM,IAAI,QAAQ,OAAO,EAAE;CACrG;CAEA,OAAO,QAAQ,IAAI,SAAS,EAAE,cAAc,QAAQ,CAAC;AACvD,IACA"}

package/build/trusted.cjs

@@ -0,0 +1,16 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/trusted.ts
+const trustedContext = new (require("async_hooks")).AsyncLocalStorage();
+/** Returns true if we're inside a trusted context, i.e. hooks, reactions, validations, or defaults. */
+function isInTrustedContext() {
+	return trustedContext.getStore() === true;
+}
+/** Runs the given function within a trusted context. */
+function runInTrustedContext(fn) {
+	return trustedContext.run(true, fn);
+}
+//#endregion
+exports.isInTrustedContext = isInTrustedContext;
+exports.runInTrustedContext = runInTrustedContext;
+
+//# sourceMappingURL=trusted.cjs.map

package/build/trusted.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trusted.cjs","names":["AsyncLocalStorage"],"sources":["../src/trusted.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"async_hooks\";\n\nconst trustedContext = new AsyncLocalStorage<boolean>();\n\n/** Returns true if we're inside a trusted context, i.e. hooks, reactions, validations, or defaults. */\nexport function isInTrustedContext(): boolean {\n  return trustedContext.getStore() === true;\n}\n\n/** Runs the given function within a trusted context. */\nexport function runInTrustedContext<T>(fn: () => T): T {\n  return trustedContext.run(true, fn);\n}\n"],"mappings":";;AAEA,MAAM,iBAAiB,0BAAIA,EAAAA,CAAAA,kBAA2B;;AAGtD,SAAgB,qBAA8B;CAC5C,OAAO,eAAe,SAAS,MAAM;AACvC;;AAGA,SAAgB,oBAAuB,IAAgB;CACrD,OAAO,eAAe,IAAI,MAAM,EAAE;AACpC"}

package/build/trusted.d.cts

@@ -0,0 +1,8 @@
+//#region src/trusted.d.ts
+/** Returns true if we're inside a trusted context, i.e. hooks, reactions, validations, or defaults. */
+declare function isInTrustedContext(): boolean;
+/** Runs the given function within a trusted context. */
+declare function runInTrustedContext<T>(fn: () => T): T;
+//#endregion
+export { isInTrustedContext, runInTrustedContext };
+//# sourceMappingURL=trusted.d.cts.map

package/build/trusted.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trusted.d.cts","names":[],"sources":["../src/trusted.ts"],"mappings":";;iBAKgB;;iBAKA,oBAAoB,GAAG,UAAU,IAAI"}

package/build/trusted.d.mts

@@ -0,0 +1,8 @@
+//#region src/trusted.d.ts
+/** Returns true if we're inside a trusted context, i.e. hooks, reactions, validations, or defaults. */
+declare function isInTrustedContext(): boolean;
+/** Runs the given function within a trusted context. */
+declare function runInTrustedContext<T>(fn: () => T): T;
+//#endregion
+export { isInTrustedContext, runInTrustedContext };
+//# sourceMappingURL=trusted.d.mts.map

package/build/trusted.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trusted.d.mts","names":[],"sources":["../src/trusted.ts"],"mappings":";;iBAKgB;;iBAKA,oBAAoB,GAAG,UAAU,IAAI"}

package/build/trusted.js

@@ -1,15 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isInTrustedContext = isInTrustedContext;
-exports.runInTrustedContext = runInTrustedContext;
-const async_hooks_1 = require("async_hooks");
-const trustedContext = new async_hooks_1.AsyncLocalStorage();
+import { AsyncLocalStorage } from "async_hooks";
+//#region src/trusted.ts
+const trustedContext = new AsyncLocalStorage();
 /** Returns true if we're inside a trusted context, i.e. hooks, reactions, validations, or defaults. */
 function isInTrustedContext() {
-    return trustedContext.getStore() === true;
+	return trustedContext.getStore() === true;
 }
 /** Runs the given function within a trusted context. */
 function runInTrustedContext(fn) {
-    return trustedContext.run(true, fn);
+	return trustedContext.run(true, fn);
 }
+//#endregion
+export { isInTrustedContext, runInTrustedContext };
+
 //# sourceMappingURL=trusted.js.map

package/build/trusted.js.map

@@ -1 +1 @@
-{"version":3,"file":"trusted.js","sourceRoot":"","sources":["../src/trusted.ts"],"names":[],"mappings":";;AAKA,gDAEC;AAGD,kDAEC;AAZD,6CAAgD;AAEhD,MAAM,cAAc,GAAG,IAAI,+BAAiB,EAAW,CAAC;AAExD,uGAAuG;AACvG,SAAgB,kBAAkB;IAChC,OAAO,cAAc,CAAC,QAAQ,EAAE,KAAK,IAAI,CAAC;AAC5C,CAAC;AAED,wDAAwD;AACxD,SAAgB,mBAAmB,CAAI,EAAW;IAChD,OAAO,cAAc,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;AACtC,CAAC"}
+{"version":3,"file":"trusted.js","names":[],"sources":["../src/trusted.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"async_hooks\";\n\nconst trustedContext = new AsyncLocalStorage<boolean>();\n\n/** Returns true if we're inside a trusted context, i.e. hooks, reactions, validations, or defaults. */\nexport function isInTrustedContext(): boolean {\n  return trustedContext.getStore() === true;\n}\n\n/** Runs the given function within a trusted context. */\nexport function runInTrustedContext<T>(fn: () => T): T {\n  return trustedContext.run(true, fn);\n}\n"],"mappings":";;AAEA,MAAM,iBAAiB,IAAI,kBAA2B;;AAGtD,SAAgB,qBAA8B;CAC5C,OAAO,eAAe,SAAS,MAAM;AACvC;;AAGA,SAAgB,oBAAuB,IAAgB;CACrD,OAAO,eAAe,IAAI,MAAM,EAAE;AACpC"}

package/build/typeMap.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./EntityManager.cjs");
+require("./Entity.cjs");

package/build/typeMap.d.cts

@@ -0,0 +1,88 @@
+import { EntityManager } from "./EntityManager.cjs";
+import { Entity } from "./Entity.cjs";
+//#region src/typeMap.d.ts
+/**
+ * Provides a container for entities to attach their application-specific types.
+ *
+ * Downstream applications inject their types into this map, so we can look them up
+ * via types like `OptsOf<Author>` or `FilterOf<Author>`, by including a `declare module`
+ * snippet in each entity's `...Codegen` file.
+ *
+ * ```ts
+ * declare module "joist-core" {
+ *   interface TypeMap {
+ *     Author: { optsType: AuthorOpts; fieldsType: AuthorFields; columnsType: AuthorColumns; filterType: AuthorFilter };
+ *   }
+ * }
+ * ```
+ *
+ * Inspired by Tanstack Router, which uses a similar `declare module` approach.
+ */
+interface TypeMap {}
+/**
+ * Returns a key like `"Author"` or `"SmallPublisher"` for looking up types in the `TypeMap`.
+ *
+ * This is currently hard-coded to look for two levels of inheritance: we probe for the subtype
+ * key (1) first, and then fallback on the base type key (0) that all entities will have.
+ */
+type TypeMapKey<T> = T extends {
+  __type: {
+    1: infer K;
+  };
+} ? K : T extends {
+  __type: {
+    0: infer K;
+  };
+} ? K : never;
+/** The literal type name of an entity, i.e. `"Author"` or `"SmallPublisher"`. */
+type TypeNameOf<T> = TypeMapKey<T>;
+/**
+ * The literal type name of an entity's root type, i.e. `"Publisher"` for both `Publisher` and
+ * `SmallPublisher`.
+ *
+ * `em.query` uses it as an alias's default source key, so that `Alias<SmallPublisher>` stays assignable to
+ * `Alias<Publisher>` (codegen'd subtype filters extend their base filters) and a CTI subtype alias and
+ * its base alias share one nullability identity, which they should, being one table family.
+ *
+ * A type without `__type` (i.e. the bare `Entity` interface in generic code like `Scope<T>`) gets the
+ * untracked key `string`, not `never`: `never` means "source-less" and also broke the comparability of
+ * `Alias<T>` with `Alias<Entity>`.
+ */
+type RootTypeNameOf<T> = T extends {
+  __type: {
+    0: infer K extends string;
+  };
+} ? K : string;
+/** A helper type to look up `U` in the `TypeMap` for a given entity type `T`. */
+type TypeMapEntry<T, U extends string> = TypeMapKey<T> extends (infer K) ? K extends keyof TypeMap ? U extends keyof TypeMap[K] ? TypeMap[K][U] : unknown : unknown : unknown;
+/** Return the `FooOpts` type for the given `Foo` entity. */
+type OptsOf<T> = TypeMapEntry<T, "optsType">;
+/** Return the `FooFields` type for the given `Foo` entity. */
+type FieldsOf<T> = TypeMapEntry<T, "fieldsType">;
+/** Return the physical `FooColumns` type for the given `Foo` entity. */
+type ColumnsOf<T> = TypeMapEntry<T, "columnsType">;
+/** Returns the inheritance strategy, or never for non-inherited entities. */
+type InheritanceTypeOf<T> = TypeMapEntry<T, "inheritanceType">;
+type OptIdsOf<T> = TypeMapEntry<T, "optIdsType">;
+/** Pulls the entity query type out of a given entity type T. */
+type FilterOf<T> = TypeMapEntry<T, "filterType">;
+/** Pulls the entity GraphQL query type out of a given entity type T. */
+type GraphQLFilterOf<T> = TypeMapEntry<T, "gqlFilterType">;
+/** Pulls the entity order type out of a given entity type T. */
+type OrderOf<T> = TypeMapEntry<T, "orderType">;
+/** Returns the factory "extras" type, like `withDerivedField`. */
+type FactoryExtrasOf<T> = TypeMapEntry<T, "factoryExtrasType">;
+/**
+ * Returns the opts of the entity's `newEntity` factory method, as exists in the actual file.
+ *
+ * This is because `FactoryOpts` is a set of defaults, but the user can customize it if they want.
+ */
+type ActualFactoryOpts<T> = TypeMapEntry<T, "factoryOptsType">;
+/** Return the `Foo` type for a given `Foo` entity constructor. */
+type EntityOf<C> = C extends (new (em: EntityManager, opts: any) => infer T) ? T : never;
+type RelationsKeysOf<T> = { [K in keyof OptsOf<T>]: OptsOf<T>[K] extends Entity[] | undefined ? K : never; }[keyof OptsOf<T>];
+/** Return the Relation keys from `FooOpt` type, given a `Foo` entity */
+type RelationsOf<T extends Entity> = { [K in RelationsKeysOf<T>]: NonNullable<OptsOf<T>[K]>; };
+//#endregion
+export { ActualFactoryOpts, ColumnsOf, EntityOf, FactoryExtrasOf, FieldsOf, FilterOf, GraphQLFilterOf, InheritanceTypeOf, OptIdsOf, OptsOf, OrderOf, RelationsOf, RootTypeNameOf, TypeMap, TypeMapEntry, TypeNameOf };
+//# sourceMappingURL=typeMap.d.cts.map

package/build/typeMap.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeMap.d.cts","names":[],"sources":["../src/typeMap.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAoBiB;;;;;;;KAQZ,WAAW,KAAK;EAAY;IAAU,SAAS;;IAAQ,IAAI;EAAY;IAAU,SAAS;;IAAQ;;KAG3F,WAAW,KAAK,WAAW;;;;;;;;;;;;;KAc3B,eAAe,KAAK;EAAY;IAAU,SAAS;;IAAuB;;KAG1E,aAAa,GAAG,oBAC1B,WAAW,kBAAiB,KACxB,gBAAgB,UACd,gBAAgB,QAAQ,KACtB,QAAQ,GAAG;;KAMT,OAAO,KAAK,aAAa;;KAGzB,SAAS,KAAK,aAAa;;KAG3B,UAAU,KAAK,aAAa;;KAG5B,kBAAkB,KAAK,aAAa;KAEpC,SAAS,KAAK,aAAa;;KAG3B,SAAS,KAAK,aAAa;;KAG3B,gBAAgB,KAAK,aAAa;;KAGlC,QAAQ,KAAK,aAAa;;KAG1B,gBAAgB,KAAK,aAAa;;;;;;KAOlC,kBAAkB,KAAK,aAAa;;KAGpC,SAAS,KAAK,gBAAe,IAAI,eAAe,oBAAoB,KAAI;KAE/E,gBAAgB,QAClB,WAAW,OAAO,KAAK,OAAO,GAAG,WAAW,uBAAuB,mBAC9D,OAAO;;KAGH,YAAY,UAAU,aAC/B,KAAK,gBAAgB,KAAK,YAAY,OAAO,GAAG"}

package/build/typeMap.d.mts

@@ -0,0 +1,88 @@
+import { EntityManager } from "./EntityManager.mjs";
+import { Entity } from "./Entity.mjs";
+//#region src/typeMap.d.ts
+/**
+ * Provides a container for entities to attach their application-specific types.
+ *
+ * Downstream applications inject their types into this map, so we can look them up
+ * via types like `OptsOf<Author>` or `FilterOf<Author>`, by including a `declare module`
+ * snippet in each entity's `...Codegen` file.
+ *
+ * ```ts
+ * declare module "joist-core" {
+ *   interface TypeMap {
+ *     Author: { optsType: AuthorOpts; fieldsType: AuthorFields; columnsType: AuthorColumns; filterType: AuthorFilter };
+ *   }
+ * }
+ * ```
+ *
+ * Inspired by Tanstack Router, which uses a similar `declare module` approach.
+ */
+interface TypeMap {}
+/**
+ * Returns a key like `"Author"` or `"SmallPublisher"` for looking up types in the `TypeMap`.
+ *
+ * This is currently hard-coded to look for two levels of inheritance: we probe for the subtype
+ * key (1) first, and then fallback on the base type key (0) that all entities will have.
+ */
+type TypeMapKey<T> = T extends {
+  __type: {
+    1: infer K;
+  };
+} ? K : T extends {
+  __type: {
+    0: infer K;
+  };
+} ? K : never;
+/** The literal type name of an entity, i.e. `"Author"` or `"SmallPublisher"`. */
+type TypeNameOf<T> = TypeMapKey<T>;
+/**
+ * The literal type name of an entity's root type, i.e. `"Publisher"` for both `Publisher` and
+ * `SmallPublisher`.
+ *
+ * `em.query` uses it as an alias's default source key, so that `Alias<SmallPublisher>` stays assignable to
+ * `Alias<Publisher>` (codegen'd subtype filters extend their base filters) and a CTI subtype alias and
+ * its base alias share one nullability identity, which they should, being one table family.
+ *
+ * A type without `__type` (i.e. the bare `Entity` interface in generic code like `Scope<T>`) gets the
+ * untracked key `string`, not `never`: `never` means "source-less" and also broke the comparability of
+ * `Alias<T>` with `Alias<Entity>`.
+ */
+type RootTypeNameOf<T> = T extends {
+  __type: {
+    0: infer K extends string;
+  };
+} ? K : string;
+/** A helper type to look up `U` in the `TypeMap` for a given entity type `T`. */
+type TypeMapEntry<T, U extends string> = TypeMapKey<T> extends (infer K) ? K extends keyof TypeMap ? U extends keyof TypeMap[K] ? TypeMap[K][U] : unknown : unknown : unknown;
+/** Return the `FooOpts` type for the given `Foo` entity. */
+type OptsOf<T> = TypeMapEntry<T, "optsType">;
+/** Return the `FooFields` type for the given `Foo` entity. */
+type FieldsOf<T> = TypeMapEntry<T, "fieldsType">;
+/** Return the physical `FooColumns` type for the given `Foo` entity. */
+type ColumnsOf<T> = TypeMapEntry<T, "columnsType">;
+/** Returns the inheritance strategy, or never for non-inherited entities. */
+type InheritanceTypeOf<T> = TypeMapEntry<T, "inheritanceType">;
+type OptIdsOf<T> = TypeMapEntry<T, "optIdsType">;
+/** Pulls the entity query type out of a given entity type T. */
+type FilterOf<T> = TypeMapEntry<T, "filterType">;
+/** Pulls the entity GraphQL query type out of a given entity type T. */
+type GraphQLFilterOf<T> = TypeMapEntry<T, "gqlFilterType">;
+/** Pulls the entity order type out of a given entity type T. */
+type OrderOf<T> = TypeMapEntry<T, "orderType">;
+/** Returns the factory "extras" type, like `withDerivedField`. */
+type FactoryExtrasOf<T> = TypeMapEntry<T, "factoryExtrasType">;
+/**
+ * Returns the opts of the entity's `newEntity` factory method, as exists in the actual file.
+ *
+ * This is because `FactoryOpts` is a set of defaults, but the user can customize it if they want.
+ */
+type ActualFactoryOpts<T> = TypeMapEntry<T, "factoryOptsType">;
+/** Return the `Foo` type for a given `Foo` entity constructor. */
+type EntityOf<C> = C extends (new (em: EntityManager, opts: any) => infer T) ? T : never;
+type RelationsKeysOf<T> = { [K in keyof OptsOf<T>]: OptsOf<T>[K] extends Entity[] | undefined ? K : never; }[keyof OptsOf<T>];
+/** Return the Relation keys from `FooOpt` type, given a `Foo` entity */
+type RelationsOf<T extends Entity> = { [K in RelationsKeysOf<T>]: NonNullable<OptsOf<T>[K]>; };
+//#endregion
+export { ActualFactoryOpts, ColumnsOf, EntityOf, FactoryExtrasOf, FieldsOf, FilterOf, GraphQLFilterOf, InheritanceTypeOf, OptIdsOf, OptsOf, OrderOf, RelationsOf, RootTypeNameOf, TypeMap, TypeMapEntry, TypeNameOf };
+//# sourceMappingURL=typeMap.d.mts.map

package/build/typeMap.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeMap.d.mts","names":[],"sources":["../src/typeMap.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAoBiB;;;;;;;KAQZ,WAAW,KAAK;EAAY;IAAU,SAAS;;IAAQ,IAAI;EAAY;IAAU,SAAS;;IAAQ;;KAG3F,WAAW,KAAK,WAAW;;;;;;;;;;;;;KAc3B,eAAe,KAAK;EAAY;IAAU,SAAS;;IAAuB;;KAG1E,aAAa,GAAG,oBAC1B,WAAW,kBAAiB,KACxB,gBAAgB,UACd,gBAAgB,QAAQ,KACtB,QAAQ,GAAG;;KAMT,OAAO,KAAK,aAAa;;KAGzB,SAAS,KAAK,aAAa;;KAG3B,UAAU,KAAK,aAAa;;KAG5B,kBAAkB,KAAK,aAAa;KAEpC,SAAS,KAAK,aAAa;;KAG3B,SAAS,KAAK,aAAa;;KAG3B,gBAAgB,KAAK,aAAa;;KAGlC,QAAQ,KAAK,aAAa;;KAG1B,gBAAgB,KAAK,aAAa;;;;;;KAOlC,kBAAkB,KAAK,aAAa;;KAGpC,SAAS,KAAK,gBAAe,IAAI,eAAe,oBAAoB,KAAI;KAE/E,gBAAgB,QAClB,WAAW,OAAO,KAAK,OAAO,GAAG,WAAW,uBAAuB,mBAC9D,OAAO;;KAGH,YAAY,UAAU,aAC/B,KAAK,gBAAgB,KAAK,YAAY,OAAO,GAAG"}

package/build/typeMap.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=typeMap.js.map
+import "./EntityManager.js";
+import "./Entity.js";
+export {};