@smonn/ids 0.5.0 → 0.6.0

package/dist/opaque.mjs

@@ -1,2 +1,2 @@
-import { i as encodeOpaqueKey, n as importOpaqueKey, r as decodeOpaqueKey, t as createOpaqueTimestampId } from "./opaque-B4ps7Pqk.mjs";
+import { i as importOpaqueKey, n as decodeOpaqueKey, r as encodeOpaqueKey, t as createOpaqueTimestampId } from "./opaque-goLnFoo7.mjs";
 export { createOpaqueTimestampId, decodeOpaqueKey, encodeOpaqueKey, importOpaqueKey };

package/dist/prisma.d.mts

@@ -0,0 +1,84 @@
+import { i as ParseResult, t as Id } from "./types-g7CiQDyE.mjs";
+
+//#region src/prisma.d.ts
+/**
+* Minimum codec interface required by the Prisma adapter.
+*
+* Any codec variant satisfies this type — TimestampCodec, OpaqueTimestampCodec,
+* ReverseTimestampCodec, and WrappedKeyCodec all expose `safeParse`. The adapter
+* never calls key-dependent methods.
+*
+* Intentionally the same structural shape as the Drizzle adapter's IdColumnCodec.
+* Do NOT import IdColumnCodec from `@smonn/ids/drizzle` — that would create
+* cross-adapter coupling.
+*/
+type IdColumnCodec<Brand extends string> = {
+  safeParse(value: unknown): ParseResult<Brand>;
+};
+/**
+* Read/write transform pair for integrating `Id<Brand>` with Prisma extensions.
+*
+* **Prisma casting caveat:** Prisma cannot fully brand a generated model field
+* type at the schema level. The `read` function asserts `Id<Brand>` at the
+* TypeScript level, but Prisma's generated types for the model field will not
+* reflect this branding. Callers consuming the validated value from a Prisma
+* result component may need an explicit `as Id<Brand>` cast at the call site.
+*/
+type IdTransform<Brand extends string> = {
+  /**
+  * Read transform: validates the raw database value via `safeParse` and returns
+  * `Id<Brand>`. Throws if the value is missing, malformed, or belongs to a
+  * different brand.
+  *
+  * Use in a Prisma `$extends` result component's `compute` function.
+  */
+  read(value: unknown): Id<Brand>;
+  /**
+  * Write transform: passes `Id<Brand>` through as its canonical string form.
+  * `Id<Brand>` is already the canonical string, so this is an identity function
+  * at runtime.
+  *
+  * Use in a Prisma `$extends` query component or explicit `data` mapping.
+  */
+  write(value: Id<Brand>): string;
+};
+/**
+* Creates a read/write transform pair for use with Prisma's `$extends` extension model.
+*
+* Works with any codec variant exposing `safeParse` (TimestampCodec,
+* OpaqueTimestampCodec, ReverseTimestampCodec, WrappedKeyCodec).
+*
+* **Prisma casting caveat:** Prisma's `$extends` result component can add
+* typed computed accessors to model instances, but cannot retroactively
+* re-type an existing schema field at the Prisma Client level. The `read`
+* function asserts `Id<Brand>`, but callers will need an explicit
+* `as Id<Brand>` cast at consumption sites where Prisma's generated types
+* are expected.
+*
+* @example
+* ```ts
+* import { idField } from "@smonn/ids/prisma";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* const userIdField = idField(usr);
+*
+* const xprisma = prisma.$extends({
+*   result: {
+*     user: {
+*       id: {
+*         needs: { id: true },
+*         compute(user) {
+*           // Cast required: Prisma cannot brand the generated type at schema level
+*           return userIdField.read(user.id) as Id<"usr">;
+*         },
+*       },
+*     },
+*   },
+* });
+* ```
+*/
+declare function idField<Brand extends string>(codec: IdColumnCodec<Brand>): IdTransform<Brand>;
+//#endregion
+export { IdColumnCodec, IdTransform, idField };
+//# sourceMappingURL=prisma.d.mts.map

