@qwen-code/qwen-code 0.22.2-preview.1 → 0.22.3-nightly.20260829.e5cb60ad48

package/chunks/chunk-DJBQCO2E.js

@@ -0,0 +1,842 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  isTranscriptArtifactRecord
+} from "./chunk-7J6OTNGO.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/services/session-artifact-persistence.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+var SESSION_ARTIFACT_PERSISTENCE_VERSION = 2;
+var CONTENT_ID_PATTERN = /^[0-9a-f]{64}-[0-9a-f]{16}$/;
+var WORKSPACE_CONTENT_SHA256_METADATA_KEY = "qwen.workspace.sha256";
+var WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY = "qwen.workspace.mtimeMs";
+var WORKSPACE_CONTENT_SIZE_BYTES_METADATA_KEY = "qwen.workspace.sizeBytes";
+var PUBLISHED_CONTENT_SHA256_METADATA_KEY = "qwen.published.sha256";
+var MAX_PERSISTED_ARTIFACTS = 500;
+var MAX_PERSISTED_EVENT_CHANGES = 800;
+var MAX_PERSISTED_IDS = 500;
+var MAX_PERSISTED_MARKER_ARTIFACTS = MAX_PERSISTED_IDS * 2;
+var MAX_PERSISTED_ID_CHARS = 200;
+var MAX_PERSISTED_TITLE_CHARS = 200;
+var MAX_PERSISTED_DESCRIPTION_CHARS = 1e3;
+var MAX_PERSISTED_PATH_CHARS = 500;
+var MAX_PERSISTED_URL_CHARS = 2048;
+var MAX_PERSISTED_MIME_CHARS = 120;
+var MAX_PERSISTED_FIELD_CHARS = 200;
+var MAX_PERSISTED_TIMESTAMP_CHARS = 64;
+var SECRET_TOKEN_VALUE_PATTERN = /(?:^|\s)(?:bearer\s+\S{8,}|sk-[A-Za-z0-9_-]{12,}|(?:gh[pousr]|github_pat)_[A-Za-z0-9_/-]{12,}|[a-f0-9]{40,}|[A-Za-z0-9+/]{48,}={0,2})(?:$|\s)/i;
+function isSessionArtifactRecord(record) {
+  return isTranscriptArtifactRecord(record);
+}
+__name(isSessionArtifactRecord, "isSessionArtifactRecord");
+function selectActiveSideArtifactRecordUuids(records, activeRecordUuids) {
+  const activeUuids = new Set(activeRecordUuids);
+  const firstActiveUuid = activeRecordUuids[0];
+  const firstActiveIndex = firstActiveUuid === void 0 ? -1 : records.findIndex((record) => record.uuid === firstActiveUuid);
+  const nextActiveUuidByIndex = /* @__PURE__ */ new Map();
+  const nextBlockingUuidByIndex = /* @__PURE__ */ new Map();
+  let nextActiveUuid;
+  let nextBlockingUuid;
+  for (let index = records.length - 1; index >= 0; index--) {
+    if (nextActiveUuid !== void 0) {
+      nextActiveUuidByIndex.set(index, nextActiveUuid);
+    }
+    if (nextBlockingUuid !== void 0) {
+      nextBlockingUuidByIndex.set(index, nextBlockingUuid);
+    }
+    const record = records[index];
+    if (activeUuids.has(record.uuid)) {
+      nextActiveUuid = record.uuid;
+      nextBlockingUuid = void 0;
+    } else if (!isSessionArtifactRecord(record) && !(record.type === "system" && record.subtype === "custom_title")) {
+      nextBlockingUuid = record.uuid;
+    }
+  }
+  const selected = [];
+  const includedSideArtifactUuids = /* @__PURE__ */ new Set();
+  let previousActiveUuid;
+  for (let index = 0; index < records.length; index++) {
+    const record = records[index];
+    if (activeUuids.has(record.uuid)) {
+      previousActiveUuid = record.uuid;
+      continue;
+    }
+    if (!isSessionArtifactRecord(record)) continue;
+    const nextUuid = nextActiveUuidByIndex.get(index);
+    const isInActiveSegment = !nextBlockingUuidByIndex.has(index) && (nextUuid !== void 0 ? activeUuids.has(nextUuid) : previousActiveUuid !== void 0 && activeUuids.has(previousActiveUuid));
+    if (record.parentUuid !== null && (activeUuids.has(record.parentUuid) || includedSideArtifactUuids.has(record.parentUuid)) && isInActiveSegment && (record.parentUuid === previousActiveUuid || includedSideArtifactUuids.has(record.parentUuid))) {
+      selected.push(record.uuid);
+      includedSideArtifactUuids.add(record.uuid);
+    } else if (record.parentUuid === null && index < firstActiveIndex && isInActiveSegment) {
+      selected.push(record.uuid);
+      includedSideArtifactUuids.add(record.uuid);
+    }
+  }
+  return selected;
+}
+__name(selectActiveSideArtifactRecordUuids, "selectActiveSideArtifactRecordUuids");
+function stableSessionArtifactId(sessionId, identityKey) {
+  return createHash("sha256").update(`${sessionId}:${identityKey}`).digest("hex").slice(0, 16);
+}
+__name(stableSessionArtifactId, "stableSessionArtifactId");
+function sessionArtifactIdentityKey(artifact) {
+  if (artifact.workspacePath) return `workspace:${artifact.workspacePath}`;
+  if (artifact.managedId) return `managed:${artifact.managedId}`;
+  if (artifact.url) return `url:${artifact.url}`;
+  return void 0;
+}
+__name(sessionArtifactIdentityKey, "sessionArtifactIdentityKey");
+var SessionArtifactSnapshotAccumulator = class {
+  static {
+    __name(this, "SessionArtifactSnapshotAccumulator");
+  }
+  artifacts = /* @__PURE__ */ new Map();
+  tombstonedIds = /* @__PURE__ */ new Set();
+  stickyEphemeralIds = /* @__PURE__ */ new Set();
+  markerArtifacts = /* @__PURE__ */ new Map();
+  warnings = [];
+  sequence = 0;
+  lastSnapshotSequence = 0;
+  sessionId;
+  sawRecord = false;
+  constructor(fallbackSessionId) {
+    this.sessionId = fallbackSessionId;
+  }
+  add(record) {
+    if (!isSessionArtifactRecord(record)) return;
+    if (record.subtype === "session_artifact_snapshot") {
+      const payload2 = normalizeSnapshotPayload(
+        record.systemPayload,
+        this.warnings
+      );
+      if (!payload2) return;
+      this.sawRecord = true;
+      this.sessionId = payload2.sessionId;
+      this.sequence = Math.max(this.sequence, payload2.sequence);
+      this.lastSnapshotSequence = payload2.sequence;
+      this.artifacts.clear();
+      this.tombstonedIds.clear();
+      this.stickyEphemeralIds.clear();
+      this.markerArtifacts.clear();
+      for (const id of payload2.tombstonedIds ?? []) this.tombstonedIds.add(id);
+      for (const id of payload2.stickyEphemeralIds ?? []) {
+        this.stickyEphemeralIds.add(id);
+      }
+      const markerIds = /* @__PURE__ */ new Set([
+        ...this.tombstonedIds,
+        ...this.stickyEphemeralIds
+      ]);
+      for (const artifact of payload2.markerArtifacts ?? []) {
+        if (markerIds.has(artifact.id)) {
+          this.markerArtifacts.set(artifact.id, artifact);
+        }
+      }
+      for (const artifact of payload2.artifacts) {
+        if (artifact.retention === "ephemeral") continue;
+        this.artifacts.set(artifact.id, artifact);
+        this.markerArtifacts.delete(artifact.id);
+      }
+      return;
+    }
+    const payload = normalizeEventPayload(record.systemPayload, this.warnings);
+    if (!payload) return;
+    this.sawRecord = true;
+    this.sessionId = payload.sessionId;
+    if (payload.sequence <= this.lastSnapshotSequence) {
+      this.warnings.push(
+        `skipped stale event sequence ${payload.sequence} at or before snapshot sequence ${this.lastSnapshotSequence}`
+      );
+      return;
+    }
+    this.sequence = Math.max(this.sequence, payload.sequence);
+    for (const change of payload.changes) {
+      if (change.action === "removed") {
+        this.artifacts.delete(change.artifactId);
+        if (change.reason === "explicit") {
+          this.tombstonedIds.add(change.artifactId);
+          this.stickyEphemeralIds.delete(change.artifactId);
+          if (change.artifact) {
+            this.markerArtifacts.set(change.artifactId, change.artifact);
+          }
+        }
+        if (change.reason === "eviction") {
+          this.stickyEphemeralIds.delete(change.artifactId);
+          this.markerArtifacts.delete(change.artifactId);
+        }
+        if (change.reason === "unpin_to_ephemeral") {
+          this.stickyEphemeralIds.add(change.artifactId);
+          if (change.artifact) {
+            this.markerArtifacts.set(change.artifactId, change.artifact);
+          }
+        }
+        continue;
+      }
+      if (!change.artifact || change.artifact.retention === "ephemeral") {
+        continue;
+      }
+      this.artifacts.set(change.artifact.id, change.artifact);
+      this.tombstonedIds.delete(change.artifact.id);
+      this.stickyEphemeralIds.delete(change.artifact.id);
+      this.markerArtifacts.delete(change.artifact.id);
+    }
+  }
+  finish() {
+    if (!this.sawRecord || !this.sessionId) return void 0;
+    return {
+      v: SESSION_ARTIFACT_PERSISTENCE_VERSION,
+      sessionId: this.sessionId,
+      sequence: this.sequence,
+      artifacts: Array.from(this.artifacts.values()),
+      tombstonedIds: Array.from(this.tombstonedIds),
+      stickyEphemeralIds: Array.from(this.stickyEphemeralIds),
+      ...this.markerArtifacts.size > 0 ? { markerArtifacts: Array.from(this.markerArtifacts.values()) } : {},
+      warnings: this.warnings
+    };
+  }
+};
+function rebuildSessionArtifactSnapshot(records, fallbackSessionId) {
+  const accumulator = new SessionArtifactSnapshotAccumulator(fallbackSessionId);
+  for (const record of records) accumulator.add(record);
+  return accumulator.finish();
+}
+__name(rebuildSessionArtifactSnapshot, "rebuildSessionArtifactSnapshot");
+function remapSessionArtifactPayloadForFork(payload, sourceSessionId, newSessionId, remappedArtifactIds = /* @__PURE__ */ new Map()) {
+  const snapshot = normalizeSnapshotPayload(payload, []);
+  if (snapshot) {
+    const {
+      markerArtifacts: snapshotMarkerArtifacts,
+      ...snapshotWithoutMarkers
+    } = snapshot;
+    const artifacts = [];
+    for (const artifact of snapshot.artifacts) {
+      const remapped = remapForkSafeSessionArtifactForFork(
+        artifact,
+        sourceSessionId,
+        newSessionId
+      );
+      if (!remapped) {
+        seedForkArtifactIdRemap(artifact, newSessionId, remappedArtifactIds);
+        continue;
+      }
+      remappedArtifactIds.set(artifact.id, remapped.id);
+      artifacts.push(remapped);
+    }
+    const markerIds = /* @__PURE__ */ new Set([
+      ...snapshot.tombstonedIds ?? [],
+      ...snapshot.stickyEphemeralIds ?? []
+    ]);
+    const markerArtifacts = (snapshotMarkerArtifacts ?? []).filter((artifact) => markerIds.has(artifact.id)).map((artifact) => {
+      const remapped = remapForkSafeSessionArtifactForFork(
+        artifact,
+        sourceSessionId,
+        newSessionId
+      );
+      if (!remapped) {
+        seedForkArtifactIdRemap(artifact, newSessionId, remappedArtifactIds);
+        return void 0;
+      }
+      remappedArtifactIds.set(artifact.id, remapped.id);
+      return remapped;
+    }).filter((artifact) => artifact !== void 0);
+    return {
+      ...snapshotWithoutMarkers,
+      sessionId: newSessionId,
+      artifacts,
+      ...markerArtifacts.length > 0 ? { markerArtifacts } : {},
+      tombstonedIds: (snapshot.tombstonedIds ?? []).map(
+        (artifactId) => remapArtifactIdForFork(
+          artifactId,
+          sourceSessionId,
+          newSessionId,
+          remappedArtifactIds
+        )
+      ),
+      stickyEphemeralIds: (snapshot.stickyEphemeralIds ?? []).map(
+        (artifactId) => remapArtifactIdForFork(
+          artifactId,
+          sourceSessionId,
+          newSessionId,
+          remappedArtifactIds
+        )
+      )
+    };
+  }
+  const event = normalizeEventPayload(payload, []);
+  if (!event) return payload;
+  return {
+    ...event,
+    sessionId: newSessionId,
+    changes: event.changes.map((change) => {
+      if (change.artifact) {
+        const artifact = remapForkSafeSessionArtifactForFork(
+          change.artifact,
+          sourceSessionId,
+          newSessionId
+        );
+        if (!artifact) {
+          if (change.action !== "removed") return void 0;
+          seedForkArtifactIdRemap(
+            change.artifact,
+            newSessionId,
+            remappedArtifactIds
+          );
+          const { artifact: _unsafeArtifact, ...changeWithoutArtifact } = change;
+          return {
+            ...changeWithoutArtifact,
+            artifactId: remapArtifactIdForFork(
+              change.artifactId,
+              sourceSessionId,
+              newSessionId,
+              remappedArtifactIds
+            )
+          };
+        }
+        remappedArtifactIds.set(change.artifactId, artifact.id);
+        return {
+          ...change,
+          artifactId: artifact.id,
+          artifact
+        };
+      }
+      if (change.action === "removed") {
+        return {
+          ...change,
+          artifactId: remapArtifactIdForFork(
+            change.artifactId,
+            sourceSessionId,
+            newSessionId,
+            remappedArtifactIds
+          )
+        };
+      }
+      return {
+        ...change,
+        artifactId: remapArtifactIdForFork(
+          change.artifactId,
+          sourceSessionId,
+          newSessionId,
+          remappedArtifactIds
+        )
+      };
+    }).filter((change) => change !== void 0)
+  };
+}
+__name(remapSessionArtifactPayloadForFork, "remapSessionArtifactPayloadForFork");
+function remapForkSafeSessionArtifactForFork(artifact, sourceSessionId, newSessionId) {
+  if (!isForkSafeArtifact(artifact)) return void 0;
+  return remapSessionArtifactForFork(artifact, sourceSessionId, newSessionId);
+}
+__name(remapForkSafeSessionArtifactForFork, "remapForkSafeSessionArtifactForFork");
+function seedForkArtifactIdRemap(artifact, newSessionId, remappedArtifactIds) {
+  const identityKey = forkSafeSessionArtifactIdentityKey(artifact);
+  if (!identityKey) return;
+  remappedArtifactIds.set(
+    artifact.id,
+    stableSessionArtifactId(newSessionId, identityKey)
+  );
+}
+__name(seedForkArtifactIdRemap, "seedForkArtifactIdRemap");
+function forkSafeSessionArtifactIdentityKey(artifact) {
+  if (artifact.workspacePath) return `workspace:${artifact.workspacePath}`;
+  if (artifact.managedId) return `managed:${artifact.managedId}`;
+  if (artifact.url && !hasRestoreUnsafeUrl(artifact.url)) {
+    return `url:${artifact.url}`;
+  }
+  return void 0;
+}
+__name(forkSafeSessionArtifactIdentityKey, "forkSafeSessionArtifactIdentityKey");
+function remapArtifactIdForFork(artifactId, sourceSessionId, newSessionId, remappedArtifactIds) {
+  return remappedArtifactIds.get(artifactId) ?? stableSessionArtifactId(
+    newSessionId,
+    `fork:${sourceSessionId}:${artifactId}`
+  );
+}
+__name(remapArtifactIdForFork, "remapArtifactIdForFork");
+function remapSessionArtifactForFork(artifact, sourceSessionId, newSessionId) {
+  const identityKey = sessionArtifactIdentityKey(artifact);
+  const id = identityKey ? stableSessionArtifactId(newSessionId, identityKey) : stableSessionArtifactId(
+    newSessionId,
+    `fork:${sourceSessionId}:${artifact.id}`
+  );
+  const next = {
+    ...artifact,
+    id,
+    retention: artifact.retention === "pinned" ? "restorable" : artifact.retention
+  };
+  delete next.contentRef;
+  delete next.expiresAt;
+  delete next.clientId;
+  return next;
+}
+__name(remapSessionArtifactForFork, "remapSessionArtifactForFork");
+function isForkSafeArtifact(artifact) {
+  if (artifact.metadata && hasRestoreUnsafeMetadata(artifact.metadata)) {
+    return false;
+  }
+  if (artifact.url && hasRestoreUnsafeUrl(artifact.url)) {
+    return false;
+  }
+  return true;
+}
+__name(isForkSafeArtifact, "isForkSafeArtifact");
+function hasRestoreUnsafeMetadata(metadata) {
+  for (const [key, value] of Object.entries(metadata)) {
+    if (!key || isSecretLikeText(key)) {
+      return true;
+    }
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      return true;
+    }
+    if (typeof value === "string" && !isReservedWorkspaceMetadataKey(key) && isSecretLikeMetadataValue(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(hasRestoreUnsafeMetadata, "hasRestoreUnsafeMetadata");
+function hasRestoreUnsafeUrl(value) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return true;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return true;
+  }
+  if (parsed.username || parsed.password) {
+    return true;
+  }
+  for (const [key, urlValue] of parsed.searchParams) {
+    if (isSecretLikeText(key) || isSecretLikeUrlValue(urlValue)) {
+      return true;
+    }
+  }
+  for (const segment of parsed.pathname.split("/").filter(Boolean)) {
+    let decodedSegment = segment;
+    try {
+      decodedSegment = decodeURIComponent(segment);
+    } catch {
+    }
+    if (isSecretLikeUrlValue(decodedSegment)) {
+      return true;
+    }
+  }
+  const fragment = parsed.hash.slice(1);
+  return hasSecretLikeUrlFragment(fragment);
+}
+__name(hasRestoreUnsafeUrl, "hasRestoreUnsafeUrl");
+function hasSecretLikeUrlFragment(fragment) {
+  if (!fragment) return false;
+  const candidates = /* @__PURE__ */ new Set([fragment]);
+  try {
+    candidates.add(decodeURIComponent(fragment));
+  } catch {
+  }
+  for (const candidate of candidates) {
+    if (isSecretLikeText(candidate) || isSecretLikeUrlValue(candidate)) {
+      return true;
+    }
+    for (const [key, value] of new URLSearchParams(candidate)) {
+      if (isSecretLikeText(key) || isSecretLikeUrlValue(value)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(hasSecretLikeUrlFragment, "hasSecretLikeUrlFragment");
+function isSecretLikeText(value) {
+  const normalized = value.replace(/([a-z])([A-Z])/g, "$1-$2");
+  return /(?:^|[-_.])(token|secret|password|passwd|pwd|cookie|authorization|credential|signature|sig|api[-_]?key|access[-_]?key)(?:$|[-_.=&#])/i.test(
+    normalized
+  );
+}
+__name(isSecretLikeText, "isSecretLikeText");
+function isSecretLikeUrlValue(value) {
+  return SECRET_TOKEN_VALUE_PATTERN.test(value.trim());
+}
+__name(isSecretLikeUrlValue, "isSecretLikeUrlValue");
+function isSecretLikeMetadataValue(value) {
+  return /^(?:bearer\s+\S{8,}|sk-[A-Za-z0-9_-]{12,}|(?:gh[pousr]|github_pat)_[A-Za-z0-9_/-]{12,})$/i.test(
+    value.trim()
+  );
+}
+__name(isSecretLikeMetadataValue, "isSecretLikeMetadataValue");
+function normalizeSnapshotPayload(value, warnings) {
+  if (!isRecord(value)) {
+    warnings.push("skipped malformed snapshot record");
+    return void 0;
+  }
+  if (value["v"] !== SESSION_ARTIFACT_PERSISTENCE_VERSION) {
+    warnings.push(
+      `skipped v${String(value["v"])} snapshot record (expected v${SESSION_ARTIFACT_PERSISTENCE_VERSION})`
+    );
+    return void 0;
+  }
+  if (!Array.isArray(value["artifacts"])) {
+    warnings.push("skipped snapshot record without artifacts array");
+    return void 0;
+  }
+  const sessionId = getString(value, "sessionId");
+  if (!sessionId) {
+    warnings.push("skipped snapshot record without sessionId");
+    return void 0;
+  }
+  const rawArtifacts = value["artifacts"];
+  if (rawArtifacts.length > MAX_PERSISTED_ARTIFACTS) {
+    warnings.push(
+      `snapshot artifact list truncated to ${MAX_PERSISTED_ARTIFACTS}`
+    );
+  }
+  const rawMarkerArtifacts = Array.isArray(value["markerArtifacts"]) ? value["markerArtifacts"] : [];
+  if (rawMarkerArtifacts.length > MAX_PERSISTED_MARKER_ARTIFACTS) {
+    warnings.push(
+      `snapshot marker artifact list truncated to ${MAX_PERSISTED_MARKER_ARTIFACTS}`
+    );
+  }
+  const artifacts = rawArtifacts.slice(0, MAX_PERSISTED_ARTIFACTS).map((artifact) => normalizePersistedArtifact(artifact, warnings)).filter((artifact) => artifact !== void 0);
+  const markerArtifacts = rawMarkerArtifacts.slice(0, MAX_PERSISTED_MARKER_ARTIFACTS).map((artifact) => normalizePersistedArtifact(artifact, warnings)).filter((artifact) => artifact !== void 0);
+  return {
+    v: SESSION_ARTIFACT_PERSISTENCE_VERSION,
+    sessionId,
+    sequence: getNonNegativeInteger(value, "sequence") ?? 0,
+    recordedAt: getString(value, "recordedAt", MAX_PERSISTED_TIMESTAMP_CHARS) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    artifacts,
+    ...markerArtifacts.length > 0 ? { markerArtifacts } : {},
+    tombstonedIds: getStringArray(value, "tombstonedIds", MAX_PERSISTED_IDS),
+    stickyEphemeralIds: getStringArray(
+      value,
+      "stickyEphemeralIds",
+      MAX_PERSISTED_IDS
+    )
+  };
+}
+__name(normalizeSnapshotPayload, "normalizeSnapshotPayload");
+function normalizeEventPayload(value, warnings) {
+  if (!isRecord(value)) {
+    warnings.push("skipped malformed event record");
+    return void 0;
+  }
+  if (value["v"] !== SESSION_ARTIFACT_PERSISTENCE_VERSION) {
+    warnings.push(
+      `skipped v${String(value["v"])} event record (expected v${SESSION_ARTIFACT_PERSISTENCE_VERSION})`
+    );
+    return void 0;
+  }
+  if (!Array.isArray(value["changes"])) {
+    warnings.push("skipped event record without changes array");
+    return void 0;
+  }
+  const sessionId = getString(value, "sessionId", MAX_PERSISTED_ID_CHARS);
+  if (!sessionId) {
+    warnings.push("skipped event record without sessionId");
+    return void 0;
+  }
+  const rawChanges = value["changes"];
+  if (rawChanges.length > MAX_PERSISTED_EVENT_CHANGES) {
+    warnings.push(
+      `event change list truncated to ${MAX_PERSISTED_EVENT_CHANGES}`
+    );
+  }
+  return {
+    v: SESSION_ARTIFACT_PERSISTENCE_VERSION,
+    sessionId,
+    sequence: getNonNegativeInteger(value, "sequence") ?? 0,
+    recordedAt: getString(value, "recordedAt", MAX_PERSISTED_TIMESTAMP_CHARS) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    changes: rawChanges.slice(0, MAX_PERSISTED_EVENT_CHANGES).map((change) => normalizePersistedChange(change, warnings)).filter((change) => change !== void 0)
+  };
+}
+__name(normalizeEventPayload, "normalizeEventPayload");
+function normalizePersistedChange(value, warnings) {
+  if (!isRecord(value)) {
+    warnings.push("skipped malformed artifact change");
+    return void 0;
+  }
+  const action = value["action"];
+  if (action !== "created" && action !== "updated" && action !== "removed") {
+    warnings.push("skipped artifact change with invalid action");
+    return void 0;
+  }
+  const artifact = normalizePersistedArtifact(value["artifact"], warnings);
+  const artifactId = getString(value, "artifactId", MAX_PERSISTED_ID_CHARS) ?? artifact?.id;
+  if (!artifactId) {
+    warnings.push("skipped artifact change without artifactId");
+    return void 0;
+  }
+  const reason = value["reason"];
+  return {
+    action,
+    artifactId,
+    ...artifact ? { artifact } : {},
+    ...reason === "explicit" || reason === "eviction" || reason === "unpin_to_ephemeral" ? { reason } : {}
+  };
+}
+__name(normalizePersistedChange, "normalizePersistedChange");
+function normalizePersistedArtifact(value, warnings) {
+  if (!isRecord(value)) return void 0;
+  const id = getString(value, "id", MAX_PERSISTED_ID_CHARS);
+  const title = getString(value, "title", MAX_PERSISTED_TITLE_CHARS);
+  if (!id || !title) {
+    warnings.push("skipped artifact without id/title");
+    return void 0;
+  }
+  const kind = normalizeLiteral(value["kind"], [
+    "file",
+    "link",
+    "html",
+    "image",
+    "video",
+    "audio",
+    "pdf",
+    "notebook",
+    "document",
+    "other"
+  ]);
+  const storage = normalizeLiteral(
+    value["storage"],
+    ["workspace", "external_url", "managed", "published"]
+  );
+  const source = normalizeLiteral(
+    value["source"],
+    ["tool", "hook", "client"]
+  );
+  const status = normalizeLiteral(value["status"], [
+    "available",
+    "missing",
+    "changed"
+  ]) ?? "missing";
+  const retention = normalizeLiteral(value["retention"], [
+    "ephemeral",
+    "restorable",
+    "pinned"
+  ]) ?? "restorable";
+  if (!kind || !storage || !source) {
+    warnings.push(`skipped malformed artifact ${id}`);
+    return void 0;
+  }
+  const metadata = normalizeMetadata(value["metadata"], warnings, id);
+  const description = getString(
+    value,
+    "description",
+    MAX_PERSISTED_DESCRIPTION_CHARS
+  );
+  const workspacePath = getString(
+    value,
+    "workspacePath",
+    MAX_PERSISTED_PATH_CHARS
+  );
+  const managedId = getString(value, "managedId", MAX_PERSISTED_FIELD_CHARS);
+  const url = getString(value, "url", MAX_PERSISTED_URL_CHARS);
+  const mimeType = getString(value, "mimeType", MAX_PERSISTED_MIME_CHARS);
+  const sizeBytes = getNonNegativeInteger(value, "sizeBytes");
+  const persistedAt = getString(
+    value,
+    "persistedAt",
+    MAX_PERSISTED_TIMESTAMP_CHARS
+  );
+  const expiresAt = getString(
+    value,
+    "expiresAt",
+    MAX_PERSISTED_TIMESTAMP_CHARS
+  );
+  const contentRef = normalizeContentRef(value["contentRef"]);
+  const toolCallId = getString(value, "toolCallId", MAX_PERSISTED_FIELD_CHARS);
+  const toolName = getString(value, "toolName", MAX_PERSISTED_FIELD_CHARS);
+  const hookEventName = getString(
+    value,
+    "hookEventName",
+    MAX_PERSISTED_FIELD_CHARS
+  );
+  const clientId = getString(value, "clientId", MAX_PERSISTED_FIELD_CHARS);
+  return {
+    id,
+    kind,
+    storage,
+    source,
+    status,
+    title,
+    ...description ? { description } : {},
+    ...workspacePath ? { workspacePath } : {},
+    ...managedId ? { managedId } : {},
+    ...url ? { url } : {},
+    ...mimeType ? { mimeType } : {},
+    ...sizeBytes !== void 0 ? { sizeBytes } : {},
+    ...metadata ? { metadata } : {},
+    retention,
+    clientRetained: value["clientRetained"] === true,
+    createdAt: getString(value, "createdAt", MAX_PERSISTED_TIMESTAMP_CHARS) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    updatedAt: getString(value, "updatedAt", MAX_PERSISTED_TIMESTAMP_CHARS) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    ...persistedAt ? { persistedAt } : {},
+    ...expiresAt ? { expiresAt } : {},
+    ...contentRef ? { contentRef } : {},
+    ...toolCallId ? { toolCallId } : {},
+    ...toolName ? { toolName } : {},
+    ...hookEventName ? { hookEventName } : {},
+    ...clientId ? { clientId } : {}
+  };
+}
+__name(normalizePersistedArtifact, "normalizePersistedArtifact");
+function normalizeContentRef(value) {
+  if (!isRecord(value) || value["kind"] !== "managed_copy") return void 0;
+  const contentId = getString(value, "contentId", MAX_PERSISTED_FIELD_CHARS);
+  const sha256 = getString(value, "sha256", 64);
+  const sizeBytes = getNonNegativeInteger(value, "sizeBytes");
+  const createdAt = getString(
+    value,
+    "createdAt",
+    MAX_PERSISTED_TIMESTAMP_CHARS
+  );
+  if (!contentId || !CONTENT_ID_PATTERN.test(contentId) || !sha256 || !/^[0-9a-f]{64}$/.test(sha256) || sizeBytes === void 0 || !createdAt) {
+    return void 0;
+  }
+  return { kind: "managed_copy", contentId, sha256, sizeBytes, createdAt };
+}
+__name(normalizeContentRef, "normalizeContentRef");
+function normalizeMetadata(value, warnings, artifactId) {
+  if (!isRecord(value)) return void 0;
+  const normalized = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (isPrototypeMetadataKey(key)) continue;
+    if (key.length > 120) continue;
+    if (hasControlCharacter(key) || hasUnsafeDisplayPayload(key)) continue;
+    if (item === null || typeof item === "string" || typeof item === "number" || typeof item === "boolean") {
+      if (isAdoptableContentFingerprintKey(key) && !isContentFingerprintMetadataEntry(key, item)) {
+        continue;
+      }
+      if (typeof item === "string" && (hasControlCharacter(item) || hasUnsafeDisplayPayload(item))) {
+        continue;
+      }
+      normalized[key] = item;
+    }
+  }
+  if (Object.keys(normalized).length === 0) return void 0;
+  if (metadataBudgetBytes(normalized) > 4096) {
+    warnings.push(`skipped oversized metadata for artifact ${artifactId}`);
+    return void 0;
+  }
+  return normalized;
+}
+__name(normalizeMetadata, "normalizeMetadata");
+function isPrototypeMetadataKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+__name(isPrototypeMetadataKey, "isPrototypeMetadataKey");
+function isReservedWorkspaceMetadataKey(key) {
+  return key === WORKSPACE_CONTENT_SHA256_METADATA_KEY || key === WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY || key === WORKSPACE_CONTENT_SIZE_BYTES_METADATA_KEY;
+}
+__name(isReservedWorkspaceMetadataKey, "isReservedWorkspaceMetadataKey");
+function isAdoptableContentFingerprintKey(key) {
+  return isReservedWorkspaceMetadataKey(key) || key === PUBLISHED_CONTENT_SHA256_METADATA_KEY;
+}
+__name(isAdoptableContentFingerprintKey, "isAdoptableContentFingerprintKey");
+function hasControlCharacter(value) {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code <= 31 || code === 127 || code >= 8203 && code <= 8207 || code === 8232 || code === 8233 || code >= 8234 && code <= 8238 || code >= 8294 && code <= 8297 || code === 65279) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(hasControlCharacter, "hasControlCharacter");
+function hasUnsafeDisplayPayload(value) {
+  return /<\s*\/?[a-z!]|&(?:#[0-9]+|#x[0-9a-f]+|[a-z][a-z0-9]+);|javascript\s*:|data\s*:\s*(?:text\/(?:html|javascript)|application\/javascript|image\/svg\+xml)/i.test(
+    value
+  ) || /(?:^|[\s"'`<])on[a-z][a-z0-9-]*\s*=/i.test(value);
+}
+__name(hasUnsafeDisplayPayload, "hasUnsafeDisplayPayload");
+function metadataBudgetBytes(metadata, budget = "persisted") {
+  if (budget === "user") {
+    return Buffer.byteLength(JSON.stringify(metadata), "utf8");
+  }
+  const userMetadata = Object.fromEntries(
+    Object.entries(metadata).filter(
+      ([key, value]) => !isContentFingerprintMetadataEntry(key, value)
+    )
+  );
+  return Buffer.byteLength(JSON.stringify(userMetadata), "utf8");
+}
+__name(metadataBudgetBytes, "metadataBudgetBytes");
+function isWorkspaceContentMetadataEntry(key, value) {
+  if (key === WORKSPACE_CONTENT_SHA256_METADATA_KEY) {
+    return typeof value === "string" && /^[0-9a-f]{64}$/.test(value);
+  }
+  if (key === WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY) {
+    return typeof value === "number" && Number.isFinite(value);
+  }
+  if (key === WORKSPACE_CONTENT_SIZE_BYTES_METADATA_KEY) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0;
+  }
+  return false;
+}
+__name(isWorkspaceContentMetadataEntry, "isWorkspaceContentMetadataEntry");
+function isContentFingerprintMetadataEntry(key, value) {
+  if (isWorkspaceContentMetadataEntry(key, value)) {
+    return true;
+  }
+  return key === PUBLISHED_CONTENT_SHA256_METADATA_KEY && typeof value === "string" && /^[0-9a-f]{64}$/.test(value);
+}
+__name(isContentFingerprintMetadataEntry, "isContentFingerprintMetadataEntry");
+function normalizeLiteral(value, allowed) {
+  return typeof value === "string" && allowed.includes(value) ? value : void 0;
+}
+__name(normalizeLiteral, "normalizeLiteral");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function getString(record, key, maxLength = MAX_PERSISTED_FIELD_CHARS) {
+  const value = record[key];
+  if (typeof value !== "string" || value.length > maxLength) {
+    return void 0;
+  }
+  return value;
+}
+__name(getString, "getString");
+function getStringArray(record, key, maxItems = MAX_PERSISTED_IDS, maxLength = MAX_PERSISTED_ID_CHARS) {
+  const value = record[key];
+  if (!Array.isArray(value)) return void 0;
+  const items = value.filter(
+    (item) => typeof item === "string" && item.length <= maxLength
+  ).slice(-maxItems);
+  return items.length > 0 ? items : void 0;
+}
+__name(getStringArray, "getStringArray");
+function getNonNegativeInteger(record, key) {
+  const value = record[key];
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+__name(getNonNegativeInteger, "getNonNegativeInteger");
+
+export {
+  SESSION_ARTIFACT_PERSISTENCE_VERSION,
+  WORKSPACE_CONTENT_SHA256_METADATA_KEY,
+  WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY,
+  WORKSPACE_CONTENT_SIZE_BYTES_METADATA_KEY,
+  PUBLISHED_CONTENT_SHA256_METADATA_KEY,
+  isSessionArtifactRecord,
+  selectActiveSideArtifactRecordUuids,
+  stableSessionArtifactId,
+  SessionArtifactSnapshotAccumulator,
+  rebuildSessionArtifactSnapshot,
+  remapSessionArtifactPayloadForFork,
+  normalizeSnapshotPayload,
+  normalizeEventPayload,
+  isPrototypeMetadataKey,
+  isReservedWorkspaceMetadataKey,
+  isAdoptableContentFingerprintKey,
+  metadataBudgetBytes
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */