@evolu/common 6.0.1-preview.34 → 6.0.1-preview.35

package/src/Evolu/Protocol.ts

@@ -170,9 +170,11 @@
  *   initiator/non-initiator terminology instead, and consolidate into a single
  *   `applyProtocolMessage` function with conditional arguments to reduce code
  *   duplication.
- * - ProtocolQuotaError should return storedBytes and actual quota.
  * - Replace try-catch with Result + new Error (to preserve stacktraces). Measure
  *   Result overhead, it should be super small.
+ * - Allow clients to broadcast messages that are not persisted by relays. This
+ *   would enable real-time ephemeral data (like cursor positions, typing
+ *   indicators) to be forwarded by relays without storage overhead.
  */
 
 import { Packr } from "msgpackr";
@@ -416,7 +418,9 @@ export interface ProtocolWriteError extends BaseOwnerError {
  * excess local data is affected. Other devices that haven't exceeded quota can
  * still sync normally.
  *
- * Clients should prompt the user to upgrade their plan.
+ * Clients should prompt the user to contact the relay provider or upgrade their
+ * plan. Quota monitoring and management is the relay provider's
+ * responsibility.
  */
 export interface ProtocolQuotaError extends BaseOwnerError {
   readonly type: "ProtocolQuotaError";
@@ -1727,7 +1731,11 @@ export const encodeAndEncryptDbChange =
     // assigning this EncryptedDbChange to a different EncryptedCrdtMessage)
     buffer.extend(timestampToTimestampBytes(message.timestamp));
 
-    encodeFlags(buffer, [message.change.isInsert]);
+    encodeFlags(buffer, [
+      message.change.isInsert,
+      message.change.isDelete != null,
+      message.change.isDelete ?? false,
+    ]);
 
     encodeString(buffer, message.change.table);
     buffer.extend(idToIdBytes(message.change.id));
@@ -1803,9 +1811,7 @@ export const decryptAndDecodeDbChange =
         });
       }
 
-      const flags = decodeFlags(buffer, PositiveInt.orThrow(1));
-      const isInsert = flags[0];
-
+      const flags = decodeFlags(buffer, PositiveInt.orThrow(3));
       const table = decodeString(buffer);
       const id = decodeId(buffer);
 
@@ -1818,7 +1824,13 @@ export const decryptAndDecodeDbChange =
         values[column] = value;
       }
 