package/dist/prisma.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.d.mts","names":[],"sources":["../src/prisma.ts"],"mappings":";;;;;AAaA;;;;;;;;;KAAY,aAAA;EACV,SAAA,CAAU,KAAA,YAAiB,WAAA,CAAY,KAAA;AAAA;;;;;;;;;;KAY7B,WAAA;;;;;;;;EAQV,IAAA,CAAK,KAAA,YAAiB,EAAA,CAAG,KAAA;EAQT;AAuClB;;;;;;EAvCE,KAAA,CAAM,KAAA,EAAO,EAAA,CAAG,KAAA;AAAA;;;;;;;;;AAuCsE;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAxE,OAAA,uBAA8B,KAAA,EAAO,aAAA,CAAc,KAAA,IAAS,WAAA,CAAY,KAAA"}

package/dist/prisma.mjs

@@ -0,0 +1,53 @@
+//#region src/prisma.ts
+/**
+* Creates a read/write transform pair for use with Prisma's `$extends` extension model.
+*
+* Works with any codec variant exposing `safeParse` (TimestampCodec,
+* OpaqueTimestampCodec, ReverseTimestampCodec, WrappedKeyCodec).
+*
+* **Prisma casting caveat:** Prisma's `$extends` result component can add
+* typed computed accessors to model instances, but cannot retroactively
+* re-type an existing schema field at the Prisma Client level. The `read`
+* function asserts `Id<Brand>`, but callers will need an explicit
+* `as Id<Brand>` cast at consumption sites where Prisma's generated types
+* are expected.
+*
+* @example
+* ```ts
+* import { idField } from "@smonn/ids/prisma";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* const userIdField = idField(usr);
+*
+* const xprisma = prisma.$extends({
+*   result: {
+*     user: {
+*       id: {
+*         needs: { id: true },
+*         compute(user) {
+*           // Cast required: Prisma cannot brand the generated type at schema level
+*           return userIdField.read(user.id) as Id<"usr">;
+*         },
+*       },
+*     },
+*   },
+* });
+* ```
+*/
+function idField(codec) {
+	return {
+		read(value) {
+			const result = codec.safeParse(value);
+			if (!result.ok) throw new Error(`[ids] invalid ID from database: ${result.error}`);
+			return result.id;
+		},
+		write(value) {
+			return value;
+		}
+	};
+}
+//#endregion
+export { idField };
+
+//# sourceMappingURL=prisma.mjs.map

package/dist/prisma.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.mjs","names":[],"sources":["../src/prisma.ts"],"sourcesContent":["import type { Id, ParseResult } from \"./types.js\";\n\n/**\n * Minimum codec interface required by the Prisma adapter.\n *\n * Any codec variant satisfies this type — TimestampCodec, OpaqueTimestampCodec,\n * ReverseTimestampCodec, and WrappedKeyCodec all expose `safeParse`. The adapter\n * never calls key-dependent methods.\n *\n * Intentionally the same structural shape as the Drizzle adapter's IdColumnCodec.\n * Do NOT import IdColumnCodec from `@smonn/ids/drizzle` — that would create\n * cross-adapter coupling.\n */\nexport type IdColumnCodec<Brand extends string> = {\n  safeParse(value: unknown): ParseResult<Brand>;\n};\n\n/**\n * Read/write transform pair for integrating `Id<Brand>` with Prisma extensions.\n *\n * **Prisma casting caveat:** Prisma cannot fully brand a generated model field\n * type at the schema level. The `read` function asserts `Id<Brand>` at the\n * TypeScript level, but Prisma's generated types for the model field will not\n * reflect this branding. Callers consuming the validated value from a Prisma\n * result component may need an explicit `as Id<Brand>` cast at the call site.\n */\nexport type IdTransform<Brand extends string> = {\n  /**\n   * Read transform: validates the raw database value via `safeParse` and returns\n   * `Id<Brand>`. Throws if the value is missing, malformed, or belongs to a\n   * different brand.\n   *\n   * Use in a Prisma `$extends` result component's `compute` function.\n   */\n  read(value: unknown): Id<Brand>;\n  /**\n   * Write transform: passes `Id<Brand>` through as its canonical string form.\n   * `Id<Brand>` is already the canonical string, so this is an identity function\n   * at runtime.\n   *\n   * Use in a Prisma `$extends` query component or explicit `data` mapping.\n   */\n  write(value: Id<Brand>): string;\n};\n\n/**\n * Creates a read/write transform pair for use with Prisma's `$extends` extension model.\n *\n * Works with any codec variant exposing `safeParse` (TimestampCodec,\n * OpaqueTimestampCodec, ReverseTimestampCodec, WrappedKeyCodec).\n *\n * **Prisma casting caveat:** Prisma's `$extends` result component can add\n * typed computed accessors to model instances, but cannot retroactively\n * re-type an existing schema field at the Prisma Client level. The `read`\n * function asserts `Id<Brand>`, but callers will need an explicit\n * `as Id<Brand>` cast at consumption sites where Prisma's generated types\n * are expected.\n *\n * @example\n * ```ts\n * import { idField } from \"@smonn/ids/prisma\";\n * import { createTimestampId } from \"@smonn/ids\";\n *\n * const usr = createTimestampId(\"usr\");\n * const userIdField = idField(usr);\n *\n * const xprisma = prisma.$extends({\n *   result: {\n *     user: {\n *       id: {\n *         needs: { id: true },\n *         compute(user) {\n *           // Cast required: Prisma cannot brand the generated type at schema level\n *           return userIdField.read(user.id) as Id<\"usr\">;\n *         },\n *       },\n *     },\n *   },\n * });\n * ```\n */\nexport function idField<Brand extends string>(codec: IdColumnCodec<Brand>): IdTransform<Brand> {\n  return {\n    read(value: unknown): Id<Brand> {\n      const result = codec.safeParse(value);\n      if (!result.ok) {\n        throw new Error(`[ids] invalid ID from database: ${result.error}`);\n      }\n      return result.id;\n    },\n    write(value: Id<Brand>): string {\n      return value;\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiFA,SAAgB,QAA8B,OAAiD;CAC7F,OAAO;EACL,KAAK,OAA2B;GAC9B,MAAM,SAAS,MAAM,UAAU,KAAK;GACpC,IAAI,CAAC,OAAO,IACV,MAAM,IAAI,MAAM,mCAAmC,OAAO,OAAO;GAEnE,OAAO,OAAO;EAChB;EACA,MAAM,OAA0B;GAC9B,OAAO;EACT;CACF;AACF"}

