@opengeni/core 1.0.1 → 2.1.0-canary.0

package/src/domain/connection-authority.ts

@@ -0,0 +1,329 @@
+import type {
+  ConnectionKind,
+  ConnectionStatus,
+  SessionTenancyVisibility,
+  UserResourceDelegation,
+  UserResourceGrantMode,
+  UserResourceGrantStatus,
+} from "@opengeni/contracts";
+import {
+  ConnectionAuthorityEnvelope,
+  ConnectionUseAttribution,
+  ConnectionUseAuthoritySnapshot,
+  type ConnectionUseAuthorizationResult,
+  type ConnectionAuthoritySelectionSource,
+  type ConnectionUseDenialReason,
+  type ConnectionUseSelectionSource,
+} from "@opengeni/contracts/connection-authority";
+
+export type ConnectionAuthorityCandidate = {
+  id: string;
+  organizationId: string;
+  workspaceId: string;
+  generation: number;
+  status: ConnectionStatus;
+  providerDomain: string;
+  kind: ConnectionKind;
+  subjectId: string | null;
+  ownerOrganizationMembershipId: string | null;
+};
+
+export type UserConnectionAuthorityCandidate = {
+  id: string;
+  organizationId: string;
+  resourceKind: "connection";
+  resourceId: string;
+  originWorkspaceId: string;
+  ownerSubjectId: string;
+  ownerOrganizationMembershipId: string;
+  ownerMembershipAuthorizationRevision: number;
+  generation: number;
+  status: "active" | "retained" | "revoked";
+};
+
+export class ConnectionAuthorityInvariantError extends Error {
+  constructor(readonly code: string) {
+    super(`connection authority invariant failed: ${code}`);
+    this.name = "ConnectionAuthorityInvariantError";
+  }
+}
+
+export function captureConnectionUseAuthority(input: {
+  organizationId: string;
+  targetWorkspaceId: string;
+  targetSessionId: string;
+  targetSessionVisibility: SessionTenancyVisibility;
+  targetSessionAuthorityEpoch: number;
+  acceptedWork:
+    | { kind: "turn"; turnId: string }
+    | {
+        kind: "scheduled_task";
+        taskId: string;
+        taskAuthorityRevision: number;
+        runId: string;
+      };
+  connection: ConnectionAuthorityCandidate;
+  authority?: unknown;
+  authorityWasOmitted?: boolean;
+  userAuthority?: UserConnectionAuthorityCandidate | null;
+  selectionSources: ConnectionUseSelectionSource[];
+}): ConnectionUseAuthoritySnapshot {
+  const authority = ConnectionAuthorityEnvelope.parse(input.authority ?? {});
+  const connection = input.connection;
+  if (connection.organizationId !== input.organizationId) {
+    throw new ConnectionAuthorityInvariantError("tenant_mismatch");
+  }
+  if (connection.status !== "active") {
+    throw new ConnectionAuthorityInvariantError("connection_status_inactive");
+  }
+
+  let authoritySource: ConnectionAuthoritySelectionSource;
+  let userDelegation: UserResourceDelegation | null = null;
+  if (authority.scope === "workspace") {
+    if (connection.subjectId !== null || connection.ownerOrganizationMembershipId !== null) {
+      throw new ConnectionAuthorityInvariantError("workspace_borrowed_personal_connection");
+    }
+    if (connection.workspaceId !== input.targetWorkspaceId) {
+      throw new ConnectionAuthorityInvariantError("workspace_connection_scope_mismatch");
+    }
+    authoritySource = input.authorityWasOmitted
+      ? "legacy_workspace_omission"
+      : "explicit_workspace";
+  } else {
+    const delegation = authority.userDelegation;
+    const resourceAuthority = input.userAuthority;
+    if (!delegation || !resourceAuthority) {
+      throw new ConnectionAuthorityInvariantError("user_authority_missing");
+    }
+    if (!connection.subjectId || !connection.ownerOrganizationMembershipId) {
+      throw new ConnectionAuthorityInvariantError("personal_owner_missing");
+    }
+    if (
+      resourceAuthority.id !== delegation.authorityId ||
+      resourceAuthority.organizationId !== input.organizationId ||
+      resourceAuthority.resourceKind !== "connection" ||
+      resourceAuthority.resourceId !== connection.id ||
+      resourceAuthority.originWorkspaceId !== connection.workspaceId ||
+      resourceAuthority.ownerSubjectId !== connection.subjectId ||
+      resourceAuthority.ownerOrganizationMembershipId !==
+        connection.ownerOrganizationMembershipId ||
+      resourceAuthority.generation !== delegation.authorityGeneration ||
+      resourceAuthority.status !== "active"
+    ) {
+      throw new ConnectionAuthorityInvariantError("user_authority_mismatch");
+    }
+    userDelegation = delegation;
+    authoritySource = "user_delegation";
+  }
+
+  return ConnectionUseAuthoritySnapshot.parse({
+    organizationId: input.organizationId,
+    originWorkspaceId: connection.workspaceId,
+    targetWorkspaceId: input.targetWorkspaceId,
+    targetSessionId: input.targetSessionId,
+    targetSessionVisibility: input.targetSessionVisibility,
+    targetSessionAuthorityEpoch: input.targetSessionAuthorityEpoch,
+    acceptedWork: input.acceptedWork,
+    connectionId: connection.id,
+    connectionGeneration: connection.generation,
+    connectionStatus: "active",
+    providerDomain: connection.providerDomain.toLowerCase(),
+    connectionKind: connection.kind,
+    scope: authority.scope,
+    ownerSubjectId: connection.subjectId,
+    ownerOrganizationMembershipId: connection.ownerOrganizationMembershipId,
+    ownerMembershipAuthorizationRevision:
+      authority.scope === "user" ? input.userAuthority!.ownerMembershipAuthorizationRevision : null,
+    authoritySource,
+    selectionSources: input.selectionSources,
+    userDelegation,
+  });
+}
+
+export type LiveConnectionUseState = {
+  organizationId: string;
+  targetWorkspaceId: string;
+  targetWorkspaceAccessActive: boolean;
+  session: {
+    id: string;
+    organizationId: string;
+    workspaceId: string;
+    visibility: SessionTenancyVisibility;
+    authorityEpoch: number;
+    active: boolean;
+  };
+  connection: ConnectionAuthorityCandidate | null;
+  ownerMembership: {
+    id: string;
+    organizationId: string;
+    subjectId: string;
+    status: "provisioning" | "active" | "suspended" | "revoked";
+    authorizationRevision: number;
+  } | null;
+  userAuthority: UserConnectionAuthorityCandidate | null;
+  grant: {
+    id: string;
+    authorityId: string;
+    organizationId: string;
+    workspaceId: string;
+    sessionId: string | null;
+    action: string;
+    mode: UserResourceGrantMode;
+    context: SessionTenancyVisibility;
+    authorityEpoch: number | null;
+    generation: number;
+    status: UserResourceGrantStatus;
+    expiresAt: string | null;
+    consumed: boolean;
+  } | null;
+};
+
+function denied(reason: ConnectionUseDenialReason): ConnectionUseAuthorizationResult {
+  return { status: "denied", reason };
+}
+
+/**
+ * Revalidates every mutable fence immediately before provider use. Callers must
+ * resolve the live state in one DB authority boundary; this pure function does
+ * not cache, refresh, decrypt, or invoke a provider.
+ */
+export function revalidateConnectionUseAuthority(input: {
+  snapshot: ConnectionUseAuthoritySnapshot;
+  live: LiveConnectionUseState;
+  now?: Date;
+}): ConnectionUseAuthorizationResult {
+  const snapshot = ConnectionUseAuthoritySnapshot.parse(input.snapshot);
+  const live = input.live;
+  const now = input.now ?? new Date();
+  if (
+    live.organizationId !== snapshot.organizationId ||
+    live.targetWorkspaceId !== snapshot.targetWorkspaceId
+  ) {
+    return denied("tenant_mismatch");
+  }
+  if (!live.targetWorkspaceAccessActive) return denied("workspace_access_inactive");
+  if (!live.session.active) return denied("session_inactive");
+  if (
+    live.session.id !== snapshot.targetSessionId ||
+    live.session.organizationId !== snapshot.organizationId ||
+    live.session.workspaceId !== snapshot.targetWorkspaceId
+  ) {
+    return denied("session_identity_changed");
+  }
+  if (live.session.visibility !== snapshot.targetSessionVisibility) {
+    return denied("session_visibility_changed");
+  }
+  if (live.session.authorityEpoch !== snapshot.targetSessionAuthorityEpoch) {
+    return denied("session_authority_epoch_changed");
+  }
+  const connection = live.connection;
+  if (!connection) return denied("connection_missing");
+  if (
+    connection.id !== snapshot.connectionId ||
+    connection.organizationId !== snapshot.organizationId ||
+    connection.workspaceId !== snapshot.originWorkspaceId ||
+    connection.providerDomain.toLowerCase() !== snapshot.providerDomain ||
+    connection.kind !== snapshot.connectionKind
+  ) {
+    return denied("connection_identity_changed");
+  }
+  if (connection.generation !== snapshot.connectionGeneration) {
+    return denied("connection_generation_changed");
+  }
+  if (connection.status !== "active") return denied("connection_status_inactive");
+  if (
+    connection.subjectId !== snapshot.ownerSubjectId ||
+    connection.ownerOrganizationMembershipId !== snapshot.ownerOrganizationMembershipId
+  ) {
+    return denied("connection_owner_changed");
+  }
+
+  if (snapshot.scope === "workspace") {
+    if (connection.subjectId !== null || connection.workspaceId !== snapshot.targetWorkspaceId) {
+      return denied("connection_owner_changed");
+    }
+    return {
+      status: "authorized",
+      attribution: ConnectionUseAttribution.parse({
+        organizationId: snapshot.organizationId,
+        workspaceId: snapshot.targetWorkspaceId,
+        sessionId: snapshot.targetSessionId,
+        connectionId: snapshot.connectionId,
+        connectionGeneration: snapshot.connectionGeneration,
+        scope: "workspace",
+        ownerSubjectId: null,
+        authorityId: null,
+        grantId: null,
+      }),
+    };
+  }
+
+  const delegation = snapshot.userDelegation!;
+  const membership = live.ownerMembership;
+  if (
+    !membership ||
+    membership.status !== "active" ||
+    membership.id !== snapshot.ownerOrganizationMembershipId ||
+    membership.organizationId !== snapshot.organizationId ||
+    membership.subjectId !== snapshot.ownerSubjectId ||
+    membership.authorizationRevision !== snapshot.ownerMembershipAuthorizationRevision
+  ) {
+    return denied("owner_membership_inactive");
+  }
+  const authority = live.userAuthority;
+  if (!authority) return denied("authority_missing");
+  if (
+    authority.id !== delegation.authorityId ||
+    authority.organizationId !== snapshot.organizationId ||
+    authority.resourceKind !== "connection" ||
+    authority.resourceId !== snapshot.connectionId ||
+    authority.originWorkspaceId !== snapshot.originWorkspaceId ||
+    authority.ownerSubjectId !== snapshot.ownerSubjectId ||
+    authority.ownerOrganizationMembershipId !== snapshot.ownerOrganizationMembershipId
+  ) {
+    return denied("authority_identity_changed");
+  }
+  if (authority.generation !== delegation.authorityGeneration) {
+    return denied("authority_generation_changed");
+  }
+  if (authority.status !== "active") return denied("authority_status_inactive");
+
+  const grant = live.grant;
+  if (!grant) return denied("grant_missing");
+  if (
+    grant.id !== delegation.grantId ||
+    grant.authorityId !== delegation.authorityId ||
+    grant.organizationId !== snapshot.organizationId ||
+    grant.workspaceId !== snapshot.targetWorkspaceId ||
+    grant.sessionId !== delegation.sessionId ||
+    grant.action !== "connection.use" ||
+    grant.mode !== delegation.mode ||
+    grant.context !== snapshot.targetSessionVisibility ||
+    grant.authorityEpoch !== delegation.authorityEpoch
+  ) {
+    return denied("grant_identity_changed");
+  }
+  if (grant.generation !== delegation.grantGeneration) {
+    return denied("grant_generation_changed");
+  }
+  if (grant.status !== "active") return denied("grant_status_inactive");
+  if (grant.expiresAt !== null && Date.parse(grant.expiresAt) <= now.getTime()) {
+    return denied("grant_expired");
+  }
+  if (grant.mode === "once" && grant.consumed) return denied("grant_already_consumed");
+
+  return {
+    status: "authorized",
+    attribution: ConnectionUseAttribution.parse({
+      organizationId: snapshot.organizationId,
+      workspaceId: snapshot.targetWorkspaceId,
+      sessionId: snapshot.targetSessionId,
+      connectionId: snapshot.connectionId,
+      connectionGeneration: snapshot.connectionGeneration,
+      scope: "user",
+      ownerSubjectId: snapshot.ownerSubjectId,
+      authorityId: delegation.authorityId,
+      grantId: delegation.grantId,
+    }),
+  };
+}

