@porulle/core 0.10.6 → 0.11.0

package/src/modules/channels/adapter.ts

@@ -10,6 +10,7 @@ export interface ChannelConnectorCapabilities {
   readonly importCatalog: boolean;
   readonly importInventory: boolean;
   readonly pushOrder: boolean;
+  readonly pushCatalog?: boolean;
   readonly receiveWebhooks: boolean;
   readonly reserve?: boolean;
 }
@@ -24,11 +25,49 @@ export interface ChannelStore {
   webhookSecret: string | null;
 }
 
+export interface ChannelCatalogLocalizedAttributes {
+  locale: string;
+  title: string;
+  subtitle?: string;
+  description?: string;
+  richDescription?: unknown;
+  seoTitle?: string;
+  seoDescription?: string;
+}
+
+export interface ChannelCatalogImage {
+  externalId?: string;
+  url: string;
+  alt?: string;
+  role: "primary" | "gallery" | "thumbnail" | "video" | "document";
+  sortOrder?: number;
+  variantExternalIds?: string[];
+}
+
+export interface ChannelCatalogOptionType {
+  name: string;
+  displayName: string;
+  sortOrder?: number;
+  values: Array<{
+    value: string;
+    displayValue: string;
+    sortOrder?: number;
+  }>;
+}
+
+export interface ChannelCatalogPrice {
+  currency: string;
+  amount: number;
+  compareAtAmount?: number;
+}
+
 export interface ChannelCatalogVariant {
   externalId: string;
   sku?: string;
   barcode?: string;
   metadata?: Record<string, unknown>;
+  optionValues?: Record<string, string>;
+  prices?: ChannelCatalogPrice[];
 }
 
 export interface ChannelCatalogItem {
@@ -38,6 +77,13 @@ export interface ChannelCatalogItem {
   description?: string;
   variants: ChannelCatalogVariant[];
   metadata?: Record<string, unknown>;
+  attributes?: ChannelCatalogLocalizedAttributes[];
+  images?: ChannelCatalogImage[];
+  options?: ChannelCatalogOptionType[];
+  tags?: string[];
+  brand?: string;
+  categories?: string[];
+  status?: "draft" | "active" | "archived" | "discontinued";
 }
 
 export interface ChannelCatalogPage {
@@ -76,6 +122,54 @@ export interface ChannelPushOrderResult {
   remoteUrl?: string;
 }
 
+export type ChannelPushCatalogIntent = "filterable" | "display" | "tag";
+
+export interface ChannelPushCatalogField {
+  fieldPath: string;
+  intent: ChannelPushCatalogIntent;
+  value: unknown;
+  locale?: string;
+  remoteKey?: string;
+}
+
+export interface ChannelPushCatalogImage {
+  externalId?: string;
+  url: string;
+  alt?: string;
+  role: "primary" | "gallery" | "thumbnail" | "video" | "document";
+  sortOrder?: number;
+  variantExternalIds?: string[];
+}
+
+export interface ChannelPushCatalogVariant {
+  externalId: string;
+  fields: ChannelPushCatalogField[];
+}
+
+export interface ChannelPushCatalogItem {
+  externalId: string;
+  variants?: ChannelPushCatalogVariant[];
+  fields: ChannelPushCatalogField[];
+  images?: ChannelPushCatalogImage[];
+}
+
+export interface ChannelPushCatalogPreviousField {
+  fieldPath: string;
+  value: unknown;
+}
+
+export interface ChannelPushCatalogItemOutcome {
+  externalId: string;
+  ok: boolean;
+  error?: ChannelConnectorError;
+  remoteUpdatedAt?: string;
+  previousFields?: ChannelPushCatalogPreviousField[];
+}
+
+export interface ChannelPushCatalogResult {
+  outcomes: ChannelPushCatalogItemOutcome[];
+}
+
 export interface ChannelOrderStatus {
   status: "pending" | "confirmed" | "failed" | "cancelled" | "fulfilled";
 }
@@ -113,6 +207,11 @@ export interface ChannelConnector {
   importCatalog(store: ChannelStore, cursor?: string): Promise<Result<ChannelCatalogPage>>;
   fetchInventory(store: ChannelStore, ids?: string[]): Promise<Result<ChannelInventoryLevel[]>>;
   pushOrder(store: ChannelStore, slice: ChannelOrderSlice): Promise<Result<ChannelPushOrderResult, ChannelConnectorError>>;
+  pushCatalog?(
+    store: ChannelStore,
+    items: ChannelPushCatalogItem[],
+    opts?: { dryRun?: boolean },
+  ): Promise<Result<ChannelPushCatalogResult, ChannelConnectorError>>;
   fetchOrderStatus(store: ChannelStore, remoteId: string): Promise<Result<ChannelOrderStatus, ChannelConnectorError>>;
   verifyWebhook(store: ChannelStore, request: Request): Promise<Result<ChannelWebhookEvent>>;
   verifyAppWebhook?(
@@ -135,5 +234,12 @@ export interface ChannelConnector {
 }
 
 export function defineChannelConnector<T extends ChannelConnector>(connector: T): T {
-  return connector;
+  if (connector.capabilities.pushCatalog !== undefined) return connector;
+  return {
+    ...connector,
+    capabilities: {
+      ...connector.capabilities,
+      pushCatalog: false,
+    },
+  } as T;
 }

package/src/modules/media/module.ts

@@ -20,6 +20,8 @@ export const mediaModule = defineModule({
       catalogRepository: new CatalogRepository(db),
       storage,
       config: deps.config as CommerceConfig,
+      database: deps.db,
+      services: deps.services,
     });
   },
 });

package/src/modules/media/schema.ts

@@ -1,7 +1,12 @@
-import { index, integer, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import type { AnyPgColumn } from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+import { index, integer, jsonb, numeric, pgEnum, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core";
 import { organization } from "../../auth/auth-schema.js";
 import { sellableEntities, variants } from "../catalog/schema.js";
 
+export const mediaAssetOrigin = pgEnum("media_asset_origin", ["merchant", "generated", "imported"]);
+export type MediaAssetOrigin = (typeof mediaAssetOrigin.enumValues)[number];
+
 export const mediaAssets = pgTable(
   "media_assets",
   {
@@ -17,6 +22,11 @@ export const mediaAssets = pgTable(
     height: integer("height"),
     alt: text("alt"),
     metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+    origin: mediaAssetOrigin("origin").notNull().default("merchant"),
+    confidence: numeric("confidence", { precision: 4, scale: 3 }),
+    derivedFromAssetId: uuid("derived_from_asset_id").references((): AnyPgColumn => mediaAssets.id, {
+      onDelete: "set null",
+    }),
     uploadedAt: timestamp("uploaded_at", { withTimezone: true }).defaultNow().notNull(),
   },
   (table) => ({
@@ -38,4 +48,15 @@ export const entityMedia = pgTable("entity_media", {
     enum: ["primary", "gallery", "thumbnail", "video", "document"],
   }).notNull(),
   sortOrder: integer("sort_order").notNull().default(0),
-});
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  // Two partial indexes instead of one NULLS DISTINCT index: Postgres treats
+  // null variant ids as distinct, so a single index cannot reject duplicate
+  // entity-level rows.
+  entityLevelUnique: uniqueIndex("entity_media_entity_level_unique")
+    .on(table.entityId, table.mediaAssetId)
+    .where(sql`${table.variantId} IS NULL`),
+  variantLevelUnique: uniqueIndex("entity_media_variant_level_unique")
+    .on(table.entityId, table.variantId, table.mediaAssetId)
+    .where(sql`${table.variantId} IS NOT NULL`),
+}));

package/src/modules/media/service.ts

@@ -1,16 +1,22 @@
 import { resolveOrgId } from "../../auth/org.js";
+import { assertPermission } from "../../auth/permissions.js";
 import type { Actor } from "../../auth/types.js";
 import type { CommerceConfig } from "../../config/types.js";
 import type { StorageAdapter, StoredFile } from "./adapter.js";
 import { Err, Ok, type Result } from "../../kernel/result.js";
 import {
+  CommerceConflictError,
   CommerceNotFoundError,
   CommerceValidationError,
+  toCommerceError,
 } from "../../kernel/errors.js";
-import type { MediaRepository } from "./repository/index.js";
+import type { MediaRepository, MediaAsset } from "./repository/index.js";
 import type { CatalogRepository } from "../catalog/repository/index.js";
 import type { TxContext } from "../../kernel/database/tx-context.js";
+import { createTxContext } from "../../kernel/database/tx-context.js";
+import type { DatabaseAdapter } from "../../kernel/database/adapter.js";
 import { makeId } from "../../utils/id.js";
+import type { MediaAssetOrigin } from "./schema.js";
 
 export interface UploadMediaInput {
   filename: string;
@@ -18,6 +24,7 @@ export interface UploadMediaInput {
   data: ArrayBuffer;
   alt?: string;
   metadata?: Record<string, unknown>;
+  origin?: MediaAssetOrigin;
 }
 
 export interface AttachMediaInput {
@@ -43,6 +50,8 @@ interface MediaServiceDeps {
   catalogRepository: CatalogRepository;
   storage: StorageAdapter;
   config: CommerceConfig;
+  database?: DatabaseAdapter;
+  services?: Record<string, unknown>;
 }
 
 const DEFAULT_ALLOWED_MIME_TYPES = [
@@ -53,6 +62,17 @@ const DEFAULT_ALLOWED_MIME_TYPES = [
   "application/pdf",
 ];
 
+export function assertMediaWritable(asset: Pick<MediaAsset, "origin">, actor: Actor | null): void {
+  if (asset.origin === "merchant") assertPermission(actor, "media:write");
+}
+
+function isUniqueViolation(error: unknown): boolean {
+  if (error == null || typeof error !== "object") return false;
+  const value = error as { code?: unknown; cause?: unknown };
+  if (value.code === "23505") return true;
+  return isUniqueViolation(value.cause);
+}
+
 function isSvgOrXml(buffer: Uint8Array): boolean {
   const prefix = new TextDecoder()
     .decode(buffer.slice(0, 256))
@@ -97,6 +117,16 @@ export class MediaService {
     this.catalogRepo = deps.catalogRepository;
   }
 
+  private async withTransaction<T>(
+    actor: Actor | null,
+    ctx: TxContext | undefined,
+    fn: (txCtx: TxContext) => Promise<T>,
+  ): Promise<T> {
+    if (ctx?.tx != null) return fn(ctx);
+    if (this.deps.database == null) throw new Error("Database is required for media mutations.");
+    return this.deps.database.transaction(async (tx) => fn(createTxContext(tx, { actor })));
+  }
+
   async upload(
     input: UploadMediaInput,
     actor?: Actor | null,
@@ -148,6 +178,7 @@ export class MediaService {
         contentType: effectiveMime,
         size: input.data.byteLength,
         metadata: input.metadata ?? {},
+        origin: input.origin ?? "merchant",
         uploadedAt: new Date(),
         ...(input.alt !== undefined ? { alt: input.alt } : {}),
       },
@@ -199,6 +230,12 @@ export class MediaService {
     const asset = await this.repo.findAssetById(id, ctx, orgId);
     if (!asset) return Err(new CommerceNotFoundError("Media asset not found."));
 
+    try {
+      assertMediaWritable(asset, actor ?? ctx?.actor ?? null);
+    } catch (error) {
+      return Err(toCommerceError(error));
+    }
+
     const deleted = await this.deps.storage.delete(asset.storageKey);
     if (!deleted.ok) return deleted;
 
@@ -218,31 +255,55 @@ export class MediaService {
     actor?: Actor | null,
     ctx?: TxContext,
   ): Promise<Result<void>> {
-    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
-    const entity = await this.catalogRepo.findEntityById(input.entityId, ctx, orgId);
-    if (!entity) {
-      return Err(new CommerceNotFoundError("Entity not found."));
-    }
+    try {
+      return await this.withTransaction(actor ?? ctx?.actor ?? null, ctx, async (txCtx) => {
+        const orgId = resolveOrgId(actor ?? txCtx.actor);
+        const entity = await this.catalogRepo.findEntityById(input.entityId, txCtx, orgId);
+        if (!entity) return Err(new CommerceNotFoundError("Entity not found."));
 
-    const asset = await this.repo.findAssetById(input.mediaAssetId, ctx, orgId);
-    if (!asset) {
-      return Err(new CommerceNotFoundError("Media asset not found."));
-    }
+        const asset = await this.repo.findAssetById(input.mediaAssetId, txCtx, orgId);
+        if (!asset) return Err(new CommerceNotFoundError("Media asset not found."));
 
-    await this.repo.createEntityMedia(
-      {
-        entityId: input.entityId,
-        mediaAssetId: input.mediaAssetId,
-        role: input.role,
-        sortOrder: input.sortOrder ?? 0,
-        ...(input.variantId !== undefined
-          ? { variantId: input.variantId }
-          : {}),
-      },
-      ctx,
-    );
+        const existing = await this.repo.findEntityMedia(input.entityId, input.variantId, txCtx);
+        if (existing.some((link) => link.mediaAssetId === input.mediaAssetId)) {
+          return Err(new CommerceConflictError("Media asset is already attached at this level."));
+        }
 
-    return Ok(undefined);
+        await this.repo.createEntityMedia(
+          {
+            entityId: input.entityId,
+            mediaAssetId: input.mediaAssetId,
+            role: input.role,
+            sortOrder: input.sortOrder ?? 0,
+            ...(input.variantId !== undefined
+              ? { variantId: input.variantId }
+              : {}),
+          },
+          txCtx,
+        );
+
+        const catalog = this.deps.services?.catalog;
+        if (catalog == null || typeof catalog !== "object") {
+          throw new Error("Catalog service is required for media revision capture.");
+        }
+        const catalogService = catalog as {
+          recordEntityRevision: (
+            entityId: string,
+            actor: Actor | null,
+            reason?: "create" | "update" | "import" | "enrichment" | "push" | "restore",
+            ctx?: TxContext,
+          ) => Promise<Result<unknown>>;
+        };
+        const revision = await catalogService.recordEntityRevision(input.entityId, actor ?? txCtx.actor, "update", txCtx);
+        if (!revision.ok) throw revision.error;
+        return Ok(undefined);
+      });
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        return Err(new CommerceConflictError("Media asset is already attached at this level."));
+      }
+      return Err(toCommerceError(error));
+    }
   }
 
   /**

package/src/modules/orders/service.ts

@@ -42,6 +42,8 @@ import {
 } from "./repository/index.js";
 
 export interface CreateOrderInput {
+  /** Server-allocated id for trusted pipelines that must reference the order before persistence. */
+  id?: string;
   customerId?: string;
   /** Client-supplied retry key — a repeat create with the same key returns the original order. */
   idempotencyKey?: string | undefined;
@@ -379,6 +381,7 @@ export class OrderService {
     try {
       order = await this.repo.create(
         {
+          ...(opts?.trustedPricing === true && processed.id != null ? { id: processed.id } : {}),
           organizationId: orgId,
           orderNumber,
           status: "pending",

package/src/modules/pricing/schema.ts

@@ -15,6 +15,7 @@ export const prices = pgTable(
     variantId: uuid("variant_id").references(() => variants.id, { onDelete: "cascade" }),
     currency: text("currency").notNull(),
     amount: integer("amount").notNull(),
+    compareAtAmount: integer("compare_at_amount"),
     customerGroupId: text("customer_group_id"),
     minQuantity: integer("min_quantity"),
     maxQuantity: integer("max_quantity"),

package/src/modules/pricing/schemas.ts

@@ -7,6 +7,7 @@ export const SetBasePriceBodySchema = z.object({
   variantId: z.string().optional().openapi({ example: "variant-uuid" }),
   currency: z.string().length(3).openapi({ example: "USD" }),
   amount: z.number().openapi({ example: 29.99 }),
+  compareAtAmount: z.number().nullable().optional(),
   customerGroupId: z.string().optional(),
   minQuantity: z.number().int().optional(),
   maxQuantity: z.number().int().optional(),

package/src/modules/pricing/service.ts

@@ -224,6 +224,7 @@ export class PricingService {
       entityId: input.entityId,
       currency: normalizeCurrency(input.currency),
       amount: input.amount,
+      ...(input.compareAtAmount !== undefined ? { compareAtAmount: input.compareAtAmount } : {}),
       metadata: input.metadata ?? {},
       variantId: input.variantId ?? null,
       customerGroupId: input.customerGroupId ?? null,
@@ -252,8 +253,12 @@ export class PricingService {
 
     const record = existing
       ? (await this.repo.updatePrice(
-          existing.id,
-          { amount: priceData.amount, metadata: priceData.metadata },
+        existing.id,
+          {
+            amount: priceData.amount,
+            ...(priceData.compareAtAmount !== undefined ? { compareAtAmount: priceData.compareAtAmount } : {}),
+            metadata: priceData.metadata,
+          },
           ctx,
         )) ?? existing
       : await this.repo.createPrice(priceData, ctx);

package/src/modules/search/adapter.ts

@@ -10,6 +10,7 @@ export interface SearchDocument {
   categories: string[];
   brands: string[];
   text: string;
+  attributes?: Record<string, string | string[]>;
   payload?: Record<string, unknown>;
 }
 
@@ -18,6 +19,7 @@ export interface SearchFilters {
   category?: string;
   brand?: string;
   status?: string;
+  attributes?: Record<string, string | string[]>;
 }
 
 export interface SearchQueryParams {

package/src/modules/search/module.ts

@@ -16,6 +16,8 @@ export const searchModule = defineModule<Record<string, never>, SearchService, S
       const config = deps.config as CommerceConfig;
       return new SearchService({
         catalogRepository: deps.services.catalog.repository,
+        resolveEntityFieldDefinitions: deps.services.catalog.resolveEntityFieldDefinitions.bind(deps.services.catalog),
+        ...(config.entities ? { entities: config.entities } : {}),
         ...(config.search?.adapter ? { adapter: config.search.adapter } : {}),
         ...(config.search?.defaultFacets
           ? { defaultFacets: config.search.defaultFacets }

package/src/modules/search/service.ts

@@ -1,7 +1,12 @@
 import { Ok, type Result } from "../../kernel/result.js";
 import { resolveOrgId } from "../../auth/org.js";
 import type { TxContext } from "../../kernel/database/tx-context.js";
-import type { CatalogRepository, SellableEntity } from "../catalog/repository/index.js";
+import type { CommerceConfig } from "../../config/types.js";
+import type {
+  CatalogRepository,
+  SellableCustomField,
+  SellableEntity,
+} from "../catalog/repository/index.js";
 import type {
   SearchAdapter,
   SearchDocument,
@@ -10,9 +15,12 @@ import type {
   SearchQueryResult,
   SearchSuggestParams,
 } from "./adapter.js";
+import type { EntityFieldDefinitionResolver } from "../catalog/service.js";
 
 interface SearchServiceDeps {
   catalogRepository: CatalogRepository;
+  entities?: CommerceConfig["entities"];
+  resolveEntityFieldDefinitions?: EntityFieldDefinitionResolver;
   adapter?: SearchAdapter;
   defaultFacets?: string[];
 }
@@ -39,6 +47,19 @@ function includesAllTokens(haystack: string, tokens: string[]): boolean {
   return tokens.every((token) => lower.includes(token));
 }
 
+function customFieldValue(field: SellableCustomField): string | undefined {
+  if (field.textValue != null) return field.textValue;
+  if (field.numberValue != null) return String(field.numberValue);
+  if (field.booleanValue != null) return String(field.booleanValue);
+  if (field.dateValue != null) return field.dateValue.toISOString();
+  return undefined;
+}
+
+function attributeValues(value: string | string[] | undefined): string[] {
+  if (value == null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
 function scoreText(document: SearchDocument, tokens: string[]): number {
   if (tokens.length === 0) return 1;
 
@@ -109,16 +130,43 @@ export class SearchService {
     entity: SellableEntity,
     ctx?: TxContext,
   ): Promise<SearchDocument> {
-    const attributes =
+    const localizedAttributes =
       await this.deps.catalogRepository.findAttributesByEntityId(
         entity.id,
         ctx,
       );
-    const primary = attributes[0];
+    const primary = localizedAttributes[0];
     const title = primary?.title ?? entity.slug;
     const description = primary?.description;
     const categories = await this.entityCategories(entity.id, ctx);
     const brands = await this.entityBrands(entity.id, ctx);
+    const definitions = this.deps.resolveEntityFieldDefinitions
+      ? await this.deps.resolveEntityFieldDefinitions(entity.type, entity.organizationId, ctx)
+      : (this.deps.entities?.[entity.type]?.fields ?? []);
+    const filterableFields = new Set(
+      definitions
+        .filter((field) => field.filterable === true)
+        .map((field) => field.name),
+    );
+    const customFields = await this.deps.catalogRepository.findCustomFieldsByEntityId(
+      entity.id,
+      ctx,
+    );
+    const attributeValuesByName = new Map<string, string[]>();
+    for (const field of customFields) {
+      if (field.locale !== "en" || !filterableFields.has(field.fieldName)) continue;
+      const value = customFieldValue(field);
+      if (value == null) continue;
+      const values = attributeValuesByName.get(field.fieldName) ?? [];
+      if (!values.includes(value)) values.push(value);
+      attributeValuesByName.set(field.fieldName, values);
+    }
+    const attributes = Object.fromEntries(
+      [...attributeValuesByName.entries()].map(([name, values]) => [
+        name,
+        values.length === 1 ? values[0]! : values,
+      ]),
+    ) as Record<string, string | string[]>;
 
     const textParts: string[] = [
       entity.slug,
@@ -126,8 +174,8 @@ export class SearchService {
       description ?? "",
       ...categories,
       ...brands,
-      ...attributes.map((attr) => attr.title),
-      ...attributes.map((attr) => attr.description ?? ""),
+      ...localizedAttributes.map((attr) => attr.title),
+      ...localizedAttributes.map((attr) => attr.description ?? ""),
     ];
 
     return {
@@ -140,6 +188,7 @@ export class SearchService {
       categories,
       brands,
       text: textParts.join(" ").trim(),
+      ...(Object.keys(attributes).length > 0 ? { attributes } : {}),
       payload: {
         metadata: entity.metadata ?? undefined,
       },
@@ -168,6 +217,11 @@ export class SearchService {
     if (filters.category && !document.categories.includes(filters.category))
       return false;
     if (filters.brand && !document.brands.includes(filters.brand)) return false;
+    for (const [name, requested] of Object.entries(filters.attributes ?? {})) {
+      const actual = attributeValues(document.attributes?.[name]);
+      const expected = attributeValues(requested);
+      if (!expected.some((value) => actual.includes(value))) return false;
+    }
     return true;
   }
 
@@ -214,6 +268,26 @@ export class SearchService {
           }
         }
       }
+
+      const attributeName = facet.startsWith("attributes.")
+        ? facet.slice("attributes.".length)
+        : facet;
+      if (
+        attributeName !== "type" &&
+        attributeName !== "status" &&
+        attributeName !== "category" &&
+        attributeName !== "categories" &&
+        attributeName !== "brand" &&
+        attributeName !== "brands"
+      ) {
+        const values: Record<string, number> = {};
+        for (const document of documents) {
+          for (const value of new Set(attributeValues(document.attributes?.[attributeName]))) {
+            values[value] = (values[value] ?? 0) + 1;
+          }
+        }
+        if (Object.keys(values).length > 0) output[attributeName] = values;
+      }
     }
 
     return output;
@@ -255,7 +329,14 @@ export class SearchService {
     // In-memory fallback: require a non-empty query to avoid loading all entities
     // (allDocuments triggers N+1 DB queries per entity — unsafe at scale)
     const tokens = tokenize(safeQuery);
-    if (tokens.length === 0 && !params.filters?.type && !params.filters?.category && !params.filters?.brand && !params.filters?.status) {
+    if (
+      tokens.length === 0 &&
+      !params.filters?.type &&
+      !params.filters?.category &&
+      !params.filters?.brand &&
+      !params.filters?.status &&
+      Object.keys(params.filters?.attributes ?? {}).length === 0
+    ) {
       return Ok({ hits: [], total: 0, page, limit, facets: {} });
     }
 

package/src/utils/id.ts

@@ -1,3 +1,14 @@
 export function makeId(): string {
   return crypto.randomUUID();
 }
+
+export async function makeDeterministicId(value: string): Promise<string> {
+  const digest = new Uint8Array(
+    await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value)),
+  );
+  const bytes = digest.slice(0, 16);
+  bytes[6] = (bytes[6]! & 0x0f) | 0x80;
+  bytes[8] = (bytes[8]! & 0x3f) | 0x80;
+  const hex = [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}