@opengeni/db 0.28.1 → 0.28.9

package/src/lossless-columns.ts

@@ -0,0 +1,35 @@
+import { customType, integer } from "drizzle-orm/pg-core";
+import { toPostgresLosslessJson, toPostgresLosslessText } from "./lossless-json";
+
+/**
+ * Codec truth is explicit and out-of-band. This column intentionally has no
+ * database or application default: a caller may set version 1 only in the same
+ * statement that writes the corresponding value through the lossless codec.
+ */
+export function losslessCodecVersion<TName extends string>(name: TName) {
+  return integer(name);
+}
+
+export const losslessJsonb = customType<{ data: unknown; driverData: string }>({
+  dataType() {
+    return "jsonb";
+  },
+  toDriver(value) {
+    return JSON.stringify(toPostgresLosslessJson(value));
+  },
+  fromDriver(value) {
+    return typeof value === "string" ? JSON.parse(value) : value;
+  },
+});
+
+export const losslessText = customType<{ data: string; driverData: string }>({
+  dataType() {
+    return "text";
+  },
+  toDriver(value) {
+    return toPostgresLosslessText(value);
+  },
+  fromDriver(value) {
+    return value;
+  },
+});

package/src/lossless-json.ts

@@ -0,0 +1,322 @@
+const JSON_STRING_PREFIX = "opengeni_lossless_json_string_v2_81f06e15:";
+const JSON_KEY_PREFIX = "opengeni_lossless_json_key_v2_7ca6071d:";
+const TEXT_PREFIX = "opengeni_lossless_text_v2_c4100a62:";
+const MAX_JSON_DEPTH = 512;
+
+/**
+ * Explicit out-of-band truth for values written by the lossless PostgreSQL
+ * compatibility codec. Historical rows have NULL in their companion version
+ * column and must never be decoded based on content shape alone.
+ */
+export const LOSSLESS_CONTENT_CODEC_VERSION = 1 as const;
+export const LOSSLESS_CONTENT_WRITER_APPLICATION_NAME = "opengeni-lossless-v1";
+
+export function withLosslessContentWriteVersion<
+  const ContentKey extends string,
+  const VersionKey extends string,
+  const Value extends object,
+>(
+  value: Value & Record<ContentKey, unknown>,
+  contentKey: ContentKey,
+  versionKey: VersionKey,
+): Value & Record<VersionKey, typeof LOSSLESS_CONTENT_CODEC_VERSION>;
+export function withLosslessContentWriteVersion<
+  const ContentKey extends string,
+  const VersionKey extends string,
+  const Value extends object,
+>(
+  value: readonly (Value & Record<ContentKey, unknown>)[],
+  contentKey: ContentKey,
+  versionKey: VersionKey,
+): Array<Value & Record<VersionKey, typeof LOSSLESS_CONTENT_CODEC_VERSION>>;
+export function withLosslessContentWriteVersion(
+  value: Record<string, unknown> | readonly Record<string, unknown>[],
+  contentKey: string,
+  versionKey: string,
+): Record<string, unknown> | Record<string, unknown>[] {
+  const stamp = (entry: Record<string, unknown>) => {
+    if (!Object.hasOwn(entry, contentKey)) {
+      throw new Error(`Lossless content write omitted ${contentKey}`);
+    }
+    return { ...entry, [versionKey]: LOSSLESS_CONTENT_CODEC_VERSION };
+  };
+  return Array.isArray(value) ? value.map(stamp) : stamp(value as Record<string, unknown>);
+}
+
+export const LEGACY_LOSSLESS_JSON_ENVELOPE_KEY =
+  "$opengeniCanonicalV8_6d9b6f48_2a3e_4d8a_9e33_7611d9d08985";
+export const LEGACY_LOSSLESS_TEXT_PREFIX = "opengeni-canonical-text-v1:";
+export const LOSSLESS_JSON_STRING_PREFIX = JSON_STRING_PREFIX;
+export const LOSSLESS_TEXT_PREFIX = TEXT_PREFIX;
+
+export class UnsupportedCanonicalValueError extends TypeError {
+  override readonly name = "UnsupportedCanonicalValueError";
+}
+
+type TransformResult = { value: unknown; changed: boolean };
+
+/**
+ * Preserve JSON structure and SQL-queryable control keys. Only strings that
+ * PostgreSQL cannot represent (or that collide with this unshipped v2 tag) are
+ * encoded. Non-JSON graph values are rejected instead of silently rewritten.
+ */
+export function toPostgresLosslessJson(value: unknown): unknown {
+  return encodeJsonValue(value, new Set<object>(), 0).value;
+}
+
+/**
+ * Restore an explicitly versioned JSON value after a PostgreSQL read. A NULL
+ * version denotes literal legacy/old-writer data, including strings that happen
+ * to be valid active-marker encodings.
+ */
+export function fromPostgresLosslessJson<T>(value: T, codecVersion: number | null | undefined): T {
+  return codecVersion === LOSSLESS_CONTENT_CODEC_VERSION
+    ? (decodeJsonValue(value, 0).value as T)
+    : value;
+}
+
+/**
+ * Lossless text-column boundary for NUL, lone UTF-16, and v2-prefix text.
+ * Only the unrepresentable code unit is tagged, with SQL-visible spaces around
+ * the tag, so ordinary surrounding words retain their full-text-search shape.
+ */
+export function toPostgresLosslessText(value: string): string {
+  if (isPostgresSafeString(value) && !value.includes(TEXT_PREFIX)) return value;
+  let stored = "";
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (value.startsWith(TEXT_PREFIX, index)) {
+      stored += encodeTextCodeUnit(code);
+      continue;
+    }
+    if (code === 0 || (code >= 0xdc00 && code <= 0xdfff)) {
+      stored += encodeTextCodeUnit(code);
+      continue;
+    }
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = index + 1 < value.length ? value.charCodeAt(index + 1) : 0;
+      if (next < 0xdc00 || next > 0xdfff) {
+        stored += encodeTextCodeUnit(code);
+        continue;
+      }
+      stored += value.slice(index, index + 2);
+      index += 1;
+      continue;
+    }
+    stored += value[index];
+  }
+  return stored;
+}
+
+/**
+ * Decode only an explicitly versioned value introduced by this migration. The
+ * nullable companion column, not the producer string, is the codec truth.
+ */
+export function fromPostgresLosslessText(
+  value: string,
+  codecVersion: number | null | undefined,
+): string {
+  return codecVersion === LOSSLESS_CONTENT_CODEC_VERSION
+    ? value.replaceAll(
+        new RegExp(` ${TEXT_PREFIX}([0-9a-f]{4}); `, "g"),
+        (_match, encoded: string) => String.fromCharCode(Number.parseInt(encoded, 16)),
+      )
+    : value;
+}
+
+function encodeTextCodeUnit(code: number): string {
+  return ` ${TEXT_PREFIX}${code.toString(16).padStart(4, "0")}; `;
+}
+
+function encodeJsonValue(value: unknown, ancestors: Set<object>, depth: number): TransformResult {
+  if (depth > MAX_JSON_DEPTH) {
+    throw new UnsupportedCanonicalValueError(
+      `Canonical JSON exceeds the maximum supported depth of ${MAX_JSON_DEPTH}`,
+    );
+  }
+  if (value === null || typeof value === "boolean") return { value, changed: false };
+  if (typeof value === "string") {
+    if (isPostgresSafeString(value) && !value.startsWith(JSON_STRING_PREFIX)) {
+      return { value, changed: false };
+    }
+    return { value: `${JSON_STRING_PREFIX}${encodeUtf16(value)}`, changed: true };
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || Object.is(value, -0)) {
+      throw new UnsupportedCanonicalValueError(
+        "Canonical JSON requires finite non-negative-zero numbers",
+      );
+    }
+    return { value, changed: false };
+  }
+  if (
+    typeof value === "undefined" ||
+    typeof value === "bigint" ||
+    typeof value === "function" ||
+    typeof value === "symbol"
+  ) {
+    throw new UnsupportedCanonicalValueError(`Canonical JSON cannot contain ${typeof value}`);
+  }
+  if (!isPlainObject(value) && !Array.isArray(value)) {
+    throw new UnsupportedCanonicalValueError("Canonical JSON requires arrays and plain objects");
+  }
+  if (ancestors.has(value)) {
+    throw new UnsupportedCanonicalValueError("Canonical JSON cannot contain cyclic references");
+  }
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw new UnsupportedCanonicalValueError("Canonical JSON cannot contain symbol keys");
+  }
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      const descriptors = Object.getOwnPropertyDescriptors(value);
+      const propertyNames = Object.getOwnPropertyNames(descriptors);
+      const indexNames = propertyNames.filter((name) => name !== "length");
+      if (
+        indexNames.length !== value.length ||
+        indexNames.some((name) => {
+          const index = Number(name);
+          return (
+            !Number.isInteger(index) || index < 0 || index >= value.length || String(index) !== name
+          );
+        })
+      ) {
+        throw new UnsupportedCanonicalValueError(
+          "Canonical JSON arrays cannot contain non-index properties or holes",
+        );
+      }
+      const output: unknown[] = [];
+      let changed = false;
+      for (let index = 0; index < value.length; index += 1) {
+        const descriptor = descriptors[String(index)];
+        if (!descriptor || !descriptor.enumerable || !("value" in descriptor)) {
+          throw new UnsupportedCanonicalValueError(
+            "Canonical JSON arrays cannot contain holes, accessors, or hidden elements",
+          );
+        }
+        const encoded = encodeJsonValue(descriptor.value, ancestors, depth + 1);
+        output.push(encoded.value);
+        changed ||= encoded.changed;
+      }
+      return changed ? { value: output, changed: true } : { value, changed: false };
+    }
+
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const output: Record<string, unknown> = {};
+    let changed = false;
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      if (!descriptor.enumerable || !("value" in descriptor)) {
+        throw new UnsupportedCanonicalValueError(
+          "Canonical JSON objects cannot contain accessors or hidden properties",
+        );
+      }
+      const encodedKey =
+        isPostgresSafeString(key) && !key.startsWith(JSON_KEY_PREFIX)
+          ? key
+          : `${JSON_KEY_PREFIX}${encodeUtf16(key)}`;
+      if (Object.prototype.hasOwnProperty.call(output, encodedKey)) {
+        throw new UnsupportedCanonicalValueError("Canonical JSON key encoding collided");
+      }
+      const encodedValue = encodeJsonValue(descriptor.value, ancestors, depth + 1);
+      defineJsonDataProperty(output, encodedKey, encodedValue.value);
+      changed ||= encodedKey !== key || encodedValue.changed;
+    }
+    return changed ? { value: output, changed: true } : { value, changed: false };
+  } finally {
+    ancestors.delete(value);
+  }
+}
+
+function decodeJsonValue(value: unknown, depth: number): TransformResult {
+  if (depth > MAX_JSON_DEPTH) return { value, changed: false };
+  if (typeof value === "string") {
+    const decoded = decodeTaggedString(value, JSON_STRING_PREFIX);
+    return decoded === null ? { value, changed: false } : { value: decoded, changed: true };
+  }
+  if (!value || typeof value !== "object") return { value, changed: false };
+  if (Array.isArray(value)) {
+    const output: unknown[] = [];
+    let changed = false;
+    for (const entry of value) {
+      const decoded = decodeJsonValue(entry, depth + 1);
+      output.push(decoded.value);
+      changed ||= decoded.changed;
+    }
+    return changed ? { value: output, changed: true } : { value, changed: false };
+  }
+  if (!isPlainObject(value)) return { value, changed: false };
+
+  const output: Record<string, unknown> = {};
+  let changed = false;
+  for (const [key, entry] of Object.entries(value)) {
+    const decodedKey = decodeTaggedString(key, JSON_KEY_PREFIX) ?? key;
+    if (Object.prototype.hasOwnProperty.call(output, decodedKey)) {
+      return { value, changed: false };
+    }
+    const decodedValue = decodeJsonValue(entry, depth + 1);
+    defineJsonDataProperty(output, decodedKey, decodedValue.value);
+    changed ||= decodedKey !== key || decodedValue.changed;
+  }
+  return changed ? { value: output, changed: true } : { value, changed: false };
+}
+
+/**
+ * JSON permits own keys such as `__proto__`. Assignment into an ordinary `{}`
+ * would invoke the inherited legacy setter and silently replace the object's
+ * prototype instead of creating data. Define every transformed key explicitly
+ * so encode/decode preserve hostile-but-valid JSON keys and property order.
+ */
+function defineJsonDataProperty(
+  target: Record<string, unknown>,
+  key: string,
+  value: unknown,
+): void {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true,
+  });
+}
+
+function encodeUtf16(value: string): string {
+  const bytes = Buffer.allocUnsafe(value.length * 2);
+  for (let index = 0; index < value.length; index += 1) {
+    bytes.writeUInt16LE(value.charCodeAt(index), index * 2);
+  }
+  return bytes.toString("base64");
+}
+
+function decodeTaggedString(value: string, prefix: string): string | null {
+  if (!value.startsWith(prefix)) return null;
+  const encoded = value.slice(prefix.length);
+  if (encoded.length === 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(encoded)) return null;
+  const bytes = Buffer.from(encoded, "base64");
+  if (bytes.byteLength % 2 !== 0 || bytes.toString("base64") !== encoded) return null;
+  let decoded = "";
+  for (let offset = 0; offset < bytes.byteLength; offset += 2) {
+    decoded += String.fromCharCode(bytes.readUInt16LE(offset));
+  }
+  return decoded;
+}
+
+function isPostgresSafeString(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code === 0) return false;
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = index + 1 < value.length ? value.charCodeAt(index + 1) : 0;
+      if (next < 0xdc00 || next > 0xdfff) return false;
+      index += 1;
+      continue;
+    }
+    if (code >= 0xdc00 && code <= 0xdfff) return false;
+  }
+  return true;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}