package/src/domain/editable-artifacts/agent-application.ts

@@ -1,14 +1,12 @@
 import { createHash } from "node:crypto";
 
-import {
-  COMMITTED_TRANSACTION_PROTOCOL_VERSION,
-  EDITABLE_ARTIFACT_MODEL_SCHEMA_VERSION,
-} from "@opengeni/contracts/editable-artifact-versions";
 import {
   DOCUMENT_ARTIFACT_COMMAND_VERSION,
+  EDITABLE_ARTIFACT_INTENT_PROTOCOL_VERSION,
   EDITABLE_ARTIFACT_INTENT_VERSION,
   PRESENTATION_ARTIFACT_COMMAND_VERSION,
   SPREADSHEET_ARTIFACT_COMMAND_VERSION,
+  currentEditableArtifactCompatibility,
   decodeEditableArtifactMutationIntent,
   decodeDocumentArtifactQueryResponse,
   decodePresentationArtifactQueryResponse,
@@ -364,8 +362,9 @@ export class EditableArtifactAgentApplication {
     }
     const authored = hashEditableArtifactMutationIntent({
       envelopeVersion: EDITABLE_ARTIFACT_INTENT_VERSION,
-      protocolVersion: COMMITTED_TRANSACTION_PROTOCOL_VERSION,
-      modelSchemaVersion: EDITABLE_ARTIFACT_MODEL_SCHEMA_VERSION,
+      protocolVersion: EDITABLE_ARTIFACT_INTENT_PROTOCOL_VERSION,
+      modelSchemaVersion: currentEditableArtifactCompatibility(input.batch.modality)
+        .modelSchemaVersion,
       commandProtocolVersion: commandProtocolVersion(input.batch.modality),
       artifactId,
       clientTransactionId,
@@ -564,12 +563,21 @@ function agentContext(input: EditableArtifactAgentContext): EditableArtifactAgen
 
 function encodeCommands(batch: EditableArtifactAgentCommandBatch): Uint8Array {
   if (batch.modality === "spreadsheet") {
-    return encodeSpreadsheetArtifactCommandBatch({ version: 1, commands: batch.commands });
+    return encodeSpreadsheetArtifactCommandBatch({
+      version: SPREADSHEET_ARTIFACT_COMMAND_VERSION,
+      commands: batch.commands,
+    });
   }
   if (batch.modality === "document") {
-    return encodeDocumentArtifactCommandBatch({ version: 1, commands: batch.commands });
+    return encodeDocumentArtifactCommandBatch({
+      version: DOCUMENT_ARTIFACT_COMMAND_VERSION,
+      commands: batch.commands,
+    });
   }
-  return encodePresentationArtifactCommandBatch({ version: 1, commands: batch.commands });
+  return encodePresentationArtifactCommandBatch({
+    version: PRESENTATION_ARTIFACT_COMMAND_VERSION,
+    commands: batch.commands,
+  });
 }
 
 function encodeQuery(request: EditableArtifactAgentQuery): Uint8Array {

package/src/domain/editable-artifacts/service.ts

@@ -28,9 +28,11 @@ import { hashEditableArtifactCreateRequest, hashEditableArtifactImportRequest }
 import {
   EDITABLE_ARTIFACT_COMMAND_MAX_BYTES,
   EDITABLE_ARTIFACT_INTENT_MAX_BYTES,
+  EDITABLE_ARTIFACT_INTENT_PROTOCOL_VERSION,
   EDITABLE_ARTIFACT_INTENT_MAX_UNDO_TARGETS,
   EDITABLE_ARTIFACT_INTENT_VERSION,
   EDITABLE_ARTIFACT_KERNEL_VERSION_MAX_BYTES,
+  EDITABLE_ARTIFACT_CODEC_REGISTRY,
 } from "@opengeni/contracts/editable-artifacts";
 import {
   COMMITTED_TRANSACTION_PROTOCOL_VERSION,
@@ -111,7 +113,6 @@ export const EDITABLE_ARTIFACT_MAX_COMMAND_BYTES_PER_TRANSACTION =
   EDITABLE_ARTIFACT_COMMAND_MAX_BYTES;
 export const EDITABLE_ARTIFACT_MAX_INTENT_BYTES_PER_TRANSACTION =
   EDITABLE_ARTIFACT_INTENT_MAX_BYTES;
-export const EDITABLE_ARTIFACT_INTENT_PROTOCOL_VERSION = 1;
 export const EDITABLE_ARTIFACT_MAX_OPERATION_BYTES_PER_TRANSACTION =
   MAX_COMMITTED_TRANSACTION_BYTES;
 /** Canonical OGACO envelope bound. Kept as an alias for existing consumers. */
@@ -2266,6 +2267,10 @@ function validateSnapshotRequest(
   assertNonnegativeSafeInteger(rawCoveredHeadSequence, "snapshot covered head sequence");
   const stateHash = editableArtifactStateHash(rawStateHash);
   assertPositiveSafeInteger(rawModelSchemaVersion, "snapshot model schema version");
+  const currentCodec = EDITABLE_ARTIFACT_CODEC_REGISTRY[rawModality];
+  if (rawModelSchemaVersion !== currentCodec.modelSchemaVersion) {
+    throw new TypeError("Snapshot model schema version is unsupported");
+  }
   assertBoundedKernelVersion(rawKernelVersion);
   assertIsoTimestamp(rawVerifiedAt, "snapshot verified timestamp");
   const common = {
@@ -2294,6 +2299,12 @@ function validateSnapshotRequest(
     }
     assertPositiveSafeInteger(rawOperationProtocolVersion, "snapshot operation protocol version");
     assertPositiveSafeInteger(rawCrdtStateVersion, "snapshot CRDT state version");
+    if (
+      rawOperationProtocolVersion !== COMMITTED_TRANSACTION_PROTOCOL_VERSION ||
+      rawCrdtStateVersion !== currentCodec.snapshotVersion
+    ) {
+      throw new TypeError("Spreadsheet snapshot version is unsupported");
+    }
     return Object.freeze({
       ...common,
       modality: "spreadsheet",

package/src/domain/editable-artifacts/snapshot-compaction.ts

@@ -1,4 +1,6 @@
 import { type BoundedImmutableObjectWritePort, BoundedObjectWriteError } from "@opengeni/storage";
+import { EDITABLE_ARTIFACT_CODEC_REGISTRY } from "@opengeni/contracts/editable-artifacts";
+import { COMMITTED_TRANSACTION_PROTOCOL_VERSION } from "@opengeni/contracts/editable-artifact-committed-transaction";
 
 import type { EditableArtifactCompactionPort, EditableArtifactKernelState } from "./ports";
 import {
@@ -177,6 +179,7 @@ function validateGenerated(
   scope: EditableArtifactScope,
   artifactId: EditableArtifactId,
 ): void {
+  const currentCodec = EDITABLE_ARTIFACT_CODEC_REGISTRY[value.modality];
   if (
     value.scope.accountId !== scope.accountId ||
     value.scope.workspaceId !== scope.workspaceId ||
@@ -207,11 +210,12 @@ function validateGenerated(
     throw new EditableArtifactSnapshotVerificationError("limit_exceeded");
   }
   editableArtifactContentHash(value.canonicalContentHash);
-  const versions =
-    value.modality === "spreadsheet"
-      ? [value.modelSchemaVersion, value.operationProtocolVersion, value.crdtStateVersion]
-      : [value.modelSchemaVersion];
-  if (versions.some((version) => !Number.isSafeInteger(version) || version <= 0)) {
+  if (
+    value.modelSchemaVersion !== currentCodec.modelSchemaVersion ||
+    (value.modality === "spreadsheet" &&
+      (value.operationProtocolVersion !== COMMITTED_TRANSACTION_PROTOCOL_VERSION ||
+        value.crdtStateVersion !== currentCodec.snapshotVersion))
+  ) {
     throw new EditableArtifactSnapshotVerificationError("version_mismatch");
   }
   try {

package/src/domain/editable-artifacts/snapshot-verifier-genesis.ts

@@ -1,4 +1,6 @@
 import { type BoundedImmutableObjectWritePort, BoundedObjectWriteError } from "@opengeni/storage";
+import { EDITABLE_ARTIFACT_CODEC_REGISTRY } from "@opengeni/contracts/editable-artifacts";
+import { COMMITTED_TRANSACTION_PROTOCOL_VERSION } from "@opengeni/contracts/editable-artifact-committed-transaction";
 import type { EditableArtifactGenesisPort } from "./ports";
 import {
   MAX_EDITABLE_ARTIFACT_SNAPSHOT_BYTES,
@@ -173,6 +175,7 @@ function validateGeneratedGenesis(
   artifactId: EditableArtifactId,
   modality: EditableArtifactModality,
 ): void {
+  const currentCodec = EDITABLE_ARTIFACT_CODEC_REGISTRY[value.modality];
   if (
     value.scope.accountId !== scope.accountId ||
     value.scope.workspaceId !== scope.workspaceId ||
@@ -198,14 +201,13 @@ function validateGeneratedGenesis(
   }
   editableArtifactContentHash(value.canonicalContentHash);
   editableArtifactStateHash(value.stateHash);
-  const versions =
-    value.modality === "spreadsheet"
-      ? [value.modelSchemaVersion, value.operationProtocolVersion, value.crdtStateVersion]
-      : [value.modelSchemaVersion];
-  for (const version of versions) {
-    if (!Number.isSafeInteger(version) || version <= 0) {
-      throw new EditableArtifactSnapshotVerificationError("version_mismatch");
-    }
+  if (
+    value.modelSchemaVersion !== currentCodec.modelSchemaVersion ||
+    (value.modality === "spreadsheet" &&
+      (value.operationProtocolVersion !== COMMITTED_TRANSACTION_PROTOCOL_VERSION ||
+        value.crdtStateVersion !== currentCodec.snapshotVersion))
+  ) {
+    throw new EditableArtifactSnapshotVerificationError("version_mismatch");
   }
   try {
     assertBoundedKernelVersion(value.kernelVersion);

package/src/domain/editable-artifacts/snapshot-verifier.ts

@@ -7,7 +7,11 @@ import {
 } from "@opengeni/storage";
 import type { EditableArtifactSnapshotVerifierPort } from "./ports";
 import { decodeEditableArtifactSerializedCommit } from "@opengeni/contracts/editable-artifact-serialized-commit";
-import { EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES } from "@opengeni/contracts/editable-artifacts";
+import {
+  EDITABLE_ARTIFACT_CODEC_REGISTRY,
+  EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES,
+} from "@opengeni/contracts/editable-artifacts";
+import { COMMITTED_TRANSACTION_PROTOCOL_VERSION } from "@opengeni/contracts/editable-artifact-committed-transaction";
 import {
   causalFrontiersEqual,
   editableArtifactCausalFrontier,
@@ -520,6 +524,7 @@ function validateKernelResult(
       >
     | undefined,
 ): void {
+  const currentCodec = EDITABLE_ARTIFACT_CODEC_REGISTRY[snapshot.modality];
   if (
     result.canonicalReencodeVerified !== true ||
     result.modality !== snapshot.modality ||
@@ -542,8 +547,8 @@ function validateKernelResult(
     throw new EditableArtifactSnapshotVerificationError("state_hash_mismatch");
   }
   if (
-    result.modelSchemaVersion !== snapshot.modelSchemaVersion ||
-    result.kernelVersion !== snapshot.kernelVersion
+    snapshot.modelSchemaVersion !== currentCodec.modelSchemaVersion ||
+    result.modelSchemaVersion !== snapshot.modelSchemaVersion
   ) {
     throw new EditableArtifactSnapshotVerificationError("version_mismatch");
   }
@@ -559,6 +564,8 @@ function validateKernelResult(
       throw new EditableArtifactSnapshotVerificationError("frontier_mismatch");
     }
     if (
+      snapshot.operationProtocolVersion !== COMMITTED_TRANSACTION_PROTOCOL_VERSION ||
+      snapshot.crdtStateVersion !== currentCodec.snapshotVersion ||
       result.operationProtocolVersion !== snapshot.operationProtocolVersion ||
       result.crdtStateVersion !== snapshot.crdtStateVersion
     ) {

package/src/domain/environments.ts

@@ -69,10 +69,18 @@ export const requireEnvironmentEncryption = requireVariableSetEncryption;
 
 export async function requireVariableSetForApi(
   db: Database,
-  workspaceId: string,
+  grant: AccessGrant,
   variableSetId: string,
 ): Promise<VariableSet> {
-  const variableSet = await getVariableSet(db, workspaceId, variableSetId);
+  const variableSet = await getVariableSet(
+    db,
+    {
+      accountId: grant.accountId,
+      workspaceId: grant.workspaceId,
+      subjectId: grant.subjectId,
+    },
+    variableSetId,
+  );
   if (!variableSet) {
     throw new HTTPException(404, { message: "variableSet not found" });
   }
@@ -97,9 +105,14 @@ export async function validateVariableSetAttachment(
 ): Promise<VariableSet> {
   requireVariableSetEncryption(deps.settings);
   if (!options.preauthorized) {
+    requirePermission(grant, "variable-sets:attach");
     requirePermission(grant, "variable-sets:use");
   }
-  const variableSet = await getVariableSet(deps.db, workspaceId, variableSetId);
+  const variableSet = await getVariableSet(
+    deps.db,
+    { accountId: grant.accountId, workspaceId, subjectId: grant.subjectId },
+    variableSetId,
+  );
   if (!variableSet) {
     throw new HTTPException(422, { message: "unknown variableSetId" });
   }