@openhi/constructs 0.0.111 → 0.0.112

package/lib/provision-default-workspace.handler.js

@@ -24,10 +24,10 @@ __export(provision_default_workspace_handler_exports, {
 });
 module.exports = __toCommonJS(provision_default_workspace_handler_exports);
 var import_node_crypto = require("crypto");
-var import_types10 = require("@openhi/types");
+var import_types14 = require("@openhi/types");
 
 // src/data/dynamo/dynamo-control-service.ts
-var import_electrodb8 = require("electrodb");
+var import_electrodb14 = require("electrodb");
 
 // src/data/dynamo/dynamo-client.ts
 var import_client_dynamodb = require("@aws-sdk/client-dynamodb");
@@ -91,6 +91,60 @@ var gsi1skAttribute = {
     return label !== void 0 ? `${label}#${id}` : fallback;
   }
 };
+function extractRoleId(resource) {
+  const flat = resource.roleId;
+  if (typeof flat === "string" && flat.length > 0) return flat;
+  const role = resource.role;
+  if (role && typeof role === "object") {
+    const reference = role.reference;
+    if (typeof reference === "string" && reference.length > 0) {
+      const slash = reference.lastIndexOf("/");
+      const tail = slash >= 0 ? reference.slice(slash + 1) : reference;
+      if (tail.length > 0) return tail;
+    }
+  }
+  return void 0;
+}
+var roleAssignmentGsi1skAttribute = {
+  type: "string",
+  watch: ["resource", "denormalizedUserName", "lastUpdated", "id"],
+  set: (_val, item) => {
+    const id = typeof item?.id === "string" ? item.id : "";
+    const lastUpdated = typeof item?.lastUpdated === "string" ? item.lastUpdated : "";
+    const fallback = `${lastUpdated}#${id}`;
+    if (typeof item?.resource !== "string" || item.resource.length === 0) {
+      return fallback;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(item.resource);
+    } catch {
+      return fallback;
+    }
+    if (!parsed || typeof parsed !== "object") return fallback;
+    const roleId = extractRoleId(parsed);
+    if (roleId === void 0) return fallback;
+    const denormalizedUserName = typeof item.denormalizedUserName === "string" ? item.denormalizedUserName : "";
+    const normalizedUserName = denormalizedUserName.length > 0 ? (0, import_types.normalizeLabel)(denormalizedUserName) : "";
+    if (normalizedUserName.length === 0) return fallback;
+    return `${roleId}#${normalizedUserName}#${id}`;
+  }
+};
+var membershipGsi1skAttribute = {
+  type: "string",
+  watch: ["denormalizedUserName", "lastUpdated", "id"],
+  set: (_val, item) => {
+    const id = typeof item?.id === "string" ? item.id : "";
+    const lastUpdated = typeof item?.lastUpdated === "string" ? item.lastUpdated : "";
+    const fallback = `${lastUpdated}#${id}`;
+    const denormalizedUserName = typeof item?.denormalizedUserName === "string" ? item.denormalizedUserName : "";
+    const normalizedUserName = denormalizedUserName.length > 0 ? (0, import_types.normalizeLabel)(denormalizedUserName) : "";
+    if (normalizedUserName.length === 0) {
+      return fallback;
+    }
+    return `${normalizedUserName}#${id}`;
+  }
+};
 
 // src/data/dynamo/entities/control/configuration-entity.ts
 var ConfigurationEntity = new import_electrodb.Entity({
@@ -217,9 +271,239 @@ var ConfigurationEntity = new import_electrodb.Entity({
   }
 });
 
-// src/data/dynamo/entities/control/membership-entity.ts
+// src/data/dynamo/entities/control/configuration-user-projection-entity.ts
 var import_electrodb2 = require("electrodb");
-var MembershipEntity = new import_electrodb2.Entity({
+var ConfigurationUserProjectionEntity = new import_electrodb2.Entity({
+  model: {
+    entity: "configurationUserProjection",
+    service: "control",
+    version: "01"
+  },
+  attributes: {
+    /**
+     * User partition discriminator. Renders as `USER#ID#<userId>` on the
+     * base-table PK. Always required — the projection has no meaning
+     * outside a user partition.
+     */
+    userId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Pre-composed sort key — built by the operations-layer projection
+     * writer via `buildConfigurationUserProjectionSk`. The entity stores
+     * the value verbatim so the SK grammar (pattern #10 user-scope) is
+     * owned by the operations layer, not duplicated here.
+     */
+    sk: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Configuration canonical-record id. Stored as a discriminating
+     * field so consumers can hydrate the canonical row via the
+     * Configuration get-by-id operation when the projection's `summary`
+     * is insufficient.
+     */
+    configurationId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Tenant the Configuration is associated with. The canonical row
+     * keys off `(tenantId, workspaceId, userId, roleId)`; the projection
+     * carries `tenantId` so consumers reconstructing the canonical PK
+     * have the tenant segment without a hop.
+     */
+    tenantId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Scope marker. Always `"user"` on this projection — recorded
+     * explicitly so future scope-bearing projections (workspace,
+     * tenant, role) can share filter semantics in a unified
+     * cross-projection list query if one ever lands.
+     */
+    scope: {
+      type: "string",
+      required: true,
+      default: "user"
+    },
+    /**
+     * Configuration's `key` attribute (config category, e.g. endpoints,
+     * branding, display). Mirrored from the canonical row so consumers
+     * reading the projection get the natural display label without a
+     * BatchGet hop. Doubles as the source of `<normalizedConfigName>` in
+     * the SK.
+     */
+    displayName: {
+      type: "string",
+      required: false
+    },
+    /**
+     * Summary projection (key display fields as JSON string) — mirrored
+     * from the canonical Configuration row so user-partition queries do
+     * not need a BatchGet hop.
+     */
+    summary: {
+      type: "string",
+      required: true
+    },
+    /** Version id mirrored from the canonical Configuration row. */
+    vid: {
+      type: "string",
+      required: true
+    },
+    /** Last-updated timestamp mirrored from the canonical Configuration row. */
+    lastUpdated: {
+      type: "string",
+      required: true
+    }
+  },
+  indexes: {
+    /**
+     * Base table: PK = USER#ID#<userId>, SK = operation-supplied. A
+     * single `Query(PK = USER#ID#<userId>, SK begins_with
+     * 'CONFIGURATION#')` returns the user's user-scoped Configurations
+     * sorted by `<normalizedConfigName>` (then `<configurationId>` as
+     * the tiebreaker).
+     */
+    record: {
+      pk: {
+        field: "PK",
+        composite: ["userId"],
+        template: "USER#ID#${userId}"
+      },
+      sk: {
+        field: "SK",
+        casing: "none",
+        composite: ["sk"],
+        template: "${sk}"
+      }
+    }
+  }
+});
+
+// src/data/dynamo/entities/control/configuration-workspace-projection-entity.ts
+var import_electrodb3 = require("electrodb");
+var ConfigurationWorkspaceProjectionEntity = new import_electrodb3.Entity({
+  model: {
+    entity: "configurationWorkspaceProjection",
+    service: "control",
+    version: "01"
+  },
+  attributes: {
+    /**
+     * Tenant the workspace belongs to. Renders as the leading segment
+     * of the base-table PK. Always required — the workspace partition
+     * is tenant-scoped per ADR-011.
+     */
+    tenantId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Workspace partition discriminator. Renders as the trailing
+     * segment of the base-table PK
+     * (`TID#<tenantId>#WORKSPACE#ID#<workspaceId>`). Always required —
+     * the projection has no meaning outside a workspace partition.
+     */
+    workspaceId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Pre-composed sort key — built by the operations-layer projection
+     * writer via `buildConfigurationWorkspaceProjectionSk`. The entity
+     * stores the value verbatim so the SK grammar (pattern #10
+     * workspace-scope) is owned by the operations layer, not
+     * duplicated here.
+     */
+    sk: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Configuration canonical-record id. Stored as a discriminating
+     * field so consumers can hydrate the canonical row via the
+     * Configuration get-by-id operation when the projection's `summary`
+     * is insufficient.
+     */
+    configurationId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Scope marker. Always `"workspace"` on this projection — recorded
+     * explicitly so future scope-bearing projections (user, tenant,
+     * role) can share filter semantics in a unified cross-projection
+     * list query if one ever lands.
+     */
+    scope: {
+      type: "string",
+      required: true,
+      default: "workspace"
+    },
+    /**
+     * Configuration's `key` attribute (config category, e.g. endpoints,
+     * branding, display). Mirrored from the canonical row so consumers
+     * reading the projection get the natural display label without a
+     * BatchGet hop. Doubles as the source of `<normalizedConfigName>`
+     * in the SK.
+     */
+    displayName: {
+      type: "string",
+      required: false
+    },
+    /**
+     * Summary projection (key display fields as JSON string) — mirrored
+     * from the canonical Configuration row so workspace-partition
+     * queries do not need a BatchGet hop.
+     */
+    summary: {
+      type: "string",
+      required: true
+    },
+    /** Version id mirrored from the canonical Configuration row. */
+    vid: {
+      type: "string",
+      required: true
+    },
+    /** Last-updated timestamp mirrored from the canonical Configuration row. */
+    lastUpdated: {
+      type: "string",
+      required: true
+    }
+  },
+  indexes: {
+    /**
+     * Base table: PK = TID#<tenantId>#WORKSPACE#ID#<workspaceId>,
+     * SK = operation-supplied. A single
+     * `Query(PK = TID#<tenantId>#WORKSPACE#ID#<workspaceId>, SK begins_with 'CONFIGURATION#')`
+     * returns the workspace's workspace-scoped Configurations sorted by
+     * `<normalizedConfigName>` (then `<configurationId>` as the
+     * tiebreaker).
+     */
+    record: {
+      pk: {
+        field: "PK",
+        composite: ["tenantId", "workspaceId"],
+        template: "TID#${tenantId}#WORKSPACE#ID#${workspaceId}"
+      },
+      sk: {
+        field: "SK",
+        casing: "none",
+        composite: ["sk"],
+        template: "${sk}"
+      }
+    }
+  }
+});
+
+// src/data/dynamo/entities/control/membership-entity.ts
+var import_electrodb4 = require("electrodb");
+var MembershipEntity = new import_electrodb4.Entity({
   model: {
     entity: "membership",
     service: "control",
@@ -265,8 +549,14 @@ var MembershipEntity = new import_electrodb2.Entity({
       required: true
     },
     gsi1Shard: gsi1ShardAttribute,
-    /** Derived GSI1 sort key — name-based when extractable; else `<lastUpdated>#<id>`. */
-    gsi1sk: gsi1skAttribute,
+    /**
+     * Derived GSI1 sort key — `<normalizedUserName>#<id>` per ADR-018
+     * pattern #1 so a GSI1 query partitioned on the tenant range-scans
+     * by user-name prefix and returns memberships sorted by user name.
+     * Falls back to `<lastUpdated>#<id>` when `denormalizedUserName`
+     * is missing.
+     */
+    gsi1sk: membershipGsi1skAttribute,
     deleted: {
       type: "boolean",
       required: false
@@ -288,6 +578,36 @@ var MembershipEntity = new import_electrodb2.Entity({
     linkedDataIdentityRef: {
       type: "string",
       required: false
+    },
+    /**
+     * Denormalized display name of the linked Tenant, captured at row
+     * last-write time. Promoted to a top-level attribute so the ADR-018
+     * adjacency-list projection SKs (pattern #3 — `MEMBERSHIP#TENANT#<normalizedTenantName>#…`)
+     * can be composed from a top-level field instead of digging into the
+     * `resource` JSON. Optional on the schema so pre-TR-024 rows do not
+     * break; the operations-layer multi-write helper (#1010) makes the
+     * field load-bearing at write time per TR-024 rule 2 (write-time
+     * source = canonical Tenant.displayName).
+     * @see TR-024 — Denormalized display-name attributes
+     */
+    denormalizedTenantName: {
+      type: "string",
+      required: false
+    },
+    /**
+     * Denormalized display name of the linked User, captured at row
+     * last-write time. Promoted to a top-level attribute so the ADR-018
+     * adjacency-list canonical-record GSI1SK (pattern #1 —
+     * `<normalizedUserName>#<id>`) and workspace-projection SK (pattern #2)
+     * can be composed from a top-level field. Optional on the schema so
+     * pre-TR-024 rows do not break; the operations-layer multi-write helper
+     * (#1010) makes the field load-bearing at write time per TR-024 rule 2
+     * (write-time source = canonical User.displayName).
+     * @see TR-024 — Denormalized display-name attributes
+     */
+    denormalizedUserName: {
+      type: "string",
+      required: false
     }
   },
   indexes: {
@@ -307,9 +627,11 @@ var MembershipEntity = new import_electrodb2.Entity({
     /**
      * GSI1 — Unified Sharded List per ADR-011: list all Memberships for a tenant across the
      * four shards. Membership is tenant-scoped only, so `WID#-` is a sentinel.
-     * SK is derived via `gsi1skAttribute` — uses the resource's natural label when
-     * extractable, else `<lastUpdated>#<id>` (DR-004). `casing: "none"` preserves the
-     * normalized label and ISO-8601 `T`/`Z`.
+     * SK is derived via `membershipGsi1skAttribute` — composes
+     * `<normalizedUserName>#<id>` per ADR-018 pattern #1 (users in a
+     * tenant, sorted by user name); falls back to `<lastUpdated>#<id>`
+     * when `denormalizedUserName` is missing. `casing: "none"` preserves
+     * the normalized label and ISO-8601 `T`/`Z`.
      */
     gsi1: {
       index: "GSI1",
@@ -328,206 +650,781 @@ var MembershipEntity = new import_electrodb2.Entity({
   }
 });
 
-// src/data/dynamo/entities/control/role-entity.ts
-var import_electrodb3 = require("electrodb");
-var RoleEntity = new import_electrodb3.Entity({
+// src/data/dynamo/entities/control/membership-user-projection-entity.ts
+var import_electrodb5 = require("electrodb");
+var MembershipUserProjectionEntity = new import_electrodb5.Entity({
   model: {
-    entity: "role",
+    entity: "membershipUserProjection",
     service: "control",
     version: "01"
   },
   attributes: {
-    /** Sort key sentinel. Always "CURRENT". */
+    /**
+     * User partition discriminator. Renders as `USER#ID#<userId>` on the
+     * base-table PK. Always required — the projection has no meaning
+     * outside a user partition.
+     */
+    userId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Pre-composed sort key — built by the operations-layer projection
+     * writer via `buildMembershipUserProjectionSk*` helpers. The entity
+     * stores the value verbatim so the SK grammar (patterns #3 and #4)
+     * is owned by the operations layer, not duplicated here.
+     */
     sk: {
       type: "string",
-      required: true,
-      default: "CURRENT"
+      required: true
     },
-    /** FHIR Resource.id; role id. */
-    id: {
+    /** Tenant in which the membership applies. Always required. */
+    tenantId: {
       type: "string",
       required: true
     },
-    /** Full Role resource serialized as JSON string. */
-    resource: {
+    /**
+     * Workspace the membership scopes to. Present iff the projection
+     * row is a pattern-#4 workspace sub-lane row; absent for pattern-#3
+     * tenant sub-lane rows.
+     */
+    workspaceId: {
+      type: "string",
+      required: false
+    },
+    /**
+     * Membership canonical-record id. Stored as a discriminating field
+     * so consumers can hydrate the canonical row via
+     * `MembershipEntity.get({ tenantId, id: membershipId })` when the
+     * projection's `summary` is insufficient.
+     */
+    membershipId: {
       type: "string",
       required: true
     },
     /**
-     * Summary projection (key display fields as JSON string: id, displayName, status).
-     * Populated on every write via extractSummary(resource); GSI1 INCLUDE surfaces it on lists.
+     * Summary projection (key display fields as JSON string: id,
+     * displayName, status) — mirrored from the canonical Membership row
+     * so user-partition queries do not need a BatchGet hop.
      */
     summary: {
       type: "string",
       required: true
     },
-    /** Version id (e.g. ULID). */
+    /** Version id mirrored from the canonical Membership row. */
     vid: {
       type: "string",
       required: true
     },
+    /** Last-updated timestamp mirrored from the canonical Membership row. */
     lastUpdated: {
       type: "string",
       required: true
     },
-    gsi1Shard: gsi1ShardAttribute,
-    /** Derived GSI1 sort key — name-based when extractable; else `<lastUpdated>#<id>`. */
-    gsi1sk: gsi1skAttribute,
-    deleted: {
-      type: "boolean",
+    /**
+     * Denormalized Tenant display name — required to compose pattern-#3
+     * SK (`MEMBERSHIP#TENANT#<normalizedTenantName>#…`). Optional on the
+     * schema because pre-TR-024 rows may not carry a display name; the
+     * operations layer falls back gracefully when missing.
+     */
+    denormalizedTenantName: {
+      type: "string",
       required: false
     },
-    bundleId: {
+    /**
+     * Denormalized User display name — mirrored from the canonical
+     * Membership row per TR-024 rule 3 (canonical-record symmetry).
+     * Carried on the projection so consumers can render the user's
+     * display name without a hop to the User record.
+     */
+    denormalizedUserName: {
       type: "string",
       required: false
     },
-    msgId: {
+    /**
+     * Denormalized Workspace display name — required to compose
+     * pattern-#4 SK (`MEMBERSHIP#WORKSPACE#TID#<tenantId>#<normalizedWorkspaceName>#…`).
+     * Optional on the schema (TR-024 § Open Item #4 defers a formal
+     * Workspace-rename cascade); the operations layer falls back to a
+     * sentinel when missing so the SK still has a valid shape.
+     */
+    denormalizedWorkspaceName: {
       type: "string",
       required: false
     }
   },
   indexes: {
-    /** Base table: PK = ROLE#ID#<id>, SK = CURRENT. Do not supply PK or SK from outside. */
+    /**
+     * Base table: PK = USER#ID#<userId>, SK = operation-supplied.
+     * Both pattern #3 and pattern #4 use this same index — the SK string
+     * encodes the lane discriminator (`MEMBERSHIP#TENANT#…` vs
+     * `MEMBERSHIP#WORKSPACE#…`) so a single `Query(PK = USER#ID#<userId>,
+     * SK begins_with 'MEMBERSHIP#')` returns both lanes interleaved.
+     */
+    record: {
+      pk: {
+        field: "PK",
+        composite: ["userId"],
+        template: "USER#ID#${userId}"
+      },
+      sk: {
+        field: "SK",
+        casing: "none",
+        composite: ["sk"],
+        template: "${sk}"
+      }
+    }
+  }
+});
+
+// src/data/dynamo/entities/control/membership-workspace-projection-entity.ts
+var import_electrodb6 = require("electrodb");
+var MembershipWorkspaceProjectionEntity = new import_electrodb6.Entity({
+  model: {
+    entity: "membershipWorkspaceProjection",
+    service: "control",
+    version: "01"
+  },
+  attributes: {
+    /**
+     * Tenant the workspace belongs to. Renders as the leading segment
+     * of the base-table PK. Always required — the workspace partition
+     * is tenant-scoped per ADR-011.
+     */
+    tenantId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Workspace partition discriminator. Renders as the trailing
+     * segment of the base-table PK
+     * (`TID#<tenantId>#WORKSPACE#ID#<workspaceId>`). Always required —
+     * the projection has no meaning outside a workspace partition.
+     */
+    workspaceId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Pre-composed sort key — built by the operations-layer projection
+     * writer via `buildMembershipWorkspaceProjectionSk`. The entity
+     * stores the value verbatim so the SK grammar (pattern #2) is
+     * owned by the operations layer, not duplicated here.
+     */
+    sk: {
+      type: "string",
+      required: true
+    },
+    /**
+     * User the membership links. Stored as a discriminating field so
+     * consumers can hydrate the canonical User row via
+     * `UserEntity.get({ id: userId, sk: "CURRENT" })` when the
+     * projection's `summary` is insufficient.
+     */
+    userId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Membership canonical-record id. Stored as a discriminating field
+     * so consumers can hydrate the canonical row via
+     * `MembershipEntity.get({ tenantId, id: membershipId })` when the
+     * projection's `summary` is insufficient.
+     */
+    membershipId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Summary projection (key display fields as JSON string: id,
+     * displayName, status) — mirrored from the canonical Membership row
+     * so workspace-partition queries do not need a BatchGet hop.
+     */
+    summary: {
+      type: "string",
+      required: true
+    },
+    /** Version id mirrored from the canonical Membership row. */
+    vid: {
+      type: "string",
+      required: true
+    },
+    /** Last-updated timestamp mirrored from the canonical Membership row. */
+    lastUpdated: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Denormalized User display name — required to compose the
+     * pattern-#2 SK (`MEMBERSHIP#<normalizedUserName>#…`). Optional on
+     * the schema because pre-TR-024 rows may not carry a display name;
+     * the operations layer falls back to a sentinel when missing so
+     * the SK still has a valid shape. The TR-023 rename-cascade
+     * pipeline rewrites the SK on a User rename.
+     */
+    denormalizedUserName: {
+      type: "string",
+      required: false
+    }
+  },
+  indexes: {
+    /**
+     * Base table: PK = TID#<tenantId>#WORKSPACE#ID#<workspaceId>,
+     * SK = operation-supplied. Pattern #2 uses this index — the SK
+     * encodes the entity-type prefix (`MEMBERSHIP#…`) so a
+     * `Query(PK = TID#<tenantId>#WORKSPACE#ID#<workspaceId>, SK begins_with 'MEMBERSHIP#')`
+     * returns every member projection for the workspace in normalized-
+     * user-name sort order.
+     */
+    record: {
+      pk: {
+        field: "PK",
+        composite: ["tenantId", "workspaceId"],
+        template: "TID#${tenantId}#WORKSPACE#ID#${workspaceId}"
+      },
+      sk: {
+        field: "SK",
+        casing: "none",
+        composite: ["sk"],
+        template: "${sk}"
+      }
+    }
+  }
+});
+
+// src/data/dynamo/entities/control/role-entity.ts
+var import_electrodb7 = require("electrodb");
+var RoleEntity = new import_electrodb7.Entity({
+  model: {
+    entity: "role",
+    service: "control",
+    version: "01"
+  },
+  attributes: {
+    /** Sort key sentinel. Always "CURRENT". */
+    sk: {
+      type: "string",
+      required: true,
+      default: "CURRENT"
+    },
+    /** FHIR Resource.id; role id. */
+    id: {
+      type: "string",
+      required: true
+    },
+    /** Full Role resource serialized as JSON string. */
+    resource: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Summary projection (key display fields as JSON string: id, displayName, status).
+     * Populated on every write via extractSummary(resource); GSI1 INCLUDE surfaces it on lists.
+     */
+    summary: {
+      type: "string",
+      required: true
+    },
+    /** Version id (e.g. ULID). */
+    vid: {
+      type: "string",
+      required: true
+    },
+    lastUpdated: {
+      type: "string",
+      required: true
+    },
+    gsi1Shard: gsi1ShardAttribute,
+    /** Derived GSI1 sort key — name-based when extractable; else `<lastUpdated>#<id>`. */
+    gsi1sk: gsi1skAttribute,
+    deleted: {
+      type: "boolean",
+      required: false
+    },
+    bundleId: {
+      type: "string",
+      required: false
+    },
+    msgId: {
+      type: "string",
+      required: false
+    }
+  },
+  indexes: {
+    /** Base table: PK = ROLE#ID#<id>, SK = CURRENT. Do not supply PK or SK from outside. */
+    record: {
+      pk: {
+        field: "PK",
+        composite: ["id"],
+        template: "ROLE#ID#${id}"
+      },
+      sk: {
+        field: "SK",
+        composite: ["sk"],
+        template: "${sk}"
+      }
+    },
+    /**
+     * GSI1 — Unified Sharded List per ADR-011: list all Roles across the four shards.
+     * Non-tenant-isolated, so `TID#-#WID#-` sentinels precede `RT#Role#SHARD#<n>`.
+     * SK is derived via `gsi1skAttribute` — uses the resource's natural label when
+     * extractable, else `<lastUpdated>#<id>` (DR-004). `casing: "none"` preserves the
+     * normalized label and ISO-8601 `T`/`Z`.
+     */
+    gsi1: {
+      index: "GSI1",
+      pk: {
+        field: "GSI1PK",
+        composite: ["gsi1Shard"],
+        template: "TID#-#WID#-#RT#Role#SHARD#${gsi1Shard}"
+      },
+      sk: {
+        field: "GSI1SK",
+        casing: "none",
+        composite: ["gsi1sk"],
+        template: "${gsi1sk}"
+      }
+    }
+  }
+});
+
+// src/data/dynamo/entities/control/roleassignment-entity.ts
+var import_electrodb8 = require("electrodb");
+var RoleAssignmentEntity = new import_electrodb8.Entity({
+  model: {
+    entity: "roleassignment",
+    service: "control",
+    version: "01"
+  },
+  attributes: {
+    /** Sort key sentinel. Always "CURRENT". */
+    sk: {
+      type: "string",
+      required: true,
+      default: "CURRENT"
+    },
+    /** Tenant in which the role assignment applies (required). */
+    tenantId: {
+      type: "string",
+      required: true
+    },
+    /** FHIR Resource.id; role assignment id. */
+    id: {
+      type: "string",
+      required: true
+    },
+    /** Full RoleAssignment resource serialized as JSON string. */
+    resource: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Summary projection (key display fields as JSON string: id, displayName, status).
+     * Populated on every write via extractSummary(resource); GSI1 INCLUDE surfaces it on lists.
+     */
+    summary: {
+      type: "string",
+      required: true
+    },
+    /** Version id (e.g. ULID). */
+    vid: {
+      type: "string",
+      required: true
+    },
+    lastUpdated: {
+      type: "string",
+      required: true
+    },
+    gsi1Shard: gsi1ShardAttribute,
+    /**
+     * Derived GSI1 sort key — discriminator-first
+     * `<roleId>#<normalizedUserName>#<id>` per ADR-018 pattern #8 so a
+     * GSI1 query partitioned on the tenant can `begins_with('<roleId>#')`
+     * to enumerate every user assigned to a given role, sorted by user
+     * name. Falls back to `<lastUpdated>#<id>` when either component is
+     * missing.
+     */
+    gsi1sk: roleAssignmentGsi1skAttribute,
+    deleted: {
+      type: "boolean",
+      required: false
+    },
+    bundleId: {
+      type: "string",
+      required: false
+    },
+    msgId: {
+      type: "string",
+      required: false
+    },
+    /**
+     * Denormalized display name of the linked Tenant, captured at row
+     * last-write time. Promoted to a top-level attribute so the ADR-018
+     * adjacency-list user-projection SK (pattern #5 —
+     * `ROLEASSIGNMENT#TENANT#<normalizedRoleName>#<roleId>#TID#<tenantId>#<id>`)
+     * can be composed from a top-level field instead of digging into the
+     * `resource` JSON. Optional on the schema so pre-TR-024 rows do not
+     * break; the operations-layer multi-write helper (#1010) makes the
+     * field load-bearing at write time per TR-024 rule 2 (write-time
+     * source = canonical Tenant.displayName).
+     * @see TR-024 — Denormalized display-name attributes
+     */
+    denormalizedTenantName: {
+      type: "string",
+      required: false
+    },
+    /**
+     * Denormalized display name of the linked User, captured at row
+     * last-write time. Promoted to a top-level attribute so the ADR-018
+     * adjacency-list canonical-record GSI1SK (pattern #8 —
+     * `<roleId>#<normalizedUserName>#<id>`) and workspace-projection SK
+     * (pattern #9) can be composed from a top-level field. Optional on
+     * the schema so pre-TR-024 rows do not break; the operations-layer
+     * multi-write helper (#1010) makes the field load-bearing at write
+     * time per TR-024 rule 2 (write-time source = canonical
+     * User.displayName).
+     * @see TR-024 — Denormalized display-name attributes
+     */
+    denormalizedUserName: {
+      type: "string",
+      required: false
+    },
+    /**
+     * Denormalized display name of the linked Role, captured at row
+     * last-write time. Promoted to a top-level attribute so the ADR-018
+     * adjacency-list user-projection SK (pattern #5 —
+     * `ROLEASSIGNMENT#TENANT#<normalizedRoleName>#…`) can be composed from
+     * a top-level field. Optional on the schema so pre-TR-024 rows do not
+     * break; the operations-layer multi-write helper (#1010) makes the
+     * field load-bearing at write time per TR-024 rule 2 (write-time
+     * source = canonical Role.displayName).
+     * @see TR-024 — Denormalized display-name attributes
+     */
+    denormalizedRoleName: {
+      type: "string",
+      required: false
+    }
+  },
+  indexes: {
+    /** Base table: PK = TID#<tenantId>#ROLEASSIGNMENT#ID#<id>, SK = CURRENT. Do not supply PK or SK from outside. */
+    record: {
+      pk: {
+        field: "PK",
+        composite: ["tenantId", "id"],
+        template: "TID#${tenantId}#ROLEASSIGNMENT#ID#${id}"
+      },
+      sk: {
+        field: "SK",
+        composite: ["sk"],
+        template: "${sk}"
+      }
+    },
+    /**
+     * GSI1 — Unified Sharded List per ADR-011: list all RoleAssignments for a tenant across the
+     * four shards. Tenant-scoped only, so `WID#-` is a sentinel.
+     * SK is derived via `roleAssignmentGsi1skAttribute` — composes the
+     * discriminator-first `<roleId>#<normalizedUserName>#<id>` shape per
+     * ADR-018 pattern #8 (users with a specific role in a tenant, sorted
+     * by user name); falls back to `<lastUpdated>#<id>` when either
+     * component is missing. `casing: "none"` preserves the normalized
+     * label and ISO-8601 `T`/`Z`.
+     */
+    gsi1: {
+      index: "GSI1",
+      pk: {
+        field: "GSI1PK",
+        composite: ["tenantId", "gsi1Shard"],
+        template: "TID#${tenantId}#WID#-#RT#RoleAssignment#SHARD#${gsi1Shard}"
+      },
+      sk: {
+        field: "GSI1SK",
+        casing: "none",
+        composite: ["gsi1sk"],
+        template: "${gsi1sk}"
+      }
+    }
+  }
+});
+
+// src/data/dynamo/entities/control/roleassignment-user-projection-entity.ts
+var import_electrodb9 = require("electrodb");
+var RoleAssignmentUserProjectionEntity = new import_electrodb9.Entity({
+  model: {
+    entity: "roleAssignmentUserProjection",
+    service: "control",
+    version: "01"
+  },
+  attributes: {
+    /**
+     * User partition discriminator. Renders as `USER#ID#<userId>` on the
+     * base-table PK. Always required — the projection has no meaning
+     * outside a user partition.
+     */
+    userId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Pre-composed sort key — built by the operations-layer projection
+     * writer via `buildRoleAssignmentUserProjectionSk*` helpers. The
+     * entity stores the value verbatim so the SK grammar (tenant-lane
+     * vs workspace-lane) is owned by the operations layer, not
+     * duplicated here.
+     */
+    sk: {
+      type: "string",
+      required: true
+    },
+    /** Tenant in which the role assignment applies. Always required. */
+    tenantId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Workspace the role assignment scopes to. Present iff the
+     * projection row is the workspace-level sub-lane; absent for
+     * tenant-level sub-lane rows.
+     */
+    workspaceId: {
+      type: "string",
+      required: false
+    },
+    /**
+     * Role the assignment grants. Stored as a discriminating field so
+     * `Query(PK = USER#ID#<userId>, SK begins_with 'ROLEASSIGNMENT#…')`
+     * results carry the role id without a hop to the canonical row.
+     */
+    roleId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * RoleAssignment canonical-record id. Stored as a discriminating
+     * field so consumers can hydrate the canonical row via
+     * `RoleAssignmentEntity.get({ tenantId, id: roleAssignmentId })`
+     * when the projection's `summary` is insufficient.
+     */
+    roleAssignmentId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Summary projection (key display fields as JSON string: id,
+     * displayName, status) — mirrored from the canonical RoleAssignment
+     * row so user-partition queries do not need a BatchGet hop.
+     */
+    summary: {
+      type: "string",
+      required: true
+    },
+    /** Version id mirrored from the canonical RoleAssignment row. */
+    vid: {
+      type: "string",
+      required: true
+    },
+    /** Last-updated timestamp mirrored from the canonical RoleAssignment row. */
+    lastUpdated: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Denormalized Tenant display name — mirrored from the canonical
+     * RoleAssignment row per TR-024 rule 3 (canonical-record symmetry).
+     * Optional on the schema because pre-TR-024 rows may not carry a
+     * display name; the operations layer falls back gracefully when
+     * missing.
+     */
+    denormalizedTenantName: {
+      type: "string",
+      required: false
+    },
+    /**
+     * Denormalized User display name — mirrored from the canonical
+     * RoleAssignment row per TR-024 rule 3 (canonical-record symmetry).
+     * Carried on the projection so consumers can render the user's
+     * display name without a hop to the User record.
+     */
+    denormalizedUserName: {
+      type: "string",
+      required: false
+    },
+    /**
+     * Denormalized Role display name — required to compose the SK's
+     * `<normalizedRoleName>` segment. Optional on the schema (pre-TR-024
+     * rows fall back to a sentinel) but expected to be present at write
+     * time per TR-024 rule 2 (write-time source =
+     * canonical Role.displayName).
+     */
+    denormalizedRoleName: {
+      type: "string",
+      required: false
+    }
+  },
+  indexes: {
+    /**
+     * Base table: PK = USER#ID#<userId>, SK = operation-supplied. Both
+     * sub-lanes (tenant-level and workspace-level) use this same index —
+     * the SK string encodes the lane discriminator
+     * (`ROLEASSIGNMENT#TENANT#…` vs `ROLEASSIGNMENT#WORKSPACE#…`) so a
+     * single `Query(PK = USER#ID#<userId>, SK begins_with
+     * 'ROLEASSIGNMENT#')` returns both lanes interleaved.
+     */
     record: {
       pk: {
         field: "PK",
-        composite: ["id"],
-        template: "ROLE#ID#${id}"
+        composite: ["userId"],
+        template: "USER#ID#${userId}"
       },
       sk: {
         field: "SK",
+        casing: "none",
         composite: ["sk"],
         template: "${sk}"
       }
-    },
-    /**
-     * GSI1 — Unified Sharded List per ADR-011: list all Roles across the four shards.
-     * Non-tenant-isolated, so `TID#-#WID#-` sentinels precede `RT#Role#SHARD#<n>`.
-     * SK is derived via `gsi1skAttribute` — uses the resource's natural label when
-     * extractable, else `<lastUpdated>#<id>` (DR-004). `casing: "none"` preserves the
-     * normalized label and ISO-8601 `T`/`Z`.
-     */
-    gsi1: {
-      index: "GSI1",
-      pk: {
-        field: "GSI1PK",
-        composite: ["gsi1Shard"],
-        template: "TID#-#WID#-#RT#Role#SHARD#${gsi1Shard}"
-      },
-      sk: {
-        field: "GSI1SK",
-        casing: "none",
-        composite: ["gsi1sk"],
-        template: "${gsi1sk}"
-      }
     }
   }
 });
 
-// src/data/dynamo/entities/control/roleassignment-entity.ts
-var import_electrodb4 = require("electrodb");
-var RoleAssignmentEntity = new import_electrodb4.Entity({
+// src/data/dynamo/entities/control/roleassignment-workspace-projection-entity.ts
+var import_electrodb10 = require("electrodb");
+var RoleAssignmentWorkspaceProjectionEntity = new import_electrodb10.Entity({
   model: {
-    entity: "roleassignment",
+    entity: "roleAssignmentWorkspaceProjection",
     service: "control",
     version: "01"
   },
   attributes: {
-    /** Sort key sentinel. Always "CURRENT". */
+    /**
+     * Tenant the workspace belongs to. Renders as the leading segment
+     * of the base-table PK. Always required — the workspace partition
+     * is tenant-scoped per ADR-011.
+     */
+    tenantId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Workspace partition discriminator. Renders as the trailing
+     * segment of the base-table PK
+     * (`TID#<tenantId>#WORKSPACE#ID#<workspaceId>`). Always required —
+     * the projection has no meaning outside a workspace partition.
+     */
+    workspaceId: {
+      type: "string",
+      required: true
+    },
+    /**
+     * Pre-composed sort key — built by the operations-layer projection
+     * writer via `buildRoleAssignmentWorkspaceProjectionSk`. The entity
+     * stores the value verbatim so the SK grammar (pattern #9) is
+     * owned by the operations layer, not duplicated here.
+     */
     sk: {
       type: "string",
-      required: true,
-      default: "CURRENT"
+      required: true
     },
-    /** Tenant in which the role assignment applies (required). */
-    tenantId: {
+    /**
+     * User the role assignment grants the role to. Stored as a
+     * discriminating field so consumers can hydrate the canonical User
+     * row via `UserEntity.get({ id: userId, sk: "CURRENT" })` when the
+     * projection's `summary` is insufficient.
+     */
+    userId: {
       type: "string",
       required: true
     },
-    /** FHIR Resource.id; role assignment id. */
-    id: {
+    /**
+     * Role the assignment grants. Stored as a discriminating field —
+     * also rendered into the SK as the discriminator-first segment so
+     * `begins_with('ROLEASSIGNMENT#<roleId>#')` filters one role.
+     */
+    roleId: {
       type: "string",
       required: true
     },
-    /** Full RoleAssignment resource serialized as JSON string. */
-    resource: {
+    /**
+     * RoleAssignment canonical-record id. Stored as a discriminating
+     * field so consumers can hydrate the canonical row via
+     * `RoleAssignmentEntity.get({ tenantId, id: roleAssignmentId })`
+     * when the projection's `summary` is insufficient.
+     */
+    roleAssignmentId: {
       type: "string",
       required: true
     },
     /**
-     * Summary projection (key display fields as JSON string: id, displayName, status).
-     * Populated on every write via extractSummary(resource); GSI1 INCLUDE surfaces it on lists.
+     * Summary projection (key display fields as JSON string: id,
+     * displayName, status) — mirrored from the canonical RoleAssignment
+     * row so workspace-partition queries do not need a BatchGet hop.
      */
     summary: {
       type: "string",
       required: true
     },
-    /** Version id (e.g. ULID). */
+    /** Version id mirrored from the canonical RoleAssignment row. */
     vid: {
       type: "string",
       required: true
     },
+    /** Last-updated timestamp mirrored from the canonical RoleAssignment row. */
     lastUpdated: {
       type: "string",
       required: true
     },
-    gsi1Shard: gsi1ShardAttribute,
-    /** Derived GSI1 sort key — name-based when extractable; else `<lastUpdated>#<id>`. */
-    gsi1sk: gsi1skAttribute,
-    deleted: {
-      type: "boolean",
-      required: false
-    },
-    bundleId: {
+    /**
+     * Denormalized User display name — required to compose the
+     * pattern-#9 SK (`ROLEASSIGNMENT#<roleId>#<normalizedUserName>#…`).
+     * Optional on the schema because pre-TR-024 rows may not carry a
+     * display name; the operations layer falls back to a sentinel when
+     * missing so the SK still has a valid shape. The TR-023 rename-
+     * cascade pipeline rewrites the SK on a User rename.
+     */
+    denormalizedUserName: {
       type: "string",
       required: false
     },
-    msgId: {
+    /**
+     * Denormalized Role display name — mirrored from the canonical
+     * RoleAssignment row per TR-024 rule 3 (canonical-record symmetry).
+     * Carried on the projection so consumers can render the role's
+     * display name without a hop to the Role record. Not part of the
+     * SK (pattern #9 sorts on `<normalizedUserName>`, not role name) —
+     * a Role rename does NOT rewrite this SK.
+     */
+    denormalizedRoleName: {
       type: "string",
       required: false
     }
   },
   indexes: {
-    /** Base table: PK = TID#<tenantId>#ROLEASSIGNMENT#ID#<id>, SK = CURRENT. Do not supply PK or SK from outside. */
+    /**
+     * Base table: PK = TID#<tenantId>#WORKSPACE#ID#<workspaceId>,
+     * SK = operation-supplied. Pattern #9 uses this index — the SK
+     * encodes the entity-type prefix and discriminator-first roleId
+     * (`ROLEASSIGNMENT#<roleId>#…`) so
+     * `Query(PK = TID#<tenantId>#WORKSPACE#ID#<workspaceId>, SK begins_with 'ROLEASSIGNMENT#<roleId>#')`
+     * returns every user-assignment for that role in the workspace, sorted
+     * by normalized user name.
+     */
     record: {
       pk: {
         field: "PK",
-        composite: ["tenantId", "id"],
-        template: "TID#${tenantId}#ROLEASSIGNMENT#ID#${id}"
+        composite: ["tenantId", "workspaceId"],
+        template: "TID#${tenantId}#WORKSPACE#ID#${workspaceId}"
       },
       sk: {
         field: "SK",
+        casing: "none",
         composite: ["sk"],
         template: "${sk}"
       }
-    },
-    /**
-     * GSI1 — Unified Sharded List per ADR-011: list all RoleAssignments for a tenant across the
-     * four shards. Tenant-scoped only, so `WID#-` is a sentinel.
-     * SK is derived via `gsi1skAttribute` — uses the resource's natural label when
-     * extractable, else `<lastUpdated>#<id>` (DR-004). `casing: "none"` preserves the
-     * normalized label and ISO-8601 `T`/`Z`.
-     */
-    gsi1: {
-      index: "GSI1",
-      pk: {
-        field: "GSI1PK",
-        composite: ["tenantId", "gsi1Shard"],
-        template: "TID#${tenantId}#WID#-#RT#RoleAssignment#SHARD#${gsi1Shard}"
-      },
-      sk: {
-        field: "GSI1SK",
-        casing: "none",
-        composite: ["gsi1sk"],
-        template: "${gsi1sk}"
-      }
     }
   }
 });
 
 // src/data/dynamo/entities/control/tenant-entity.ts
-var import_electrodb5 = require("electrodb");
-var TenantEntity = new import_electrodb5.Entity({
+var import_electrodb11 = require("electrodb");
+var TenantEntity = new import_electrodb11.Entity({
   model: {
     entity: "tenant",
     service: "control",
@@ -627,8 +1524,8 @@ var TenantEntity = new import_electrodb5.Entity({
 });
 
 // src/data/dynamo/entities/control/user-entity.ts
-var import_electrodb6 = require("electrodb");
-var UserEntity = new import_electrodb6.Entity({
+var import_electrodb12 = require("electrodb");
+var UserEntity = new import_electrodb12.Entity({
   model: {
     entity: "user",
     service: "control",
@@ -683,6 +1580,28 @@ var UserEntity = new import_electrodb6.Entity({
       type: "boolean",
       required: false
     },
+    /**
+     * TR-022 / ADR-018 lifecycle state for the cascade pipeline.
+     *
+     * - `active` (or undefined) — normal, readable state.
+     * - `deleting` — intermediate state set synchronously by the
+     *   hard-delete API entry point. The owning-delete cascade state
+     *   machine fans out from this transition (DynamoDB stream →
+     *   `control-plane.owning-delete.v1` → Step Functions). Readers MUST
+     *   short-circuit on `deleting` so partial cascades stay invisible.
+     * - `deleted-failed` — terminal failure state set by the cascade
+     *   finalize Lambda when the cascade run fails irrecoverably.
+     *   Operators recover by re-running the cascade or by direct
+     *   intervention.
+     *
+     * The cascade finalize step deletes the canonical record conditional
+     * on `lifecycleState = "deleting"`; on replay the conditional check
+     * fails and the finalize step treats that as a no-op success.
+     */
+    lifecycleState: {
+      type: ["active", "deleting", "deleted-failed"],
+      required: false
+    },
     bundleId: {
       type: "string",
       required: false
@@ -752,8 +1671,8 @@ var UserEntity = new import_electrodb6.Entity({
 });
 
 // src/data/dynamo/entities/control/workspace-entity.ts
-var import_electrodb7 = require("electrodb");
-var WorkspaceEntity = new import_electrodb7.Entity({
+var import_electrodb13 = require("electrodb");
+var WorkspaceEntity = new import_electrodb13.Entity({
   model: {
     entity: "workspace",
     service: "control",
@@ -805,6 +1724,28 @@ var WorkspaceEntity = new import_electrodb7.Entity({
       type: "boolean",
       required: false
     },
+    /**
+     * TR-022 / ADR-018 lifecycle state for the cascade pipeline.
+     *
+     * - `active` (or undefined) — normal, readable state.
+     * - `deleting` — intermediate state set synchronously by the
+     *   hard-delete API entry point. The owning-delete cascade state
+     *   machine fans out from this transition (DynamoDB stream →
+     *   `control-plane.owning-delete.v1` → Step Functions). Readers MUST
+     *   short-circuit on `deleting` so partial cascades stay invisible.
+     * - `deleted-failed` — terminal failure state set by the cascade
+     *   finalize Lambda when the cascade run fails irrecoverably.
+     *   Operators recover by re-running the cascade or by direct
+     *   intervention.
+     *
+     * The cascade finalize step deletes the canonical record conditional
+     * on `lifecycleState = "deleting"`; on replay the conditional check
+     * fails and the finalize step treats that as a no-op success.
+     */
+    lifecycleState: {
+      type: ["active", "deleting", "deleted-failed"],
+      required: false
+    },
     bundleId: {
       type: "string",
       required: false
@@ -855,33 +1796,127 @@ var WorkspaceEntity = new import_electrodb7.Entity({
 // src/data/dynamo/dynamo-control-service.ts
 var controlPlaneEntities = {
   configuration: ConfigurationEntity,
+  configurationUserProjection: ConfigurationUserProjectionEntity,
+  configurationWorkspaceProjection: ConfigurationWorkspaceProjectionEntity,
   membership: MembershipEntity,
+  membershipUserProjection: MembershipUserProjectionEntity,
+  membershipWorkspaceProjection: MembershipWorkspaceProjectionEntity,
   role: RoleEntity,
   roleAssignment: RoleAssignmentEntity,
+  roleAssignmentUserProjection: RoleAssignmentUserProjectionEntity,
+  roleAssignmentWorkspaceProjection: RoleAssignmentWorkspaceProjectionEntity,
   tenant: TenantEntity,
   user: UserEntity,
   workspace: WorkspaceEntity
 };
-var controlPlaneService = new import_electrodb8.Service(controlPlaneEntities, {
+var controlPlaneService = new import_electrodb14.Service(controlPlaneEntities, {
   table: defaultTableName,
   client: dynamoClient
 });
 var DynamoControlService = {
-  entities: controlPlaneService.entities
+  entities: controlPlaneService.entities,
+  transaction: controlPlaneService.transaction
 };
 function getDynamoControlService(tableName) {
   const resolved = tableName ?? defaultTableName;
-  const service = new import_electrodb8.Service(controlPlaneEntities, {
+  const service = new import_electrodb14.Service(controlPlaneEntities, {
     table: resolved,
     client: dynamoClient
   });
   return {
-    entities: service.entities
+    entities: service.entities,
+    transaction: service.transaction
   };
 }
 
 // src/data/operations/control/membership/membership-create-operation.ts
+var import_types4 = require("@openhi/types");
+
+// src/data/operations/control/membership/membership-user-projection.ts
 var import_types2 = require("@openhi/types");
+var MISSING_NAME_SENTINEL = "-";
+function buildMembershipUserProjectionSkTenantLane(params) {
+  const normalizedTenantName = typeof params.denormalizedTenantName === "string" && params.denormalizedTenantName.length > 0 ? (0, import_types2.normalizeLabel)(params.denormalizedTenantName) : MISSING_NAME_SENTINEL;
+  return `MEMBERSHIP#TENANT#${normalizedTenantName}#TID#${params.tenantId}#${params.membershipId}`;
+}
+function buildMembershipUserProjectionSkWorkspaceLane(params) {
+  const normalizedWorkspaceName = typeof params.denormalizedWorkspaceName === "string" && params.denormalizedWorkspaceName.length > 0 ? (0, import_types2.normalizeLabel)(params.denormalizedWorkspaceName) : MISSING_NAME_SENTINEL;
+  return `MEMBERSHIP#WORKSPACE#TID#${params.tenantId}#${normalizedWorkspaceName}#WID#${params.workspaceId}#${params.membershipId}`;
+}
+function buildMembershipUserProjectionItem(input) {
+  if (!input.userId || input.userId.length === 0) {
+    return void 0;
+  }
+  const hasWorkspace = typeof input.workspaceId === "string" && input.workspaceId.length > 0;
+  const sk = hasWorkspace ? buildMembershipUserProjectionSkWorkspaceLane({
+    tenantId: input.tenantId,
+    workspaceId: input.workspaceId,
+    membershipId: input.membershipId,
+    denormalizedWorkspaceName: input.denormalizedWorkspaceName
+  }) : buildMembershipUserProjectionSkTenantLane({
+    tenantId: input.tenantId,
+    membershipId: input.membershipId,
+    denormalizedTenantName: input.denormalizedTenantName
+  });
+  return {
+    userId: input.userId,
+    sk,
+    tenantId: input.tenantId,
+    workspaceId: hasWorkspace ? input.workspaceId : void 0,
+    membershipId: input.membershipId,
+    summary: input.summary,
+    vid: input.vid,
+    lastUpdated: input.lastUpdated,
+    denormalizedTenantName: input.denormalizedTenantName,
+    denormalizedUserName: input.denormalizedUserName,
+    denormalizedWorkspaceName: hasWorkspace ? input.denormalizedWorkspaceName : void 0
+  };
+}
+function extractReferenceSlug(resource, fieldName) {
+  const field = resource[fieldName];
+  if (!field || typeof field !== "object") {
+    return void 0;
+  }
+  const reference = field.reference;
+  if (typeof reference !== "string" || reference.length === 0) {
+    return void 0;
+  }
+  const slash = reference.lastIndexOf("/");
+  const tail = slash >= 0 ? reference.slice(slash + 1) : reference;
+  return tail.length > 0 ? tail : void 0;
+}
+
+// src/data/operations/control/membership/membership-workspace-projection.ts
+var import_types3 = require("@openhi/types");
+var MISSING_NAME_SENTINEL2 = "-";
+function buildMembershipWorkspaceProjectionSk(params) {
+  const normalizedUserName = typeof params.denormalizedUserName === "string" && params.denormalizedUserName.length > 0 ? (0, import_types3.normalizeLabel)(params.denormalizedUserName) : MISSING_NAME_SENTINEL2;
+  return `MEMBERSHIP#${normalizedUserName}#USER#${params.userId}#${params.membershipId}`;
+}
+function buildMembershipWorkspaceProjectionItem(input) {
+  if (!input.workspaceId || input.workspaceId.length === 0) {
+    return void 0;
+  }
+  if (!input.userId || input.userId.length === 0) {
+    return void 0;
+  }
+  const sk = buildMembershipWorkspaceProjectionSk({
+    userId: input.userId,
+    membershipId: input.membershipId,
+    denormalizedUserName: input.denormalizedUserName
+  });
+  return {
+    tenantId: input.tenantId,
+    workspaceId: input.workspaceId,
+    sk,
+    userId: input.userId,
+    membershipId: input.membershipId,
+    summary: input.summary,
+    vid: input.vid,
+    lastUpdated: input.lastUpdated,
+    denormalizedUserName: input.denormalizedUserName
+  };
+}
 
 // src/data/errors/domain-errors.ts
 var DomainError = class extends Error {
@@ -898,6 +1933,131 @@ var ValidationError = class extends DomainError {
     super(message, "VALIDATION", options);
   }
 };
+var ConflictError = class extends DomainError {
+  constructor(message, options) {
+    super(message, "CONFLICT", options);
+  }
+};
+
+// src/data/operations/control/denormalized-display-names.ts
+function extractDenormalizedReferenceDisplay(resource, fieldName) {
+  const field = resource[fieldName];
+  if (!field || typeof field !== "object") {
+    return void 0;
+  }
+  const display = field.display;
+  if (typeof display !== "string") {
+    return void 0;
+  }
+  const trimmed = display.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+
+// src/data/operations/control/multi-write-operation.ts
+var TRANSACT_WRITE_ITEM_LIMIT = 100;
+async function executeMultiWrite(params) {
+  const { service, triples, token } = params;
+  if (triples.length === 0) {
+    throw new ValidationError(
+      "executeMultiWrite called with zero triples; at least one triple is required"
+    );
+  }
+  if (triples.length > TRANSACT_WRITE_ITEM_LIMIT) {
+    throw new ValidationError(
+      `executeMultiWrite received ${triples.length} triples; DynamoDB TransactWriteItems is limited to ${TRANSACT_WRITE_ITEM_LIMIT} items per call`,
+      {
+        details: {
+          itemsRequested: triples.length,
+          limit: TRANSACT_WRITE_ITEM_LIMIT
+        }
+      }
+    );
+  }
+  for (const [index, triple] of triples.entries()) {
+    if (!triple || typeof triple !== "object") {
+      throw new ValidationError(
+        `executeMultiWrite triple at index ${index} is not an object`
+      );
+    }
+    if (typeof triple.entity !== "string" || triple.entity.length === 0) {
+      throw new ValidationError(
+        `executeMultiWrite triple at index ${index} is missing a non-empty 'entity' key`
+      );
+    }
+    if (!isSupportedAction(triple.action)) {
+      throw new ValidationError(
+        `executeMultiWrite triple at index ${index} has unsupported action '${String(
+          triple.action
+        )}'; supported: 'put' | 'create' | 'delete'`
+      );
+    }
+    if (!triple.item || typeof triple.item !== "object") {
+      throw new ValidationError(
+        `executeMultiWrite triple at index ${index} is missing an 'item' payload`
+      );
+    }
+  }
+  let result;
+  try {
+    result = await service.transaction.write(
+      (entities) => triples.map((triple, index) => {
+        const transactEntity = entities[triple.entity];
+        if (transactEntity === void 0) {
+          throw new ValidationError(
+            `executeMultiWrite triple at index ${index} references unknown entity '${triple.entity}'; ensure the service exposes it`
+          );
+        }
+        switch (triple.action) {
+          case "put":
+            return transactEntity.put(triple.item).commit();
+          case "create":
+            return transactEntity.create(triple.item).commit();
+          case "delete":
+            return transactEntity.delete(triple.item).commit();
+          default:
+            throw new ValidationError(
+              `executeMultiWrite triple at index ${index} has unsupported action '${String(
+                triple.action
+              )}'`
+            );
+        }
+      })
+    ).go(token === void 0 ? void 0 : { token });
+  } catch (err) {
+    if (err instanceof DomainError) {
+      throw err;
+    }
+    throw new ConflictError(buildCancellationMessage(err), {
+      cause: err,
+      details: extractCancellationReasons(err)
+    });
+  }
+  if (result.canceled) {
+    throw new ConflictError(
+      "TransactWriteItems was canceled by DynamoDB (check CancellationReasons on the cause for details)",
+      { details: { canceled: true, data: result.data } }
+    );
+  }
+  return { itemsWritten: triples.length, canceled: false };
+}
+function isSupportedAction(value) {
+  return value === "put" || value === "create" || value === "delete";
+}
+function buildCancellationMessage(err) {
+  if (err instanceof Error && err.message) {
+    return `TransactWriteItems failed: ${err.message}`;
+  }
+  return "TransactWriteItems failed (no error message available)";
+}
+function extractCancellationReasons(err) {
+  if (err && typeof err === "object") {
+    const cancellationReasons = err.CancellationReasons;
+    if (cancellationReasons !== void 0) {
+      return { CancellationReasons: cancellationReasons };
+    }
+  }
+  return void 0;
+}
 
 // src/data/operations/control/membership/membership-create-operation.ts
 async function createMembershipOperation(params) {
@@ -910,26 +2070,86 @@ async function createMembershipOperation(params) {
   const resource = { resourceType: "Membership", id, ...parsedResource };
   let linkedDataIdentityRef;
   try {
-    const ext = (0, import_types2.assertLinkedDataIdentityCardinality)(
+    const ext = (0, import_types4.assertLinkedDataIdentityCardinality)(
       resource
     );
     linkedDataIdentityRef = ext?.valueReference?.reference;
   } catch (e) {
-    if (e instanceof import_types2.LinkedDataIdentityCardinalityError) {
+    if (e instanceof import_types4.LinkedDataIdentityCardinalityError) {
       throw new ValidationError(e.message, { cause: e });
     }
     throw e;
   }
-  const summary = JSON.stringify((0, import_types2.extractSummary)(resource));
-  await service.entities.membership.put({
+  const resourceRecord = resource;
+  const denormalizedTenantName = extractDenormalizedReferenceDisplay(
+    resourceRecord,
+    "tenant"
+  );
+  const denormalizedUserName = extractDenormalizedReferenceDisplay(
+    resourceRecord,
+    "user"
+  );
+  const denormalizedWorkspaceName = extractDenormalizedReferenceDisplay(
+    resourceRecord,
+    "workspace"
+  );
+  const summary = JSON.stringify((0, import_types4.extractSummary)(resource));
+  const userIdFromResource = extractReferenceSlug(resourceRecord, "user");
+  const workspaceIdFromResource = extractReferenceSlug(
+    resourceRecord,
+    "workspace"
+  );
+  const userProjectionItem = userIdFromResource !== void 0 ? buildMembershipUserProjectionItem({
+    tenantId: context.tenantId,
+    userId: userIdFromResource,
+    workspaceId: workspaceIdFromResource,
+    membershipId: id,
+    summary,
+    vid,
+    lastUpdated,
+    denormalizedTenantName,
+    denormalizedUserName,
+    denormalizedWorkspaceName
+  }) : void 0;
+  const workspaceProjectionItem = userIdFromResource !== void 0 && workspaceIdFromResource !== void 0 ? buildMembershipWorkspaceProjectionItem({
+    tenantId: context.tenantId,
+    workspaceId: workspaceIdFromResource,
+    userId: userIdFromResource,
+    membershipId: id,
+    summary,
+    vid,
+    lastUpdated,
+    denormalizedUserName
+  }) : void 0;
+  const canonicalItem = {
     tenantId: context.tenantId,
     id,
     resource: JSON.stringify(resource),
     summary,
     vid,
     lastUpdated,
-    linkedDataIdentityRef
-  }).go();
+    linkedDataIdentityRef,
+    denormalizedTenantName,
+    denormalizedUserName
+  };
+  const triples = [
+    { entity: "membership", action: "put", item: canonicalItem }
+  ];
+  if (userProjectionItem) {
+    triples.push({
+      entity: "membershipUserProjection",
+      action: "put",
+      item: userProjectionItem
+    });
+  }
+  if (workspaceProjectionItem) {
+    triples.push({
+      entity: "membershipWorkspaceProjection",
+      action: "put",
+      item: workspaceProjectionItem
+    });
+  }
+  await executeMultiWrite({ service, triples });
   return {
     id,
     resource,
@@ -938,7 +2158,107 @@ async function createMembershipOperation(params) {
 }
 
 // src/data/operations/control/roleassignment/roleassignment-create-operation.ts
-var import_types3 = require("@openhi/types");
+var import_types7 = require("@openhi/types");
+
+// src/data/operations/control/roleassignment/roleassignment-user-projection.ts
+var import_types5 = require("@openhi/types");
+var MISSING_NAME_SENTINEL3 = "-";
+function buildRoleAssignmentUserProjectionSkTenantLane(params) {
+  const normalizedRoleName = typeof params.denormalizedRoleName === "string" && params.denormalizedRoleName.length > 0 ? (0, import_types5.normalizeLabel)(params.denormalizedRoleName) : MISSING_NAME_SENTINEL3;
+  return `ROLEASSIGNMENT#TENANT#${normalizedRoleName}#${params.roleId}#TID#${params.tenantId}#${params.roleAssignmentId}`;
+}
+function buildRoleAssignmentUserProjectionSkWorkspaceLane(params) {
+  const normalizedRoleName = typeof params.denormalizedRoleName === "string" && params.denormalizedRoleName.length > 0 ? (0, import_types5.normalizeLabel)(params.denormalizedRoleName) : MISSING_NAME_SENTINEL3;
+  return `ROLEASSIGNMENT#WORKSPACE#${normalizedRoleName}#${params.roleId}#TID#${params.tenantId}#WID#${params.workspaceId}#${params.roleAssignmentId}`;
+}
+function buildRoleAssignmentUserProjectionItem(input) {
+  if (!input.userId || input.userId.length === 0) {
+    return void 0;
+  }
+  if (!input.roleId || input.roleId.length === 0) {
+    return void 0;
+  }
+  const hasWorkspace = typeof input.workspaceId === "string" && input.workspaceId.length > 0;
+  const sk = hasWorkspace ? buildRoleAssignmentUserProjectionSkWorkspaceLane({
+    tenantId: input.tenantId,
+    workspaceId: input.workspaceId,
+    roleId: input.roleId,
+    roleAssignmentId: input.roleAssignmentId,
+    denormalizedRoleName: input.denormalizedRoleName
+  }) : buildRoleAssignmentUserProjectionSkTenantLane({
+    tenantId: input.tenantId,
+    roleId: input.roleId,
+    roleAssignmentId: input.roleAssignmentId,
+    denormalizedRoleName: input.denormalizedRoleName
+  });
+  return {
+    userId: input.userId,
+    sk,
+    tenantId: input.tenantId,
+    workspaceId: hasWorkspace ? input.workspaceId : void 0,
+    roleId: input.roleId,
+    roleAssignmentId: input.roleAssignmentId,
+    summary: input.summary,
+    vid: input.vid,
+    lastUpdated: input.lastUpdated,
+    denormalizedTenantName: input.denormalizedTenantName,
+    denormalizedUserName: input.denormalizedUserName,
+    denormalizedRoleName: input.denormalizedRoleName
+  };
+}
+function extractReferenceSlug2(resource, fieldName) {
+  const field = resource[fieldName];
+  if (!field || typeof field !== "object") {
+    return void 0;
+  }
+  const reference = field.reference;
+  if (typeof reference !== "string" || reference.length === 0) {
+    return void 0;
+  }
+  const slash = reference.lastIndexOf("/");
+  const tail = slash >= 0 ? reference.slice(slash + 1) : reference;
+  return tail.length > 0 ? tail : void 0;
+}
+
+// src/data/operations/control/roleassignment/roleassignment-workspace-projection.ts
+var import_types6 = require("@openhi/types");
+var MISSING_NAME_SENTINEL4 = "-";
+function buildRoleAssignmentWorkspaceProjectionSk(params) {
+  const normalizedUserName = typeof params.denormalizedUserName === "string" && params.denormalizedUserName.length > 0 ? (0, import_types6.normalizeLabel)(params.denormalizedUserName) : MISSING_NAME_SENTINEL4;
+  return `ROLEASSIGNMENT#${params.roleId}#${normalizedUserName}#USER#${params.userId}#${params.roleAssignmentId}`;
+}
+function buildRoleAssignmentWorkspaceProjectionItem(input) {
+  if (!input.workspaceId || input.workspaceId.length === 0) {
+    return void 0;
+  }
+  if (!input.userId || input.userId.length === 0) {
+    return void 0;
+  }
+  if (!input.roleId || input.roleId.length === 0) {
+    return void 0;
+  }
+  const sk = buildRoleAssignmentWorkspaceProjectionSk({
+    roleId: input.roleId,
+    userId: input.userId,
+    roleAssignmentId: input.roleAssignmentId,
+    denormalizedUserName: input.denormalizedUserName
+  });
+  return {
+    tenantId: input.tenantId,
+    workspaceId: input.workspaceId,
+    sk,
+    userId: input.userId,
+    roleId: input.roleId,
+    roleAssignmentId: input.roleAssignmentId,
+    summary: input.summary,
+    vid: input.vid,
+    lastUpdated: input.lastUpdated,
+    denormalizedUserName: input.denormalizedUserName,
+    denormalizedRoleName: input.denormalizedRoleName
+  };
+}
+
+// src/data/operations/control/roleassignment/roleassignment-create-operation.ts
 async function createRoleAssignmentOperation(params) {
   const { context, body, tableName } = params;
   const service = getDynamoControlService(tableName);
@@ -947,15 +2267,80 @@ async function createRoleAssignmentOperation(params) {
   const lastUpdated = context.date ?? (/* @__PURE__ */ new Date()).toISOString();
   const vid = `1`;
   const resource = { resourceType: "RoleAssignment", id, ...parsedResource };
-  const summary = JSON.stringify((0, import_types3.extractSummary)(resource));
-  await service.entities.roleAssignment.put({
+  const resourceRecord = resource;
+  const denormalizedTenantName = extractDenormalizedReferenceDisplay(
+    resourceRecord,
+    "tenant"
+  );
+  const denormalizedUserName = extractDenormalizedReferenceDisplay(
+    resourceRecord,
+    "user"
+  );
+  const denormalizedRoleName = extractDenormalizedReferenceDisplay(
+    resourceRecord,
+    "role"
+  );
+  const summary = JSON.stringify((0, import_types7.extractSummary)(resource));
+  const userIdFromResource = extractReferenceSlug2(resourceRecord, "user");
+  const roleIdFromResource = extractReferenceSlug2(resourceRecord, "role");
+  const workspaceIdFromResource = extractReferenceSlug2(
+    resourceRecord,
+    "workspace"
+  );
+  const userProjectionItem = userIdFromResource !== void 0 && roleIdFromResource !== void 0 ? buildRoleAssignmentUserProjectionItem({
+    tenantId: context.tenantId,
+    userId: userIdFromResource,
+    workspaceId: workspaceIdFromResource,
+    roleId: roleIdFromResource,
+    roleAssignmentId: id,
+    summary,
+    vid,
+    lastUpdated,
+    denormalizedTenantName,
+    denormalizedUserName,
+    denormalizedRoleName
+  }) : void 0;
+  const workspaceProjectionItem = userIdFromResource !== void 0 && roleIdFromResource !== void 0 && workspaceIdFromResource !== void 0 ? buildRoleAssignmentWorkspaceProjectionItem({
+    tenantId: context.tenantId,
+    workspaceId: workspaceIdFromResource,
+    userId: userIdFromResource,
+    roleId: roleIdFromResource,
+    roleAssignmentId: id,
+    summary,
+    vid,
+    lastUpdated,
+    denormalizedUserName,
+    denormalizedRoleName
+  }) : void 0;
+  const canonicalItem = {
     tenantId: context.tenantId,
     id,
     resource: JSON.stringify(resource),
     summary,
     vid,
-    lastUpdated
-  }).go();
+    lastUpdated,
+    denormalizedTenantName,
+    denormalizedUserName,
+    denormalizedRoleName
+  };
+  const triples = [
+    { entity: "roleAssignment", action: "put", item: canonicalItem }
+  ];
+  if (userProjectionItem) {
+    triples.push({
+      entity: "roleAssignmentUserProjection",
+      action: "put",
+      item: userProjectionItem
+    });
+  }
+  if (workspaceProjectionItem) {
+    triples.push({
+      entity: "roleAssignmentWorkspaceProjection",
+      action: "put",
+      item: workspaceProjectionItem
+    });
+  }
+  await executeMultiWrite({ service, triples });
   return {
     id,
     resource,
@@ -964,7 +2349,7 @@ async function createRoleAssignmentOperation(params) {
 }
 
 // src/data/operations/control/tenant/tenant-create-operation.ts
-var import_types4 = require("@openhi/types");
+var import_types8 = require("@openhi/types");
 async function createTenantOperation(params) {
   const { context, body, tableName } = params;
   const service = getDynamoControlService(tableName);
@@ -973,7 +2358,7 @@ async function createTenantOperation(params) {
   const vid = lastUpdated.replace(/[-:T.Z]/g, "").slice(0, 12) || Date.now().toString(36);
   const parsedResource = typeof body.resource === "string" ? JSON.parse(body.resource) : body.resource ?? {};
   const resource = { resourceType: "Tenant", id, ...parsedResource };
-  const summary = JSON.stringify((0, import_types4.extractSummary)(resource));
+  const summary = JSON.stringify((0, import_types8.extractSummary)(resource));
   await service.entities.tenant.put({
     tenantId: id,
     id,
@@ -986,7 +2371,7 @@ async function createTenantOperation(params) {
 }
 
 // src/data/operations/control/user/user-create-operation.ts
-var import_types5 = require("@openhi/types");
+var import_types9 = require("@openhi/types");
 
 // src/data/operations/control/user/user-find-by-sub-operation.ts
 async function findUserBySubOperation(params) {
@@ -1006,7 +2391,7 @@ async function findUserBySubOperation(params) {
 }
 
 // src/data/operations/data-operations-common.ts
-var import_types6 = require("@openhi/types");
+var import_types10 = require("@openhi/types");
 
 // src/lib/compression.ts
 var import_node_zlib = require("zlib");
@@ -1043,8 +2428,8 @@ async function createDataEntityRecord(entity, tenantId, workspaceId, id, resourc
   const lastUpdated = resourceWithAudit.meta?.lastUpdated ?? fallbackDate ?? (/* @__PURE__ */ new Date()).toISOString();
   const vid = lastUpdated.replace(/[-:T.Z]/g, "").slice(0, 12) || Date.now().toString(36);
   const resourceLike = resourceWithAudit;
-  const summary = JSON.stringify((0, import_types6.extractSummary)(resourceLike));
-  const gsi1sk = (0, import_types6.extractSortKey)(resourceLike);
+  const summary = JSON.stringify((0, import_types10.extractSummary)(resourceLike));
+  const gsi1sk = (0, import_types10.extractSortKey)(resourceLike);
   await entity.put({
     sk: DATA_ENTITY_SK,
     tenantId,
@@ -1063,7 +2448,7 @@ async function createDataEntityRecord(entity, tenantId, workspaceId, id, resourc
 }
 
 // src/data/operations/control/user/user-switch-tenant-workspace-operation.ts
-var import_types7 = require("@openhi/types");
+var import_types11 = require("@openhi/types");
 
 // src/data/operations/control/user/user-resource-helpers.ts
 function parseUserResource(resource) {
@@ -1084,16 +2469,16 @@ function idFromReference(reference, prefix) {
 }
 
 // src/data/operations/control/user/user-update-operation.ts
-var import_types8 = require("@openhi/types");
+var import_types12 = require("@openhi/types");
 
 // src/data/operations/control/workspace/workspace-create-operation.ts
-var import_types9 = require("@openhi/types");
+var import_types13 = require("@openhi/types");
 
 // src/data/dynamo/dynamo-data-service.ts
-var import_electrodb10 = require("electrodb");
+var import_electrodb16 = require("electrodb");
 
 // src/data/dynamo/entities/data-entity-common.ts
-var import_electrodb9 = require("electrodb");
+var import_electrodb15 = require("electrodb");
 var dataEntityAttributes = {
   /** Sort key. "CURRENT" for current version; version history in S3. */
   sk: {
@@ -1189,7 +2574,7 @@ var dataEntityAttributes = {
   }
 };
 function createDataEntity(entity, resourceTypeLabel) {
-  return new import_electrodb9.Entity({
+  return new import_electrodb15.Entity({
     model: {
       entity,
       service: "data",
@@ -2103,21 +3488,23 @@ var dataPlaneEntities = {
   visionprescription: VisionPrescriptionEntity,
   verificationresult: VerificationResultEntity
 };
-var dataPlaneService = new import_electrodb10.Service(dataPlaneEntities, {
+var dataPlaneService = new import_electrodb16.Service(dataPlaneEntities, {
   table: defaultTableName,
   client: dynamoClient
 });
 var DynamoDataService = {
-  entities: dataPlaneService.entities
+  entities: dataPlaneService.entities,
+  transaction: dataPlaneService.transaction
 };
 function getDynamoDataService(tableName) {
   const resolved = tableName ?? defaultTableName;
-  const service = new import_electrodb10.Service(dataPlaneEntities, {
+  const service = new import_electrodb16.Service(dataPlaneEntities, {
     table: resolved,
     client: dynamoClient
   });
   return {
-    entities: service.entities
+    entities: service.entities,
+    transaction: service.transaction
   };
 }
 
@@ -2169,7 +3556,7 @@ async function createWorkspaceOperation(params) {
   const vid = lastUpdated.replace(/[-:T.Z]/g, "").slice(0, 12) || Date.now().toString(36);
   const parsedResource = typeof body.resource === "string" ? JSON.parse(body.resource) : body.resource ?? {};
   const resource = { resourceType: "Workspace", id, ...parsedResource };
-  const summary = JSON.stringify((0, import_types9.extractSummary)(resource));
+  const summary = JSON.stringify((0, import_types13.extractSummary)(resource));
   await service.entities.workspace.put({
     tenantId,
     id,
@@ -2192,7 +3579,7 @@ async function createWorkspaceOperation(params) {
 var CURRENT_SK = "CURRENT";
 var VID = "1";
 var summaryFor = (resource) => {
-  return JSON.stringify((0, import_types10.extractSummary)(resource));
+  return JSON.stringify((0, import_types14.extractSummary)(resource));
 };
 var stableOnboardingId = (kind, cognitoSub) => {
   return (0, import_node_crypto.createHash)("sha256").update(kind).update("\0").update(cognitoSub).digest("hex").slice(0, 26).toUpperCase();