package/src/memory-domain.ts

@@ -431,7 +431,7 @@ export const MEMORY_SEARCH_TOOL_DESCRIPTION =
   "Search this workspace's shared long-lived memory (semantic + keyword). Use it before starting a new non-trivial task when the injected notes or current conversation do not already answer how the workspace does something. Results persist in conversation context: do not repeat the same search as routine setup on every continuation, resume, or interrupted turn. Returns scored records with ids.";
 
 export const MEMORY_SAVE_TOOL_DESCRIPTION =
-  "Save one durable, future-useful fact to this workspace's shared memory: a stable preference, an environment fact, a procedure that worked, or a decision and its reason. Write it compactly (1–3 sentences), self-contained (no 'this session/above' references, absolute dates, name concrete things), so a future session can act on it alone. Do NOT save: session-specific state, speculation, anything derivable from the repo/docs, near-duplicates of existing memories (search first — to refine or replace an existing record pass replaces_id), or secrets/tokens/credentials. Most turns have nothing worth saving.";
+  "Save one durable, future-useful fact to this workspace's shared memory: a stable preference, an environment fact, a procedure that worked, or a decision and its reason. Write it compactly (1–3 sentences), self-contained (no 'this session/above' references, absolute dates, name concrete things), so a future session can act on it alone. Do NOT save: session-specific state, speculation, anything derivable from the repo/docs, or near-duplicates of existing memories (search first — to refine or replace an existing record pass replaces_id). Most turns have nothing worth saving.";
 
 export const MEMORY_CORRECT_TOOL_DESCRIPTION =
   "Flag a workspace memory as wrong or outdated the moment you discover it — this is the most valuable memory action, because a wrong memory misleads every future session. Pass the record's id (as shown in [brackets]); optionally give replacement_text with the corrected fact, otherwise the record is archived.";