package/dist/reverse--n4D2yxu.mjs

@@ -0,0 +1,87 @@
+import { a as toWireId, i as payloadBytesFromId, n as registerBrand, s as validateBrand, t as wireMethods } from "./codec-shell-dWpxoFmy.mjs";
+import { r as writeTimestamp } from "./timestamp-bytes-B57RM7Ho.mjs";
+//#region src/layouts/reverse-timestamp.ts
+const randomByteLength = 10;
+/** Writes inverted timestamp bytes, then fills random portion. */
+function buildReversePayload(ms, rng, buffer, randomView) {
+	writeTimestamp(ms, buffer);
+	for (let i = 0; i < 6; i++) buffer[i] = ~buffer[i] & 255;
+	rng(randomView);
+}
+/** Writes inverted timestamp bytes, then fills random portion with a sentinel. */
+function buildReverseSentinelPayload(ms, fill, buffer, randomView) {
+	writeTimestamp(ms, buffer);
+	for (let i = 0; i < 6; i++) buffer[i] = ~buffer[i] & 255;
+	randomView.fill(fill);
+}
+/** Decodes the original timestamp by inverting the first 6 payload bytes. */
+function extractReverseTimestampFromId(prefix, id) {
+	const bytes = payloadBytesFromId(prefix, id);
+	let ms = 0;
+	for (let i = 0; i < 6; i++) ms = ms * 256 + (~bytes[i] & 255);
+	return new Date(ms);
+}
+/** Layout ops binder for the Reverse Timestamp variant. */
+function createReverseTimestampLayoutOps(prefix, rng) {
+	const buffer = new Uint8Array(16);
+	const randomView = new Uint8Array(buffer.buffer, 6, randomByteLength);
+	return {
+		generateAt: (ms) => {
+			buildReversePayload(ms, rng, buffer, randomView);
+			return toWireId(prefix, buffer);
+		},
+		extractTimestamp: (id) => extractReverseTimestampFromId(prefix, id),
+		minIdForTime: (ms) => {
+			buildReverseSentinelPayload(ms, 0, buffer, randomView);
+			return toWireId(prefix, buffer);
+		},
+		maxIdForTime: (ms) => {
+			buildReverseSentinelPayload(ms, 255, buffer, randomView);
+			return toWireId(prefix, buffer);
+		},
+		exampleWireId: (ms) => {
+			buildReversePayload(ms, rng, buffer, randomView);
+			return toWireId(prefix, buffer);
+		}
+	};
+}
+//#endregion
+//#region src/reverse.ts
+function defaultRng(target) {
+	crypto.getRandomValues(target);
+}
+/**
+* Creates a Reverse Timestamp codec for `brand` (three lowercase a–z characters).
+*
+* IDs sort newest-first: the 48-bit timestamp field is bitwise-inverted before encoding,
+* so lexicographic ID order equals descending creation-time order. `extractTimestamp`
+* inverts back to recover the original millisecond.
+*
+* @param brand - Entity type brand validated once at construction.
+* @param opts - Optional `now`, `rng`, and `allowDuplicateBrand` overrides.
+*/
+function createReverseTimestampId(brand, opts = {}) {
+	validateBrand(brand);
+	registerBrand(brand, opts.allowDuplicateBrand);
+	const now = opts.now ?? Date.now;
+	const rng = opts.rng ?? defaultRng;
+	const prefix = `${brand}_`;
+	const wire = wireMethods(prefix);
+	const layout = createReverseTimestampLayoutOps(prefix, rng);
+	return {
+		generate: () => layout.generateAt(now()),
+		generateAt: (date) => layout.generateAt(date.getTime()),
+		is: wire.is,
+		parse: wire.parse,
+		safeParse: wire.safeParse,
+		extractTimestamp: layout.extractTimestamp,
+		minIdForTime: (date) => layout.minIdForTime(date.getTime()),
+		maxIdForTime: (date) => layout.maxIdForTime(date.getTime()),
+		toJsonSchema: () => wire.toJsonSchema(brand, layout.exampleWireId(now())),
+		"~standard": wire["~standard"]
+	};
+}
+//#endregion
+export { createReverseTimestampId as t };
+
+//# sourceMappingURL=reverse--n4D2yxu.mjs.map

