chore: import upstream snapshot with attribution

apps/sim/ee/workspace-forking/lib/remap/remap-files.ts

@@ -0,0 +1,101 @@
+/**
+ * `file-upload` subblock remapping for fork/promote.
+ *
+ * A `file-upload` value is a workspace-file reference (or array of them) stored as
+ * objects `{ key, name, ... }` where `key` is the object-storage key (NOT the
+ * `workspace_files.id`). Forking copies the blob to a new key; this rewrites each
+ * reference's key to the copied key, preserving the rest of the object. References
+ * whose file was not copied are dropped (the field is emptied) rather than left
+ * pointing at another workspace's blob. External `file-selector` references
+ * (provider file ids, credential-scoped) are NOT handled here - they carry over
+ * unchanged.
+ */
+
+function parseMaybeJson(value: unknown): { value: unknown; serialized: boolean } {
+  if (typeof value !== 'string') return { value, serialized: false }
+  const trimmed = value.trim()
+  const looksJson =
+    (trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+    (trimmed.startsWith('[') && trimmed.endsWith(']'))
+  if (!looksJson) return { value, serialized: false }
+  try {
+    return { value: JSON.parse(trimmed), serialized: true }
+  } catch {
+    return { value, serialized: false }
+  }
+}
+
+/** The field a file-upload item uses as its storage key, and that key's value. */
+function fileItemKeyField(item: unknown): { field: 'key' | 'path' | 'name'; key: string } | null {
+  if (!item || typeof item !== 'object' || Array.isArray(item)) return null
+  const record = item as Record<string, unknown>
+  for (const field of ['key', 'path', 'name'] as const) {
+    const value = record[field]
+    if (typeof value === 'string' && value.trim().length > 0) return { field, key: value }
+  }
+  return null
+}
+
+/**
+ * Enumerate the workspace-file storage keys referenced by a `file-upload` subblock
+ * value (single object, array, or JSON-string form). Used at promote time to emit each
+ * workspace file as a `file` reference (keyed by storage key) so it surfaces in the
+ * scan / unmapped set and can be copied into the target. Deduplicated, order-preserving.
+ */
+export function collectForkFileUploadKeys(value: unknown): string[] {
+  const parsed = parseMaybeJson(value)
+  const items = Array.isArray(parsed.value)
+    ? (parsed.value as unknown[])
+    : parsed.value
+      ? [parsed.value]
+      : []
+  const keys: string[] = []
+  const seen = new Set<string>()
+  for (const item of items) {
+    const keyInfo = fileItemKeyField(item)
+    if (!keyInfo || seen.has(keyInfo.key)) continue
+    seen.add(keyInfo.key)
+    keys.push(keyInfo.key)
+  }
+  return keys
+}
+
+/**
+ * Remap a `file-upload` subblock value. `resolveFileKey(sourceKey)` returns the
+ * copied target storage key, or null when the file was not copied (drop the ref).
+ */
+export function remapForkFileUploadValue(
+  value: unknown,
+  resolveFileKey: (sourceKey: string) => string | null
+): unknown {
+  const parsed = parseMaybeJson(value)
+  const isArray = Array.isArray(parsed.value)
+  const items = isArray ? (parsed.value as unknown[]) : parsed.value ? [parsed.value] : []
+  if (items.length === 0) return value
+
+  const next: unknown[] = []
+  let changed = false
+  for (const item of items) {
+    const keyInfo = fileItemKeyField(item)
+    if (!keyInfo) {
+      next.push(item)
+      continue
+    }
+    const targetKey = resolveFileKey(keyInfo.key)
+    if (targetKey == null) {
+      changed = true
+      continue
+    }
+    if (targetKey === keyInfo.key) {
+      next.push(item)
+      continue
+    }
+    changed = true
+    next.push({ ...(item as Record<string, unknown>), [keyInfo.field]: targetKey })
+  }
+
+  if (!changed) return value
+  if (next.length === 0) return ''
+  if (isArray) return parsed.serialized ? JSON.stringify(next) : next
+  return parsed.serialized ? JSON.stringify(next[0]) : next[0]
+}