-      const dbChange = DbChange.orThrow({ table, id, values, isInsert });
+      const dbChange = DbChange.orThrow({
+        table,
+        id,
+        values,
+        isInsert: flags[0],
+        isDelete: flags[1] ? flags[2] : null,
+      });
 
       return ok(dbChange);
     } catch (error) {

package/src/Evolu/PublicKysely.ts

@@ -209,8 +209,7 @@ export function getJsonObjectArgs(
   table: string,
 ): Array<Expression<unknown> | string> {
   const args: Array<Expression<unknown> | string> = [];
-  args.push(kyselyJsonIdentifier, kyselyJsonIdentifier);
-
+  
   for (const { selection: s } of node.selections ?? []) {
     if (ReferenceNode.is(s) && ColumnNode.is(s.column)) {
       args.push(

package/src/Evolu/Schema.ts

@@ -1,6 +1,4 @@
 import * as Kysely from "kysely";
-import { assert } from "../Assert.js";
-import { createEqArrayLike, eqString } from "../Eq.js";
 import { mapObject, objectToEntries, ReadonlyRecord } from "../Object.js";
 import { ok, Result } from "../Result.js";
 import {
@@ -101,11 +99,11 @@ export type EvoluSchema = ReadonlyRecord<
 export type ValidateSchema<S extends EvoluSchema> =
   ValidateSchemaHasId<S> extends never
     ? ValidateIdColumnType<S> extends never
-      ? ValidateNoDefaultColumns<S> extends never
+      ? ValidateNoSystemColumns<S> extends never
         ? ValidateColumnTypes<S> extends never
           ? S
           : ValidateColumnTypes<S>
-        : ValidateNoDefaultColumns<S>
+        : ValidateNoSystemColumns<S>
       : ValidateIdColumnType<S>
     : ValidateSchemaHasId<S>;
 
@@ -129,13 +127,17 @@ export type ValidateIdColumnType<S extends EvoluSchema> =
       : never
     : never;
 
-export type ValidateNoDefaultColumns<S extends EvoluSchema> =
+export type ValidateNoSystemColumns<S extends EvoluSchema> =
   keyof S extends infer TableName
     ? TableName extends keyof S
       ? keyof S[TableName] extends infer ColumnName
         ? ColumnName extends keyof S[TableName]
-          ? ColumnName extends "createdAt" | "updatedAt" | "isDeleted"
-            ? SchemaValidationError<`Table "${TableName & string}" uses system column name "${ColumnName & string}". System columns (createdAt, updatedAt, isDeleted) are added automatically.`>
+          ? ColumnName extends
+              | "createdAt"
+              | "updatedAt"
+              | "isDeleted"
+              | "ownerId"
+            ? SchemaValidationError<`Table "${TableName & string}" uses system column name "${ColumnName & string}". System columns (createdAt, updatedAt, isDeleted, ownerId) are added automatically.`>
             : never
           : never
         : never
@@ -192,10 +194,7 @@ export type CreateQuery<S extends EvoluSchema> = <R extends Row>(
       Kysely.Kysely<
         {
           [Table in keyof S]: {
-            readonly [Column in keyof S[Table]]: Column extends
-              | "id"
-              | "createdAt"
-              | "updatedAt"
+            readonly [Column in keyof S[Table]]: Column extends "id"
               ? InferType<S[Table][Column]>
               : InferType<S[Table][Column]> | null;
           } & SystemColumns;
@@ -222,24 +221,17 @@ export type CreateQuery<S extends EvoluSchema> = <R extends Row>(
  * - `updatedAt`: Set by Evolu on every row change, derived from {@link Timestamp}.
  * - `isDeleted`: Soft delete flag created by Evolu and used by the developer to
  *   mark rows as deleted.
+ * - `ownerId`: Represents ownership and logically partitions the database.
  */
 export const SystemColumns = object({
   createdAt: DateIso,
   updatedAt: DateIso,
   isDeleted: nullOr(SqliteBoolean),
-  // TODO: ownerId
+  ownerId: OwnerId,
 });
 export type SystemColumns = typeof SystemColumns.Type;
 
-export const systemColumns = ["createdAt", "updatedAt", "isDeleted"];
-
-assert(
-  createEqArrayLike(eqString)(
-    objectToEntries(SystemColumns.props).map(([key]) => key),
-    systemColumns,
-  ),
-  "SystemColumns keys must match systemColumnsKeys",
-);
+export const systemColumns = Object.keys(SystemColumns.props);
 
 export type MutationKind = "insert" | "update" | "upsert";
 
@@ -550,10 +542,7 @@ export const ensureDbSchema =
         (t) => t.name === newTable.name,
       );
       if (!currentTable) {
-        queries.push({
-          sql: createAppTableWithDefaultColumns(newTable),
-          parameters: [],
-        });
+        queries.push(createAppTable(newTable));
       } else {
         newTable.columns
           .filter((newColumn) => !currentTable.columns.includes(newColumn))
@@ -599,21 +588,24 @@ export const ensureDbSchema =
     return ok();
   };
 
-const createAppTableWithDefaultColumns = (table: DbTable): SafeSql => {
-  return `
-    create table ${sql.identifier(table.name).sql} (
-      "id" text primary key,
-      ${table.columns
-        .concat(systemColumns)
+const createAppTable = (table: DbTable) => sql`
+  create table ${sql.identifier(table.name)} (
+    "id" text,
+    ${sql.raw(
+      `${systemColumns
+        .concat(table.columns)
         .filter((c) => c !== "id")
-        // "A column with affinity BLOB does not prefer one storage class over another
-        // and no attempt is made to coerce data from one storage class into another."
-        // https://www.sqlite.org/datatype3.html
-        .map((name) => `${sql.identifier(name).sql} blob`)
-        .join(", ")}
-    );
-  ` as SafeSql;
-};
+        // With strict tables and any type, data is preserved exactly as received
+        // without any type affinity coercion. This allows storing any data type
+        // while maintaining strict null enforcement for primary key columns.
+        .map((name) => `${sql.identifier(name).sql} any`)
+        .join(", ")}`,
+    )},
+    primary key ("ownerId", "id")
+  )
+  without rowid, strict;
+`;
+
 // https://kysely.dev/docs/recipes/splitting-query-building-and-execution
 export const kysely = new Kysely.Kysely({
   dialect: {

package/src/Evolu/Storage.ts

@@ -1,6 +1,5 @@
 import { sha256 } from "@noble/hashes/sha2.js";
 import {
-  filterArray,
   firstInArray,
   isNonEmptyReadonlyArray,
   NonEmptyReadonlyArray,
@@ -19,6 +18,7 @@ import {
   Id,
   Int64String,
   NonNegativeInt,
+  nullOr,
   object,
   PositiveInt,
   record,
@@ -32,8 +32,8 @@ import {
   OwnerIdBytes,
   OwnerWriteKey,
 } from "./Owner.js";
-import { orderTimestampBytes, Timestamp, TimestampBytes } from "./Timestamp.js";
 import { systemColumns } from "./Schema.js";
+import { orderTimestampBytes, Timestamp, TimestampBytes } from "./Timestamp.js";
 
 export interface StorageConfig {
   /**
@@ -256,18 +256,16 @@ export interface CrdtMessage {
 export const DbChangeValues = record(String, SqliteValue);
 export type DbChangeValues = typeof DbChangeValues.Type;
 
-const systemColumnsWithIdAndWithoutIsDeleted = filterArray(
-  systemColumns.concat("id"),
-  (column) => column != "isDeleted",
-);
+// "createdAt" and "updatedAt" are derived from Timestamp.
+// "id" and "isDeleted" are encoded separately to save bytes
+// "ownerId" is part of the protocol message
+const forbiddenSystemColumns = systemColumns.concat("id");
 
 export const ValidDbChangeValues = brand(
   "ValidDbChangeValues",
   DbChangeValues,
   (value) => {
-    const invalidColumns = systemColumnsWithIdAndWithoutIsDeleted.filter(
-      (key) => key in value,
-    );
+    const invalidColumns = forbiddenSystemColumns.filter((key) => key in value);
     if (invalidColumns.length > 0)
       return err<ValidDbChangeValuesError>({
         type: "ValidDbChangeValues",
@@ -294,6 +292,7 @@ export const DbChange = object({
   id: Id,
   values: ValidDbChangeValues,
   isInsert: Boolean,
+  isDelete: nullOr(Boolean),
 });
 export type DbChange = typeof DbChange.Type;
 

package/src/Evolu/Sync.ts

@@ -19,7 +19,16 @@ import { objectToEntries } from "../Object.js";
 import { RandomDep } from "../Random.js";
 import { createResources } from "../Resources.js";
 import { err, ok, Result } from "../Result.js";
-import { sql, SqliteDep, SqliteError, SqliteValue } from "../Sqlite.js";
+import {
+  booleanToSqliteBoolean,
+  sql,
+  SqliteBoolean,
+  sqliteBooleanToBoolean,
+  SqliteDep,
+  SqliteError,
+  sqliteFalse,
+  SqliteValue,
+} from "../Sqlite.js";
 import { AbortError, createMutex } from "../Task.js";
 import { TimeDep } from "../Time.js";
 import {
@@ -30,7 +39,7 @@ import {
   PositiveInt,
 } from "../Type.js";
 import { CreateWebSocketDep, WebSocket } from "../WebSocket.js";
-import type { PostMessageDep } from "./Db.js";
+import type { AppOwnerDep, PostMessageDep } from "./Db.js";
 import {
   AppOwner,
   OwnerEncryptionKey,
@@ -596,14 +605,24 @@ const createClientStorage =
         const { table, id } = rows[0];
         const values: Record<string, SqliteValue> = {};
         let isInsert = false;
+        let isDelete: boolean | null = null;
 
         for (const r of rows) {
           assert(r.table === table, "All rows must have the same table");
           assert(eqArrayNumber(r.id, id), "All rows must have the same Id");
-          if (r.column === "createdAt") {
-            isInsert = true;
-          } else {
-            values[r.column] = r.value;
+          switch (r.column) {
+            case "createdAt":
+              isInsert = true;
+              break;
+            case "isDeleted":
+              assert(
+                SqliteBoolean.is(r.value),
+                "isDeleted column must contain a valid SqliteBoolean (0 or 1)",
+              );
+              isDelete = sqliteBooleanToBoolean(r.value);
+              break;
+            default:
+              values[r.column] = r.value;
           }
         }
 
@@ -614,6 +633,7 @@ const createClientStorage =
             id: idBytesToId(rows[0].id),
             values,
             isInsert,
+            isDelete,
           }),
         };
 
@@ -632,12 +652,9 @@ const createTransportKey = (transportConfig: OwnerTransport): TransportKey => {
 };
 
 export const applyLocalOnlyChange =
-  (deps: SqliteDep & TimeDep) =>
+  (deps: SqliteDep & TimeDep & AppOwnerDep) =>
   (change: MutationChange): Result<void, SqliteError> => {
-    const isDeletion =
-      "isDeleted" in change.values && change.values.isDeleted === 1;
-
-    if (isDeletion) {
+    if (change.isDelete) {
       const result = deps.sqlite.exec(sql`
         delete from ${sql.identifier(change.table)}
         where id = ${change.id};
@@ -645,13 +662,19 @@ export const applyLocalOnlyChange =
       if (!result.ok) return result;
     } else {
       const now = deps.time.nowIso();
+      const ownerId = deps.appOwner.id;
+
+      let entries = objectToEntries(change.values);
+      if (change.isDelete !== null) {
+        entries = [...entries, ["isDeleted", sqliteFalse]];
+      }
 
-      for (const [column, value] of objectToEntries(change.values)) {
+      for (const [column, value] of entries) {
         const result = deps.sqlite.exec(sql.prepared`
           insert into ${sql.identifier(change.table)}
-            ("id", ${sql.identifier(column)}, createdAt, updatedAt)
-          values (${change.id}, ${value}, ${now}, ${now})
-          on conflict ("id") do update
+            ("ownerId", "id", ${sql.identifier(column)}, createdAt, updatedAt)
+          values (${ownerId}, ${change.id}, ${value}, ${now}, ${now})
+          on conflict ("ownerId", "id") do update
             set
               ${sql.identifier(column)} = ${value},
               updatedAt = ${now};
@@ -721,23 +744,21 @@ const applyMessages =
 const applyMessageToAppTable =
   (deps: SqliteDep) =>
   (
-    ownerId: OwnerIdBytes,
+    ownerIdBytes: OwnerIdBytes,
     message: CrdtMessage,
     date: DateIso,
   ): Result<void, SqliteError> => {
-    let entries = objectToEntries(message.change.values);
-    if (message.change.isInsert) {
-      entries = [...entries, ["createdAt", date]];
-    }
+    const ownerId = ownerIdBytesToOwnerId(ownerIdBytes);
+    const columns = dbChangeToColumns(message.change, date);
 
-    for (const [column, value] of entries) {
+    for (const [column, value] of columns) {
       const result = deps.sqlite.exec(sql.prepared`
         with
           existingTimestamp as (
             select 1
             from evolu_history
             where
-              "ownerId" = ${ownerId}
+              "ownerId" = ${ownerIdBytes}
               and "table" = ${message.change.table}
               and "id" = ${idToIdBytes(message.change.id)}
               and "column" = ${column}
@@ -745,10 +766,10 @@ const applyMessageToAppTable =
             limit 1
           )
         insert into ${sql.identifier(message.change.table)}
-          ("id", ${sql.identifier(column)}, updatedAt)
-        select ${message.change.id}, ${value}, ${date}
+          ("ownerId", "id", ${sql.identifier(column)}, updatedAt)
+        select ${ownerId}, ${message.change.id}, ${value}, ${date}
         where not exists (select 1 from existingTimestamp)
-        on conflict ("id") do update
+        on conflict ("ownerId", "id") do update
           set
             ${sql.identifier(column)} = ${value},
             updatedAt = ${date}
@@ -775,12 +796,9 @@ export const applyMessageToTimestampAndHistoryTables =
     const result = deps.storage.insertTimestamp(ownerId, timestamp, strategy);
     if (!result.ok) return result;
 
-    let entries = objectToEntries(message.change.values);
-    if (message.change.isInsert) {
-      entries = [...entries, ["createdAt", date]];
-    }
+    const columns = dbChangeToColumns(message.change, date);
 
-    for (const [column, value] of entries) {
+    for (const [column, value] of columns) {
       const result = deps.sqlite.exec(sql.prepared`
         insert into evolu_history
           ("ownerId", "table", "id", "column", "value", "timestamp")
@@ -801,6 +819,20 @@ export const applyMessageToTimestampAndHistoryTables =
     return ok();
   };
 
+const dbChangeToColumns = (
+  change: DbChange,
+  date: DateIso,
+): Array<[string, SqliteValue | DateIso]> => {
+  const entries = [...objectToEntries(change.values)];
+  if (change.isInsert) {
+    entries.push(["createdAt", date]);
+  }
+  if (change.isDelete !== null) {
+    entries.push(["isDeleted", booleanToSqliteBoolean(change.isDelete)]);
+  }
+  return entries;
+};
+
 /**
  * TODO: Rework for the new owners API.
  *

package/src/Sqlite.ts

@@ -511,10 +511,14 @@ const drawSqliteQueryPlan = (rows: Array<SqliteQueryPlanRow>): string =>
  * SQLite represents boolean values using `0` (false) and `1` (true) instead of
  * a dedicated boolean type.
  *
- * Use {@link sqliteTrue} and {@link sqliteFalse} constants for better
- * readability.
- *
  * See: https://www.sqlite.org/quirks.html#no_separate_boolean_datatype
+ *
+ * ### Tips
+ *
+ * - Use {@link sqliteTrue} and {@link sqliteFalse} constants for better
+ *   readability.
+ * - Use {@link booleanToSqliteBoolean} and {@link sqliteBooleanToBoolean} for
+ *   converting between JavaScript booleans and SQLite boolean values.
  */
 export const SqliteBoolean = union(0, 1);
 export type SqliteBoolean = typeof SqliteBoolean.Type;
@@ -532,3 +536,29 @@ export const sqliteTrue = 1;
  * See {@link SqliteBoolean}.
  */
 export const sqliteFalse = 0;
+
+/**
+ * Converts a JavaScript boolean to a {@link SqliteBoolean}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const isActive = true;
+ * const sqlValue = booleanToSqliteBoolean(isActive); // Returns 1
+ * ```
+ */
+export const booleanToSqliteBoolean = (value: boolean): SqliteBoolean =>
+  value ? sqliteTrue : sqliteFalse;
+
+/**
+ * Converts a {@link SqliteBoolean} to a JavaScript boolean.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const sqlValue: SqliteBoolean = 1;
+ * const bool = sqliteBooleanToBoolean(sqlValue); // Returns true
+ * ```
+ */
+export const sqliteBooleanToBoolean = (value: SqliteBoolean): boolean =>
+  value === sqliteTrue;

package/src/Type.ts

@@ -212,6 +212,7 @@ import { isPlainObject } from "./Object.js";
 import { hasNodeBuffer } from "./Platform.js";
 import { err, getOrNull, getOrThrow, ok, Result, trySync } from "./Result.js";
 import { safelyStringifyUnknownValue } from "./String.js";
+import type { TimeDep } from "./Time.js";
 import type { Literal, Simplify, WidenLiteral } from "./Types.js";
 import { IntentionalNever } from "./Types.js";
 
@@ -1589,41 +1590,27 @@ export const formatSimplePasswordError = (
   );
 
 /**
- * Globally unique identifier.
- *
- * **Evolu Id** is 16 random bytes from a cryptographically secure random
- * generator, encoded as 22-character Base64Url string. This provides strong
- * collision resistance for distributed ID generation.
- *
- * ### Design Rationale
- *
- * Why Evolu Id over alternatives:
- *
- * - **NanoID**: No standard binary serialization format, and uses only ~126 bits
- *   of entropy (21 characters from 64-symbol alphabet) compared to Evolu Id's
- *   128 bits.
- * - **UUID (v4)**: String format is 36 characters (with hyphens) compared to
- *   Evolu Id's 22 characters. While UUIDs can be stored as 16 bytes, their
- *   standard string representation is verbose.
- * - **UUID v7**: Includes timestamp in the ID, which leaks information about when
- *   data was created. This is a privacy concern for local-first applications
- *   where creation time must remain private.
- *
- * Evolu Id provides 128 bits of entropy, compact string representation (22
- * characters), standard and native string serialization (Base64Url), and no
- * privacy leaks.
- *
- * ### Future Consideration
- *
- * For database-heavy workloads where insert performance is critical, a hybrid
- * approach could be considered: `timestamp ^ H(cluster_id, timestamp >> N)`
- * where H is a keyed hash function and N is a configurable parameter. This
- * would maintain spatial locality for database caches (improving insert
- * performance by an order of magnitude) while adding entropy to prevent
- * timestamp leakage and correlation across systems. The parameter N would allow
- * trading off cache locality (larger N = better locality) versus entropy
- * distribution. See https://brooker.co.za/blog/2025/10/22/uuidv7.html for
- * details on this approach.
+ * Evolu Id: 16 bytes encoded as a 22‑character Base64Url string.
+ *
+ * There are three ways to create an Evolu Id:
+ *
+ * - {@link createId} – default cryptographically secure random bytes
+ *   (privacy‑preserving)
+ * - {@link createIdFromString} – deterministic: first 16 bytes of SHA‑256 of a
+ *   string
+ * - {@link createIdAsUuidv7} – optional: embeds timestamp bits (UUID v7 layout)
+ *
+ * Privacy: the default random Id does not leak creation time and is safe to
+ * share or log. The UUID v7 variant leaks creation time anywhere the Id is
+ * copied (logs, URLs, exports); only use it when you explicitly want insertion
+ * locality for very large write‑heavy tables and accept timestamp exposure.
+ *
+ * ### Future
+ *
+ * A possible hybrid masked‑time approach (`timestamp ^ H(cluster_id, timestamp
+ *
+ * > > N)`) could provide locality without exposing raw creation time. See
+ * > > https://brooker.co.za/blog/2025/10/22/uuidv7.html
  *
  * @category String
  */
@@ -1641,26 +1628,25 @@ export const formatIdError = createTypeErrorFormatter<IdError>(
 );
 
 /**
- * Creates an {@link Id}.
+ * Creates a random {@link Id}. This is the recommended default.
+ *
+ * Use {@link createIdFromString} for deterministic mapping of external IDs or
+ * {@link createIdAsUuidv7} when you accept timestamp leakage for index
+ * locality.
  *
  * ### Example
  *
  * ```ts
- * // string & Brand<"Id">
  * const id = createId(deps);
- *
- * // string & Brand<"Id"> & Brand<"Todo">
  * const todoId = createId<"Todo">(deps);
  * ```
  */
 export const createId = <B extends string = never>(
   deps: RandomBytesDep,
-): [B] extends [never] ? Id : Id & Brand<B> =>
-  uint8ArrayToBase64Url(deps.randomBytes.create(16)) as unknown as [B] extends [
-    never,
-  ]
-    ? Id
-    : Id & Brand<B>;
+): [B] extends [never] ? Id : Id & Brand<B> => {
+  const id = uint8ArrayToBase64Url(deps.randomBytes.create(16));
+  return id as unknown as [B] extends [never] ? Id : Id & Brand<B>;
+};
 
 /**
  * Creates an {@link Id} from a string using SHA-256.
@@ -1704,6 +1690,42 @@ export const createIdFromString = <B extends string = never>(
   return id as [B] extends [never] ? Id : Id & Brand<B>;
 };
 
+/**
+ * Creates an {@link Id} embedding timestamp bits (UUID v7 layout) before
+ * Base64Url encoding.
+ *
+ * Tradeoff: better insertion locality / index performance for huge datasets vs
+ * leaking creation time everywhere the Id appears. Evolu uses {@link createId}
+ * by default to avoid activity leakage; choose this only if you explicitly
+ * accept timestamp exposure.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const id = createIdAsUuidv7({ randomBytes, time });
+ * const todoId = createIdAsUuidv7<"Todo">({ randomBytes, time });
+ * ```
+ */
+export const createIdAsUuidv7 = <B extends string = never>(
+  deps: RandomBytesDep & TimeDep,
+): [B] extends [never] ? Id : Id & Brand<B> => {
+  const id = deps.randomBytes.create(16);
+
+  const timestamp = globalThis.BigInt(deps.time.now());
+
+  id[0] = globalThis.Number((timestamp >> 40n) & 0xffn);
+  id[1] = globalThis.Number((timestamp >> 32n) & 0xffn);
+  id[2] = globalThis.Number((timestamp >> 24n) & 0xffn);
+  id[3] = globalThis.Number((timestamp >> 16n) & 0xffn);
+  id[4] = globalThis.Number((timestamp >> 8n) & 0xffn);
+  id[5] = globalThis.Number(timestamp & 0xffn);
+
+  id[6] = (id[6] & 0x0f) | 0x70;
+  id[8] = (id[8] & 0x3f) | 0x80;
+
+  return id as unknown as [B] extends [never] ? Id : Id & Brand<B>;
+};
+
 /**
  * Creates a branded {@link Id} Type for a table's primary key.
  *