package/dist/reverse--n4D2yxu.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse--n4D2yxu.mjs","names":[],"sources":["../src/layouts/reverse-timestamp.ts","../src/reverse.ts"],"sourcesContent":["import type { Id, Prefix } from \"../types.js\";\nimport { payloadBytesFromId, toWireId } from \"../wire/envelope.js\";\nimport { payloadByteLength } from \"../wire/invariants.js\";\nimport { timestampByteLength, writeTimestamp } from \"../wire/timestamp-bytes.js\";\n\nconst randomByteLength: number = payloadByteLength - timestampByteLength;\n\n/** Writes inverted timestamp bytes, then fills random portion. */\nfunction buildReversePayload(\n  ms: number,\n  rng: (target: Uint8Array) => void,\n  buffer: Uint8Array,\n  randomView: Uint8Array,\n): void {\n  writeTimestamp(ms, buffer);\n  for (let i = 0; i < timestampByteLength; i++) {\n    buffer[i] = ~buffer[i]! & 0xff;\n  }\n  rng(randomView);\n}\n\n/** Writes inverted timestamp bytes, then fills random portion with a sentinel. */\nfunction buildReverseSentinelPayload(\n  ms: number,\n  fill: number,\n  buffer: Uint8Array,\n  randomView: Uint8Array,\n): void {\n  writeTimestamp(ms, buffer);\n  for (let i = 0; i < timestampByteLength; i++) {\n    buffer[i] = ~buffer[i]! & 0xff;\n  }\n  randomView.fill(fill);\n}\n\n/** Decodes the original timestamp by inverting the first 6 payload bytes. */\nfunction extractReverseTimestampFromId<Brand extends string>(\n  prefix: Prefix<Brand>,\n  id: Id<Brand>,\n): Date {\n  const bytes = payloadBytesFromId(prefix, id);\n  let ms = 0;\n  for (let i = 0; i < timestampByteLength; i++) {\n    ms = ms * 256 + (~bytes[i]! & 0xff);\n  }\n  return new Date(ms);\n}\n\n/** Layout ops binder for the Reverse Timestamp variant. */\nexport function createReverseTimestampLayoutOps<Brand extends string>(\n  prefix: Prefix<Brand>,\n  rng: (target: Uint8Array) => void,\n) {\n  const buffer = new Uint8Array(payloadByteLength);\n  const randomView = new Uint8Array(buffer.buffer, timestampByteLength, randomByteLength);\n\n  return {\n    generateAt: (ms: number): Id<Brand> => {\n      buildReversePayload(ms, rng, buffer, randomView);\n      return toWireId(prefix, buffer);\n    },\n    extractTimestamp: (id: Id<Brand>): Date => extractReverseTimestampFromId(prefix, id),\n    minIdForTime: (ms: number): Id<Brand> => {\n      buildReverseSentinelPayload(ms, 0x00, buffer, randomView);\n      return toWireId(prefix, buffer);\n    },\n    maxIdForTime: (ms: number): Id<Brand> => {\n      buildReverseSentinelPayload(ms, 0xff, buffer, randomView);\n      return toWireId(prefix, buffer);\n    },\n    exampleWireId: (ms: number): Id<Brand> => {\n      buildReversePayload(ms, rng, buffer, randomView);\n      return toWireId(prefix, buffer);\n    },\n  };\n}\n","import { validateBrand } from \"./brand.js\";\nimport { createReverseTimestampLayoutOps } from \"./layouts/reverse-timestamp.js\";\nimport { registerBrand } from \"./registry.js\";\nimport type { Id, JsonSchema, ParseResult, Prefix, StandardSchemaProps } from \"./types.js\";\nimport { wireMethods } from \"./wire/codec-shell.js\";\n\n/**\n * Configuration options for a Reverse Timestamp codec instance.\n */\nexport type ReverseTimestampOptions = {\n  /** Returns the current timestamp in milliseconds. Defaults to `Date.now`. */\n  now?: () => number;\n  /** Writes random bytes into `target` for ID generation. Defaults to `crypto.getRandomValues`. */\n  rng?: (target: Uint8Array) => void;\n  /** If true, silences the duplicate-brand warning in non-production environments. */\n  allowDuplicateBrand?: boolean;\n};\n\n/**\n * A brand-scoped codec for generating and validating Reverse Timestamp IDs.\n *\n * Wire format: `{brand}_` plus 26 lowercase Crockford base32 characters encoding a\n * 16-byte payload (6-byte bitwise-inverted ms timestamp + 10 random bytes). IDs sort\n * by creation time in **descending** (newest-first) order.\n *\n * Range queries across a time interval [t_old, t_new] should scan from\n * `minIdForTime(t_new)` to `maxIdForTime(t_old)` — the reversed sort order means\n * newer timestamps produce lexicographically smaller IDs.\n *\n * Constructed via `createReverseTimestampId(brand)` from `@smonn/ids/reverse`.\n */\nexport type ReverseTimestampCodec<Brand extends string> = {\n  /** Produces a new canonical ID using the codec's `now` and `rng`. */\n  generate(): Id<Brand>;\n  /** Produces a new canonical ID with timestamp bytes from `date` and a fresh random tail. Throws on invalid dates. */\n  generateAt(date: Date): Id<Brand>;\n  /**\n   * Strict type guard: `true` only for already-canonical strings for this brand.\n   * For untrusted input, use `safeParse()` or `parse()` instead. See ADR-0003.\n   */\n  is(value: unknown): value is Id<Brand>;\n  /**\n   * Lenient parse: normalises case and Crockford aliases, returns canonical `Id<Brand>`, or throws.\n   */\n  parse(value: unknown): Id<Brand>;\n  /**\n   * Lenient parse without throwing: normalises to canonical form, or returns `{ ok: false, error }`.\n   */\n  safeParse(value: unknown): ParseResult<Brand>;\n  /**\n   * Decodes the creation `Date` from an `Id<Brand>` by inverting the timestamp bytes.\n   * Trusts the type — use `safeParse()` at boundaries first.\n   */\n  extractTimestamp(id: Id<Brand>): Date;\n  /**\n   * Lexicographically smallest ID for any ID generated at `date` (random portion `0x00`).\n   * Because timestamps are inverted, a newer `date` yields a lexicographically smaller result —\n   * use `minIdForTime(t_new)` as the lower bound when scanning [t_old, t_new].\n   * Throws on invalid dates.\n   */\n  minIdForTime(date: Date): Id<Brand>;\n  /**\n   * Lexicographically largest ID for any ID generated at `date` (random portion `0xff`).\n   * Because timestamps are inverted, an older `date` yields a lexicographically larger result —\n   * use `maxIdForTime(t_old)` as the upper bound when scanning [t_old, t_new].\n   * Throws on invalid dates.\n   */\n  maxIdForTime(date: Date): Id<Brand>;\n  /** JSON Schema for the canonical wire form (`pattern` is canonical-only). */\n  toJsonSchema(): JsonSchema;\n  /** Standard Schema validate entry point. */\n  readonly \"~standard\": StandardSchemaProps<Brand>;\n};\n\nfunction defaultRng(target: Uint8Array): void {\n  crypto.getRandomValues(target as Uint8Array<ArrayBuffer>);\n}\n\n/**\n * Creates a Reverse Timestamp codec for `brand` (three lowercase a–z characters).\n *\n * IDs sort newest-first: the 48-bit timestamp field is bitwise-inverted before encoding,\n * so lexicographic ID order equals descending creation-time order. `extractTimestamp`\n * inverts back to recover the original millisecond.\n *\n * @param brand - Entity type brand validated once at construction.\n * @param opts - Optional `now`, `rng`, and `allowDuplicateBrand` overrides.\n */\nexport function createReverseTimestampId<Brand extends string>(\n  brand: Brand,\n  opts: ReverseTimestampOptions = {},\n): ReverseTimestampCodec<Brand> {\n  validateBrand(brand);\n  registerBrand(brand, opts.allowDuplicateBrand);\n\n  const now = opts.now ?? Date.now;\n  const rng = opts.rng ?? defaultRng;\n  const prefix: Prefix<Brand> = `${brand}_`;\n  const wire = wireMethods(prefix);\n  const layout = createReverseTimestampLayoutOps(prefix, rng);\n\n  return {\n    generate: () => layout.generateAt(now()),\n    generateAt: (date: Date) => layout.generateAt(date.getTime()),\n    is: wire.is,\n    parse: wire.parse,\n    safeParse: wire.safeParse,\n    extractTimestamp: layout.extractTimestamp,\n    minIdForTime: (date: Date) => layout.minIdForTime(date.getTime()),\n    maxIdForTime: (date: Date) => layout.maxIdForTime(date.getTime()),\n    toJsonSchema: () => wire.toJsonSchema(brand, layout.exampleWireId(now())),\n    \"~standard\": wire[\"~standard\"],\n  };\n}\n"],"mappings":";;;AAKA,MAAM,mBAAA;;AAGN,SAAS,oBACP,IACA,KACA,QACA,YACM;CACN,eAAe,IAAI,MAAM;CACzB,KAAK,IAAI,IAAI,GAAG,IAAA,GAAyB,KACvC,OAAO,KAAK,CAAC,OAAO,KAAM;CAE5B,IAAI,UAAU;AAChB;;AAGA,SAAS,4BACP,IACA,MACA,QACA,YACM;CACN,eAAe,IAAI,MAAM;CACzB,KAAK,IAAI,IAAI,GAAG,IAAA,GAAyB,KACvC,OAAO,KAAK,CAAC,OAAO,KAAM;CAE5B,WAAW,KAAK,IAAI;AACtB;;AAGA,SAAS,8BACP,QACA,IACM;CACN,MAAM,QAAQ,mBAAmB,QAAQ,EAAE;CAC3C,IAAI,KAAK;CACT,KAAK,IAAI,IAAI,GAAG,IAAA,GAAyB,KACvC,KAAK,KAAK,OAAO,CAAC,MAAM,KAAM;CAEhC,OAAO,IAAI,KAAK,EAAE;AACpB;;AAGA,SAAgB,gCACd,QACA,KACA;CACA,MAAM,SAAS,IAAI,WAAA,EAA4B;CAC/C,MAAM,aAAa,IAAI,WAAW,OAAO,QAAA,GAA6B,gBAAgB;CAEtF,OAAO;EACL,aAAa,OAA0B;GACrC,oBAAoB,IAAI,KAAK,QAAQ,UAAU;GAC/C,OAAO,SAAS,QAAQ,MAAM;EAChC;EACA,mBAAmB,OAAwB,8BAA8B,QAAQ,EAAE;EACnF,eAAe,OAA0B;GACvC,4BAA4B,IAAI,GAAM,QAAQ,UAAU;GACxD,OAAO,SAAS,QAAQ,MAAM;EAChC;EACA,eAAe,OAA0B;GACvC,4BAA4B,IAAI,KAAM,QAAQ,UAAU;GACxD,OAAO,SAAS,QAAQ,MAAM;EAChC;EACA,gBAAgB,OAA0B;GACxC,oBAAoB,IAAI,KAAK,QAAQ,UAAU;GAC/C,OAAO,SAAS,QAAQ,MAAM;EAChC;CACF;AACF;;;ACDA,SAAS,WAAW,QAA0B;CAC5C,OAAO,gBAAgB,MAAiC;AAC1D;;;;;;;;;;;AAYA,SAAgB,yBACd,OACA,OAAgC,CAAC,GACH;CAC9B,cAAc,KAAK;CACnB,cAAc,OAAO,KAAK,mBAAmB;CAE7C,MAAM,MAAM,KAAK,OAAO,KAAK;CAC7B,MAAM,MAAM,KAAK,OAAO;CACxB,MAAM,SAAwB,GAAG,MAAM;CACvC,MAAM,OAAO,YAAY,MAAM;CAC/B,MAAM,SAAS,gCAAgC,QAAQ,GAAG;CAE1D,OAAO;EACL,gBAAgB,OAAO,WAAW,IAAI,CAAC;EACvC,aAAa,SAAe,OAAO,WAAW,KAAK,QAAQ,CAAC;EAC5D,IAAI,KAAK;EACT,OAAO,KAAK;EACZ,WAAW,KAAK;EAChB,kBAAkB,OAAO;EACzB,eAAe,SAAe,OAAO,aAAa,KAAK,QAAQ,CAAC;EAChE,eAAe,SAAe,OAAO,aAAa,KAAK,QAAQ,CAAC;EAChE,oBAAoB,KAAK,aAAa,OAAO,OAAO,cAAc,IAAI,CAAC,CAAC;EACxE,aAAa,KAAK;CACpB;AACF"}