@@ -452,51 +452,12 @@ export function hashMemoryText(text: string): string {
 }
 
 // ---------------------------------------------------------------------------
-// Sanitization + secret redaction
+// Exact stored memory content
 // ---------------------------------------------------------------------------
 
-// Conservative secret patterns. This is slop/leak defense, not a guarantee; the
-// end-state reflector adds real scanning. Each match is replaced with [REDACTED].
-const SECRET_PATTERNS: readonly RegExp[] = [
-  /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g, // PEM private keys
-  /AKIA[0-9A-Z]{16}/g, // AWS access key id
-  /\bASIA[0-9A-Z]{16}/g, // AWS temporary access key id
-  /\bsk-[A-Za-z0-9_-]{20,}/g, // OpenAI-style secret keys
-  /\bgh[pousr]_[A-Za-z0-9]{20,}/g, // GitHub tokens
-  /\bxox[baprs]-[A-Za-z0-9-]{10,}/g, // Slack tokens
-  /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, // JWT (three b64url segments)
-  /\bBearer\s+[A-Za-z0-9._~+/-]{16,}=*/gi, // bearer credentials
-  /\b(?:password|passwd|secret|api[_-]?key|token)\s*[=:]\s*\S{6,}/gi, // key=value secrets
-];
-
-// Strip C0/C1 control characters, collapse whitespace to single spaces, trim.
-function stripControlAndCollapse(raw: string): string {
-  // eslint-disable-next-line no-control-regex
-  const withoutControls = raw.replace(/[\u0000-\u001F\u007F-\u009F]/g, " ");
-  return withoutControls.replace(/\s+/g, " ").trim();
-}
-
-export type MemorySanitizeResult = {
-  text: string;
-  redactionCount: number;
-};
-
-// Produce the stored form of a memory text: control-stripped, single-line,
-// secret-redacted. Does NOT enforce the length cap (callers check
-// tooLong via isMemoryTextTooLong on the returned text so they can surface an
-// actionable error rather than silently truncating).
-export function sanitizeMemoryText(raw: string): MemorySanitizeResult {
-  let text = stripControlAndCollapse(raw);
-  let redactionCount = 0;
-  for (const pattern of SECRET_PATTERNS) {
-    text = text.replace(pattern, () => {
-      redactionCount += 1;
-      return "[REDACTED]";
-    });
-  }
-  // Redaction can leave doubled spaces; re-collapse.
-  text = text.replace(/\s+/g, " ").trim();
-  return { text, redactionCount };
+/** Accepted memory text is canonical content; validation must never rewrite it. */
+export function memoryTextForStorage(raw: string): string {
+  return raw;
 }
 
 export function isMemoryTextTooLong(text: string): boolean {

package/src/persistence-errors.ts

@@ -1,5 +1,3 @@
-import { sanitizeEventString } from "./event-payload-sanitizer";
-
 export type DatabaseFailureCode = "db_deadlock" | "db_serialization_failure" | "db_failure";
 
 export type PersistenceRetryOutcome = "not_retryable" | "exhausted";
@@ -58,7 +56,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 
 function safeFact(value: unknown): string | undefined {
   if (typeof value !== "string" || value.length === 0) return undefined;
-  return sanitizeEventString(value).slice(0, 256);
+  return value;
 }
 
 /** Find the driver SQLSTATE even when Drizzle wrapped it under nested causes. */
@@ -98,8 +96,8 @@ export function isRetryablePersistenceSqlState(sqlState: string | null): boolean
 
 /**
  * Distinguish database/ORM failures from expected domain exceptions when a
- * driver omitted SQLSTATE. This checks shape only and never retains query text,
- * bound parameters, or a raw driver cause.
+ * driver omitted SQLSTATE. This checks shape only; callers retain the original
+ * failure independently as canonical error evidence.
  */
 export function isDatabasePersistenceFailure(error: unknown): boolean {
   if (nestedPostgresSqlState(error) !== null) return true;
@@ -156,36 +154,30 @@ export function safeDatabaseErrorFacts(error: unknown): SafeDatabaseErrorFacts {
   return facts;
 }
 
-/** Public-safe cause that preserves database classification without driver data. */
-export class SanitizedDatabasePersistenceCause extends Error {
-  readonly name = "SanitizedDatabasePersistenceCause";
-
-  constructor(
-    readonly sqlState: string | null,
-    readonly database: SafeDatabaseErrorFacts,
-  ) {
-    super(sqlState === null ? "Database driver failure" : `PostgreSQL failure ${sqlState}`);
-  }
-}
-
 /**
- * Public-safe replacement for a raw Drizzle/postgres-js failure. Its `cause`
- * is a newly constructed sanitized projection; the original driver cause can
- * contain full SQL and bound parameters and is never retained.
+ * Typed persistence classification that retains the exact original failure as
+ * `cause`. Classification metadata supplements the cause; it never replaces or
+ * rewrites source error content.
  */
 export class SessionEventPersistenceError extends Error {
   readonly name = "SessionEventPersistenceError";
-  readonly cause: SanitizedDatabasePersistenceCause;
+  readonly cause: unknown;
 
-  constructor(readonly details: PersistenceFailureDetails) {
+  constructor(
+    readonly details: PersistenceFailureDetails,
+    cause?: unknown,
+  ) {
     const label =
       details.code === "db_deadlock"
         ? "Database deadlock"
         : details.code === "db_serialization_failure"
           ? "Database serialization failure"
           : "Database failure";
-    super(`${label} while persisting ${details.eventTypes.join(", ") || "session events"}`);
-    this.cause = new SanitizedDatabasePersistenceCause(details.sqlState, details.database);
+    const operation = `${label} while persisting ${details.eventTypes.join(", ") || "session events"}`;
+    const sourceMessage =
+      cause === undefined ? null : cause instanceof Error ? cause.message : String(cause);
+    super(sourceMessage ? `${operation}: ${sourceMessage}` : operation);
+    this.cause = cause;
   }
 
   get code(): DatabaseFailureCode {
@@ -236,16 +228,19 @@ export async function runIdempotentPersistenceTransaction<T>(
         continue;
       }
       if (!isDatabasePersistenceFailure(error)) throw error;
-      throw new SessionEventPersistenceError({
-        code: databaseFailureCode(sqlState),
-        sqlState,
-        stage: options.stage,
-        eventTypes,
-        correlationId,
-        attempts: attempt,
-        retryOutcome: retryable ? "exhausted" : "not_retryable",
-        database: safeDatabaseErrorFacts(error),
-      });
+      throw new SessionEventPersistenceError(
+        {
+          code: databaseFailureCode(sqlState),
+          sqlState,
+          stage: options.stage,
+          eventTypes,
+          correlationId,
+          attempts: attempt,
+          retryOutcome: retryable ? "exhausted" : "not_retryable",
+          database: safeDatabaseErrorFacts(error),
+        },
+        error,
+      );
     }
   }
   throw new Error("Unreachable persistence retry state");

package/src/runtime-posture.ts

@@ -67,6 +67,7 @@ export const FORCE_RLS_TABLES = [
   "knowledge_sync_runs",
   "machine_metrics_latest",
   "machine_metrics_series",
+  "machine_removal_operations",
   "model_call_facts",
   "new_session_drafts",
   "pack_installations",
@@ -74,6 +75,7 @@ export const FORCE_RLS_TABLES = [
   "preference_registry_preferences",
   "preference_registry_revisions",
   "preference_registry_snapshots",
+  "retained_screenshot_artifacts",
   "rig_changes",
   "rig_versions",
   "rigs",
@@ -136,6 +138,7 @@ export const FORCE_RLS_TABLES = [
   "workspace_instruction_policy_snapshots",
   "workspace_model_policies",
   "workspace_packs",
+  "workspace_screenshot_quotas",
   "workspace_session_activity_revisions",
   "workspace_variable_set_variables",
   "workspace_variable_sets",
@@ -204,10 +207,12 @@ export const RUNTIME_FULL_DML_TABLES = [
   "knowledge_memories",
   "machine_metrics_latest",
   "machine_metrics_series",
+  "machine_removal_operations",
   "managed_accounts",
   "model_call_facts",
   "new_session_drafts",
   "pack_installations",
+  "retained_screenshot_artifacts",
   "rig_changes",
   "rig_versions",
   "rigs",
@@ -265,6 +270,7 @@ export const RUNTIME_FULL_DML_TABLES = [
   "workspace_memberships",
   "workspace_model_policies",
   "workspace_packs",
+  "workspace_screenshot_quotas",
   "workspace_session_activity_revisions",
   "workspace_variable_set_variables",
   "workspace_variable_sets",