package/dist/reverse.d.mts

@@ -0,0 +1,76 @@
+import { a as StandardSchemaProps, i as ParseResult, n as JsonSchema, t as Id } from "./types-g7CiQDyE.mjs";
+
+//#region src/reverse.d.ts
+/**
+* Configuration options for a Reverse Timestamp codec instance.
+*/
+type ReverseTimestampOptions = {
+  /** Returns the current timestamp in milliseconds. Defaults to `Date.now`. */now?: () => number; /** Writes random bytes into `target` for ID generation. Defaults to `crypto.getRandomValues`. */
+  rng?: (target: Uint8Array) => void; /** If true, silences the duplicate-brand warning in non-production environments. */
+  allowDuplicateBrand?: boolean;
+};
+/**
+* A brand-scoped codec for generating and validating Reverse Timestamp IDs.
+*
+* Wire format: `{brand}_` plus 26 lowercase Crockford base32 characters encoding a
+* 16-byte payload (6-byte bitwise-inverted ms timestamp + 10 random bytes). IDs sort
+* by creation time in **descending** (newest-first) order.
+*
+* Range queries across a time interval [t_old, t_new] should scan from
+* `minIdForTime(t_new)` to `maxIdForTime(t_old)` — the reversed sort order means
+* newer timestamps produce lexicographically smaller IDs.
+*
+* Constructed via `createReverseTimestampId(brand)` from `@smonn/ids/reverse`.
+*/
+type ReverseTimestampCodec<Brand extends string> = {
+  /** Produces a new canonical ID using the codec's `now` and `rng`. */generate(): Id<Brand>; /** Produces a new canonical ID with timestamp bytes from `date` and a fresh random tail. Throws on invalid dates. */
+  generateAt(date: Date): Id<Brand>;
+  /**
+  * Strict type guard: `true` only for already-canonical strings for this brand.
+  * For untrusted input, use `safeParse()` or `parse()` instead. See ADR-0003.
+  */
+  is(value: unknown): value is Id<Brand>;
+  /**
+  * Lenient parse: normalises case and Crockford aliases, returns canonical `Id<Brand>`, or throws.
+  */
+  parse(value: unknown): Id<Brand>;
+  /**
+  * Lenient parse without throwing: normalises to canonical form, or returns `{ ok: false, error }`.
+  */
+  safeParse(value: unknown): ParseResult<Brand>;
+  /**
+  * Decodes the creation `Date` from an `Id<Brand>` by inverting the timestamp bytes.
+  * Trusts the type — use `safeParse()` at boundaries first.
+  */
+  extractTimestamp(id: Id<Brand>): Date;
+  /**
+  * Lexicographically smallest ID for any ID generated at `date` (random portion `0x00`).
+  * Because timestamps are inverted, a newer `date` yields a lexicographically smaller result —
+  * use `minIdForTime(t_new)` as the lower bound when scanning [t_old, t_new].
+  * Throws on invalid dates.
+  */
+  minIdForTime(date: Date): Id<Brand>;
+  /**
+  * Lexicographically largest ID for any ID generated at `date` (random portion `0xff`).
+  * Because timestamps are inverted, an older `date` yields a lexicographically larger result —
+  * use `maxIdForTime(t_old)` as the upper bound when scanning [t_old, t_new].
+  * Throws on invalid dates.
+  */
+  maxIdForTime(date: Date): Id<Brand>; /** JSON Schema for the canonical wire form (`pattern` is canonical-only). */
+  toJsonSchema(): JsonSchema; /** Standard Schema validate entry point. */
+  readonly "~standard": StandardSchemaProps<Brand>;
+};
+/**
+* Creates a Reverse Timestamp codec for `brand` (three lowercase a–z characters).
+*
+* IDs sort newest-first: the 48-bit timestamp field is bitwise-inverted before encoding,
+* so lexicographic ID order equals descending creation-time order. `extractTimestamp`
+* inverts back to recover the original millisecond.
+*
+* @param brand - Entity type brand validated once at construction.
+* @param opts - Optional `now`, `rng`, and `allowDuplicateBrand` overrides.
+*/
+declare function createReverseTimestampId<Brand extends string>(brand: Brand, opts?: ReverseTimestampOptions): ReverseTimestampCodec<Brand>;
+//#endregion
+export { ReverseTimestampCodec, ReverseTimestampOptions, createReverseTimestampId };
+//# sourceMappingURL=reverse.d.mts.map

package/dist/reverse.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse.d.mts","names":[],"sources":["../src/reverse.ts"],"mappings":";;;;;AASA;KAAY,uBAAA;+EAEV,GAAA;EAEA,GAAA,IAAO,MAAA,EAAQ,UAAA;EAEf,mBAAA;AAAA;;AAAA;AAgBF;;;;;;;;;;;KAAY,qBAAA;uEAEV,QAAA,IAAY,EAAA,CAAG,KAAA;EAEf,UAAA,CAAW,IAAA,EAAM,IAAA,GAAO,EAAA,CAAG,KAAA;;;;;EAK3B,EAAA,CAAG,KAAA,YAAiB,KAAA,IAAS,EAAA,CAAG,KAAA;;;;EAIhC,KAAA,CAAM,KAAA,YAAiB,EAAA,CAAG,KAAA;;;;EAI1B,SAAA,CAAU,KAAA,YAAiB,WAAA,CAAY,KAAA;;;;;EAKvC,gBAAA,CAAiB,EAAA,EAAI,EAAA,CAAG,KAAA,IAAS,IAAA;;;;;;;EAOjC,YAAA,CAAa,IAAA,EAAM,IAAA,GAAO,EAAA,CAAG,KAAA;;;;;;;EAO7B,YAAA,CAAa,IAAA,EAAM,IAAA,GAAO,EAAA,CAAG,KAAA;EAE7B,YAAA,IAAgB,UAAA;WAEP,WAAA,EAAa,mBAAA,CAAoB,KAAA;AAAA;;;;;;;;;;;iBAiB5B,wBAAA,uBACd,KAAA,EAAO,KAAA,EACP,IAAA,GAAM,uBAAA,GACL,qBAAA,CAAsB,KAAA"}

package/dist/reverse.mjs

@@ -0,0 +1,2 @@
+import { t as createReverseTimestampId } from "./reverse--n4D2yxu.mjs";
+export { createReverseTimestampId };