@qwen-code/qwen-code 0.23.3 → 0.23.4

package/chunks/chunk-LMJSPC55.js

@@ -0,0 +1,260 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  skillRestrictionNames
+} from "./chunk-NJ2OFVUX.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/config/skill-settings.ts
+init_esbuild_shims();
+function normalizeSkillNames(value) {
+  if (!Array.isArray(value)) return /* @__PURE__ */ new Set();
+  return new Set(
+    value.filter((name) => typeof name === "string").map((name) => name.trim().toLowerCase()).filter(Boolean)
+  );
+}
+__name(normalizeSkillNames, "normalizeSkillNames");
+function skillSettingStrings(settings, scope, key) {
+  const value = settings.forScope(scope).settings.skills?.[key];
+  return Array.isArray(value) ? value.filter((name) => typeof name === "string") : [];
+}
+__name(skillSettingStrings, "skillSettingStrings");
+function resolveSkillSettings(settings) {
+  const hardDisabled = normalizeSkillNames(settings.merged.skills?.disabled);
+  const defaultDisabled = normalizeSkillNames(
+    settings.merged.skills?.defaultDisabled
+  );
+  const enabled = normalizeSkillNames(settings.merged.skills?.enabled);
+  const disablements = /* @__PURE__ */ new Map();
+  for (const name of defaultDisabled) {
+    if (!enabled.has(name)) disablements.set(name, { reason: "default" });
+  }
+  const lockedScopes = [
+    ["SystemDefaults" /* SystemDefaults */, "systemDefaults"],
+    ["User" /* User */, "user"],
+    ["System" /* System */, "system"]
+  ];
+  const lockedByName = /* @__PURE__ */ new Map();
+  for (const [scope, label] of lockedScopes) {
+    for (const name of normalizeSkillNames(
+      skillSettingStrings(settings, scope, "disabled")
+    )) {
+      lockedByName.set(name, label);
+    }
+  }
+  for (const name of hardDisabled) {
+    const lockedScope = lockedByName.get(name);
+    disablements.set(name, {
+      reason: "hard",
+      ...lockedScope ? { lockedScope } : {}
+    });
+  }
+  return {
+    disabledNames: new Set(disablements.keys()),
+    defaultDisabledNames: defaultDisabled,
+    enabledNames: enabled,
+    disablements
+  };
+}
+__name(resolveSkillSettings, "resolveSkillSettings");
+function lookupSkillSetting(entries, skill) {
+  for (const name of skillRestrictionNames(skill)) {
+    const found = entries.get(name);
+    if (found !== void 0) return found;
+  }
+  return void 0;
+}
+__name(lookupSkillSetting, "lookupSkillSetting");
+function lookupSkillDisablement(disablements, skill) {
+  let fallback;
+  let hard;
+  for (const name of skillRestrictionNames(skill)) {
+    const found = disablements.get(name);
+    if (found?.reason === "hard") {
+      if (found.lockedScope) return found;
+      hard ??= found;
+      continue;
+    }
+    fallback ??= found;
+  }
+  return hard ?? fallback;
+}
+__name(lookupSkillDisablement, "lookupSkillDisablement");
+function buildHigherDisabled(settings) {
+  const scopeOfEntry = /* @__PURE__ */ new Map();
+  for (const [scope, label] of [
+    ["SystemDefaults" /* SystemDefaults */, "SystemDefaults"],
+    ["User" /* User */, "User"],
+    ["System" /* System */, "System"]
+  ]) {
+    for (const name of normalizeSkillNames(
+      skillSettingStrings(settings, scope, "disabled")
+    )) {
+      scopeOfEntry.set(name, label);
+    }
+  }
+  const hardEntries = /* @__PURE__ */ new Map();
+  const defaultEntries = /* @__PURE__ */ new Map();
+  for (const [scope, label] of [
+    ["SystemDefaults" /* SystemDefaults */, "SystemDefaults"],
+    ["User" /* User */, "User"],
+    ["Workspace" /* Workspace */, "Workspace"],
+    ["System" /* System */, "System"]
+  ]) {
+    if (scope === "Workspace" /* Workspace */ && !settings.isTrusted) continue;
+    for (const name of normalizeSkillNames(
+      skillSettingStrings(settings, scope, "disabled")
+    )) {
+      hardEntries.set(name, label);
+    }
+    for (const name of normalizeSkillNames(
+      skillSettingStrings(settings, scope, "defaultDisabled")
+    )) {
+      defaultEntries.set(name, label);
+    }
+  }
+  const enabledEntries = new Set(
+    [
+      "SystemDefaults" /* SystemDefaults */,
+      "User" /* User */,
+      "System" /* System */,
+      ...settings.isTrusted ? ["Workspace" /* Workspace */] : []
+    ].flatMap((scope) => [
+      ...normalizeSkillNames(skillSettingStrings(settings, scope, "enabled"))
+    ])
+  );
+  const workspaceDisabled = new Set(
+    settings.isTrusted ? normalizeSkillNames(
+      skillSettingStrings(settings, "Workspace" /* Workspace */, "disabled")
+    ) : []
+  );
+  const blockIn = /* @__PURE__ */ __name((skill) => {
+    const registry = skill.name.trim().toLowerCase();
+    const spellings = skillRestrictionNames(skill);
+    for (const spelling of spellings) {
+      const scope = scopeOfEntry.get(spelling);
+      if (scope) {
+        return { reason: "hard", list: "disabled", entry: spelling, scope };
+      }
+    }
+    for (const spelling of spellings) {
+      const hard = hardEntries.get(spelling);
+      if (hard) {
+        if (spelling === registry && workspaceDisabled.has(spelling)) {
+          continue;
+        }
+        return {
+          reason: "hard",
+          list: "disabled",
+          entry: spelling,
+          scope: hard
+        };
+      }
+      const def = defaultEntries.get(spelling);
+      if (def) {
+        if (spelling === registry || enabledEntries.has(spelling)) continue;
+        return {
+          reason: "default",
+          list: "defaultDisabled",
+          entry: spelling,
+          scope: def
+        };
+      }
+    }
+    return null;
+  }, "blockIn");
+  return {
+    blockIn,
+    lockedIn: /* @__PURE__ */ __name((skill) => {
+      const block = blockIn(skill);
+      if (!block) return null;
+      if (block.reason === "hard" && block.scope !== "Workspace") {
+        return block.scope;
+      }
+      return `skills.${block.list} '${block.entry}' (${block.scope})`;
+    }, "lockedIn")
+  };
+}
+__name(buildHigherDisabled, "buildHigherDisabled");
+function skillToggleBlockForName(settings, skillName) {
+  const prefixEnd = skillName.indexOf(":");
+  return buildHigherDisabled(settings).blockIn({
+    name: skillName,
+    ...prefixEnd > 0 ? { authoredName: skillName.slice(prefixEnd + 1) } : {}
+  });
+}
+__name(skillToggleBlockForName, "skillToggleBlockForName");
+function updateTarget(names, skillName, include) {
+  const normalizedName = skillName.trim().toLowerCase();
+  const next = [];
+  let found = false;
+  for (const name of names) {
+    if (name.trim().toLowerCase() !== normalizedName) {
+      next.push(name);
+    } else if (include && !found) {
+      next.push(skillName);
+      found = true;
+    }
+  }
+  if (include && !found) next.push(skillName);
+  return next;
+}
+__name(updateTarget, "updateTarget");
+function updateWorkspaceSkillSettingLists(lists, skillName, enabled) {
+  if (enabled) {
+    return {
+      disabled: updateTarget(lists.disabled, skillName, false),
+      enabled: updateTarget(lists.enabled, skillName, true)
+    };
+  }
+  return {
+    disabled: updateTarget(lists.disabled, skillName, true),
+    enabled: updateTarget(lists.enabled, skillName, false)
+  };
+}
+__name(updateWorkspaceSkillSettingLists, "updateWorkspaceSkillSettingLists");
+function computeWorkspaceSkillListUpdates(workspaceDisabled, workspaceEnabled, toggles) {
+  const previousDisabled = [...workspaceDisabled];
+  const previousEnabled = [...workspaceEnabled];
+  let next = {
+    disabled: previousDisabled,
+    enabled: previousEnabled
+  };
+  for (const toggle of toggles) {
+    if (toggle.wasEnabled === toggle.isEnabled) continue;
+    next = updateWorkspaceSkillSettingLists(
+      next,
+      toggle.name,
+      toggle.isEnabled
+    );
+  }
+  return {
+    disabled: next.disabled,
+    enabled: next.enabled,
+    disabledChanged: JSON.stringify(previousDisabled) !== JSON.stringify(next.disabled),
+    enabledChanged: JSON.stringify(previousEnabled) !== JSON.stringify(next.enabled)
+  };
+}
+__name(computeWorkspaceSkillListUpdates, "computeWorkspaceSkillListUpdates");
+
+export {
+  normalizeSkillNames,
+  skillSettingStrings,
+  resolveSkillSettings,
+  lookupSkillSetting,
+  lookupSkillDisablement,
+  buildHigherDisabled,
+  skillToggleBlockForName,
+  updateWorkspaceSkillSettingLists,
+  computeWorkspaceSkillListUpdates
+};
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-X6K77VHC.js → chunk-LWWRJRCD.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getGlobalQwenDir
-} from "./chunk-7QYWGTHB.js";
+} from "./chunk-EPVEPTI3.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-UXEO7E3V.js → chunk-LYD3T3H7.js}

@@ -143,6 +143,7 @@ export {
   MAX_CHILD_HEAP_MB,
   JOURNAL_GROWTH_POOL_FRACTION,
   MAX_JOURNAL_GROWTH_POOL_MB,
+  detectAvailableMemoryMb,
   isValidMemoryBudgetMb,
   memoryBudgetRangeError,
   recommendedChildShareMb,

package/chunks/{chunk-HBQ2NXOU.js → chunk-M6MID3FA.js}

@@ -6,8 +6,8 @@ import {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "b695664b8d";
-var CLI_VERSION = "0.23.3";
+var GIT_COMMIT_INFO = "fdcd7c2761";
+var CLI_VERSION = "0.23.4";
 
 export {
   GIT_COMMIT_INFO,

package/chunks/{chunk-E4UEO3XM.js → chunk-ME4JBHSB.js}

@@ -449,6 +449,23 @@ 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 getWebPreviewSnapshotId(artifact) {
+  const id = /^preview-([0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})$/.exec(
+    artifact.managedId ?? ""
+  )?.[1];
+  const sha256 = artifact.metadata?.[PUBLISHED_CONTENT_SHA256_METADATA_KEY];
+  if (!id || artifact.kind !== "html" || artifact.storage !== "published" || artifact.metadata?.["artifactType"] !== "web_preview_snapshot" || typeof sha256 !== "string" || !/^[0-9a-f]{64}$/.test(sha256) || artifact.source !== void 0 && (artifact.source !== "tool" || artifact.toolName?.toLowerCase() !== "artifact") || artifact.toolName !== void 0 && artifact.toolName.toLowerCase() !== "artifact")
+    return void 0;
+  try {
+    const url = new URL(artifact.url ?? "");
+    if (url.protocol === "file:" && !url.host && !url.search && !url.hash && url.pathname.endsWith(`/artifacts/snapshots/${id}/index.html`))
+      return id;
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+__name(getWebPreviewSnapshotId, "getWebPreviewSnapshotId");
 function isSessionArtifactRecord(record) {
   return isTranscriptArtifactRecord(record);
 }
@@ -797,7 +814,7 @@ function isForkSafeArtifact(artifact) {
   if (artifact.metadata && hasRestoreUnsafeMetadata(artifact.metadata)) {
     return false;
   }
-  if (artifact.url && hasRestoreUnsafeUrl(artifact.url)) {
+  if (artifact.url && hasRestoreUnsafeUrl(artifact.url) && !getWebPreviewSnapshotId(artifact)) {
     return false;
   }
   return true;
@@ -1233,6 +1250,296 @@ function getNonNegativeInteger(record, key) {
 }
 __name(getNonNegativeInteger, "getNonNegativeInteger");
 
+// packages/core/src/tools/artifact/html.ts
+init_esbuild_shims();
+var MAX_ARTIFACT_BYTES = 16 * 1024 * 1024;
+var CSS_RESET = `*,*::before,*::after{box-sizing:border-box}
+html{-webkit-text-size-adjust:100%}
+body{margin:0;padding:1.5rem;font-family:system-ui,-apple-system,Segoe UI,Roboto,sans-serif;line-height:1.5;color:#1a1a1a;background:#fff}
+img,svg,video,canvas{max-width:100%;height:auto}
+pre,table{max-width:100%;overflow-x:auto}
+:where(a){color:#0969da}`;
+var DEFAULT_TITLE = "Artifact";
+function sanitizeArtifactTitle(raw) {
+  const cleaned = (raw ?? "").replace(/\s+/g, " ").trim().slice(0, 120);
+  return cleaned || DEFAULT_TITLE;
+}
+__name(sanitizeArtifactTitle, "sanitizeArtifactTitle");
+function escapeForTitle(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+__name(escapeForTitle, "escapeForTitle");
+function validateSelfContained(fragment) {
+  if (!fragment.trim()) {
+    return "Artifact file is empty \u2014 write the page content (a body-only HTML fragment) first.";
+  }
+  const scan = normalizeAttributeQuotes(fragment);
+  const head = fragment.replace(/^\s+/, "").replace(/^(?:<!--[\s\S]*?-->\s*)+/, "");
+  const wrapperTag = /^(?:<!doctype\b|<html[\s>]|<head[\s>]|<body[\s>])/i.exec(
+    head
+  );
+  if (wrapperTag) {
+    return `Write a body-only fragment \u2014 it starts with a full-document tag (${wrapperTag[0].trim()}). Omit <!doctype>, <html>, <head>, and <body>; they are added at publish time.`;
+  }
+  const extResource = /\b(?:src|srcset|poster)\s*=\s*["']?\s*(?:https?:)?\/\//i.exec(scan) ?? /<link\b[^>]*\bhref\s*=\s*["']?\s*(?:https?:)?\/\//i.exec(scan);
+  if (extResource) {
+    return `Artifact must be self-contained \u2014 found an external reference (${truncate(extResource[0])}). Inline scripts/styles and embed assets as data: URIs.`;
+  }
+  const jsUri = /\b(?:href|src)\s*=\s*["']?\s*javascript\s*:/i.exec(scan);
+  if (jsUri) {
+    return `Artifact must be self-contained \u2014 found a javascript: URI (${truncate(jsUri[0])}). Use inline <script> blocks instead.`;
+  }
+  const extScript = /\b(?:fetch|WebSocket|XMLHttpRequest)\s*\(\s*["']\s*(?:https?|wss?):\/\//i.exec(
+    scan
+  ) ?? /\bimport\s*\(\s*["'](?:https?:)?\/\//i.exec(scan) ?? /\bwindow\.open\s*\(/i.exec(scan) ?? /\blocation\.\w+\s*[=(]/i.exec(scan) ?? /\bnavigator\.sendBeacon\s*\(\s*["']\s*(?:https?:)?\/\//i.exec(scan);
+  if (extScript) {
+    return `Artifact must be self-contained \u2014 found browser network egress (${truncate(extScript[0])}). Embed data in the artifact instead of fetching it at runtime.`;
+  }
+  const metaRefresh = /<meta\b[^>]*http-equiv\s*=\s*["']?refresh["']?[^>]*\burl\s*=\s*(?:https?:)?\/\//i.exec(
+    scan
+  );
+  if (metaRefresh) {
+    return `Artifact must be self-contained \u2014 found a meta refresh redirect (${truncate(metaRefresh[0])}).`;
+  }
+  const extCss = /(?:@import\s+(?:url\()?|url\()\s*["']?\s*(?:https?:)?\/\//i.exec(scan);
+  if (extCss) {
+    return `Artifact must be self-contained \u2014 found an external CSS reference (${truncate(extCss[0])}). Inline CSS and embed fonts/images as data: URIs.`;
+  }
+  return null;
+}
+__name(validateSelfContained, "validateSelfContained");
+function normalizeAttributeQuotes(s) {
+  return s.replace(/&quot;|&#34;|&#x22;/gi, '"').replace(/&apos;|&#39;|&#x27;/gi, "'");
+}
+__name(normalizeAttributeQuotes, "normalizeAttributeQuotes");
+function truncate(s, max = 60) {
+  const t = s.replace(/\s+/g, " ").trim();
+  return t.length > max ? `${t.slice(0, max)}\u2026` : t;
+}
+__name(truncate, "truncate");
+function wrapArtifactHtml(bodyFragment, title) {
+  const safeTitle = escapeForTitle(sanitizeArtifactTitle(title));
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data:; font-src data:; media-src data:; connect-src 'none'; form-action 'none'; base-uri 'none'; frame-ancestors 'none'; sandbox allow-scripts;">
+<title>${safeTitle}</title>
+<style>${CSS_RESET}</style>
+</head>
+<body>
+${bodyFragment}
+</body>
+</html>
+`;
+}
+__name(wrapArtifactHtml, "wrapArtifactHtml");
+function byteLength(s) {
+  return Buffer.byteLength(s, "utf8");
+}
+__name(byteLength, "byteLength");
+
+// packages/core/src/tools/artifact/artifact-snapshots.ts
+init_esbuild_shims();
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { constants, promises as fs } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+var SNAPSHOT_REFERENCES_METADATA_KEY = "qwen.snapshot.references";
+async function saveArtifactSnapshot(html, title, publishedUrl, sessionId, runtimeBaseDir) {
+  const id = randomUUID();
+  const root = path.join(runtimeBaseDir, "artifacts", "snapshots");
+  await fs.mkdir(root, { recursive: true });
+  const dir = path.join(root, id);
+  await fs.mkdir(dir);
+  const file = path.join(dir, "index.html");
+  try {
+    const references = path.join(dir, "references");
+    await fs.mkdir(references);
+    await fs.writeFile(
+      path.join(references, snapshotReference(sessionId)),
+      "",
+      {
+        flag: "wx",
+        mode: 384,
+        flush: true
+      }
+    );
+    await fs.writeFile(file, html, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384,
+      flush: true
+    });
+    await syncSnapshotDirectory(references);
+    await syncSnapshotDirectory(dir);
+    await syncSnapshotDirectory(root);
+  } catch (error) {
+    await fs.rm(dir, { recursive: true, force: true }).catch(() => void 0);
+    throw error;
+  }
+  return {
+    kind: "html",
+    storage: "published",
+    title,
+    url: pathToFileURL(file).href,
+    managedId: `preview-${id}`,
+    mimeType: "text/html",
+    sizeBytes: Buffer.byteLength(html, "utf8"),
+    metadata: {
+      artifactType: "web_preview_snapshot",
+      [SNAPSHOT_REFERENCES_METADATA_KEY]: 1,
+      publishedUrl,
+      [PUBLISHED_CONTENT_SHA256_METADATA_KEY]: createHash2("sha256").update(html).digest("hex")
+    }
+  };
+}
+__name(saveArtifactSnapshot, "saveArtifactSnapshot");
+async function readArtifactSnapshot(artifact, runtimeBaseDir) {
+  const id = getWebPreviewSnapshotId(artifact);
+  const sha256 = artifact.metadata?.[PUBLISHED_CONTENT_SHA256_METADATA_KEY];
+  const unavailable = /* @__PURE__ */ __name(() => new Error("Saved webpage version is unavailable."), "unavailable");
+  if (!id) throw unavailable();
+  const root = path.join(runtimeBaseDir, "artifacts", "snapshots");
+  const file = path.join(root, id, "index.html");
+  if (artifact.url !== pathToFileURL(file).href) throw unavailable();
+  const realRoot = await fs.realpath(root);
+  if (await fs.realpath(file) !== path.join(realRoot, id, "index.html")) {
+    throw unavailable();
+  }
+  const handle = await fs.open(
+    file,
+    // O_NOFOLLOW refuses a symlink swapped in after the realpath check, and
+    // O_NONBLOCK keeps a FIFO swapped into the same window from blocking the
+    // open: the path is only proven to be a regular file by the fstat below.
+    constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+  );
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size > MAX_ARTIFACT_BYTES) throw unavailable();
+    const bytes = Buffer.alloc(stat.size + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const { bytesRead } = await handle.read(
+        bytes,
+        length,
+        bytes.length - length
+      );
+      if (bytesRead === 0) break;
+      length += bytesRead;
+    }
+    const content = bytes.subarray(0, length);
+    if (length !== stat.size || createHash2("sha256").update(content).digest("hex") !== sha256) {
+      throw unavailable();
+    }
+    return content.toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+__name(readArtifactSnapshot, "readArtifactSnapshot");
+function snapshotReference(sessionId, operationId) {
+  const owner = createHash2("sha256").update(sessionId).digest("hex");
+  return operationId ? `${owner}-${createHash2("sha256").update(operationId).digest("hex")}` : owner;
+}
+__name(snapshotReference, "snapshotReference");
+async function syncSnapshotDirectory(directory) {
+  try {
+    const handle = await fs.open(directory, "r");
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    if (process.platform !== "win32") throw error;
+  }
+}
+__name(syncSnapshotDirectory, "syncSnapshotDirectory");
+async function snapshotDirectory(artifact, runtimeBaseDir) {
+  const id = getWebPreviewSnapshotId(artifact);
+  if (!id) return void 0;
+  const root = path.join(runtimeBaseDir, "artifacts", "snapshots");
+  const dir = path.join(root, id);
+  if (artifact.url !== pathToFileURL(path.join(dir, "index.html")).href) {
+    return void 0;
+  }
+  if (artifact.metadata?.[SNAPSHOT_REFERENCES_METADATA_KEY] !== 1)
+    return void 0;
+  const realRoot = await fs.realpath(root);
+  if (await fs.realpath(dir) !== path.join(realRoot, id)) return void 0;
+  if (await fs.realpath(path.join(dir, "index.html")) !== path.join(realRoot, id, "index.html"))
+    return void 0;
+  if (await fs.realpath(path.join(dir, "references")) !== path.join(realRoot, id, "references")) {
+    return void 0;
+  }
+  return dir;
+}
+__name(snapshotDirectory, "snapshotDirectory");
+async function retainArtifactSnapshot(artifact, runtimeBaseDir, sessionId, operationId) {
+  try {
+    const dir = await snapshotDirectory(artifact, runtimeBaseDir);
+    if (!dir) return;
+    const references = path.join(dir, "references");
+    const owner = snapshotReference(sessionId);
+    const entries = await fs.readdir(references);
+    if (!operationId && entries.some((entry) => entry === owner || entry.startsWith(`${owner}-`)))
+      return;
+    await fs.writeFile(
+      path.join(references, snapshotReference(sessionId, operationId)),
+      "",
+      { flag: "wx", mode: 384, flush: true }
+    );
+    await syncSnapshotDirectory(references);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "EEXIST" && !(code === "ENOENT" && !operationId)) throw error;
+  }
+}
+__name(retainArtifactSnapshot, "retainArtifactSnapshot");
+async function deleteArtifactSnapshot(artifact, runtimeBaseDir, sessionId, operationId, assertCleanupOwned) {
+  try {
+    const dir = await snapshotDirectory(artifact, runtimeBaseDir);
+    if (!dir) return;
+    await releaseSnapshotDirectory(
+      dir,
+      sessionId,
+      operationId,
+      assertCleanupOwned
+    );
+  } catch {
+    assertCleanupOwned?.();
+  }
+}
+__name(deleteArtifactSnapshot, "deleteArtifactSnapshot");
+async function releaseSnapshotDirectory(dir, sessionId, operationId, assertCleanupOwned) {
+  const references = path.join(dir, "references");
+  const owner = snapshotReference(sessionId, operationId);
+  let released = false;
+  for (const reference of await fs.readdir(references)) {
+    if (reference === owner || !operationId && reference.startsWith(`${owner}-`)) {
+      assertCleanupOwned?.();
+      await fs.unlink(path.join(references, reference));
+      released = true;
+    }
+  }
+  if (!released) return;
+  try {
+    assertCleanupOwned?.();
+    await fs.rmdir(references);
+  } catch (error) {
+    if (error.code === "ENOTEMPTY") return;
+    throw error;
+  }
+  const file = path.join(dir, "index.html");
+  assertCleanupOwned?.();
+  await fs.unlink(file);
+  assertCleanupOwned?.();
+  await fs.rmdir(dir);
+}
+__name(releaseSnapshotDirectory, "releaseSnapshotDirectory");
+
 export {
   TranscriptRecordPreparationError,
   stripGeneratedAttachmentTokens,
@@ -1250,6 +1557,7 @@ export {
   WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY,
   WORKSPACE_CONTENT_SIZE_BYTES_METADATA_KEY,
   PUBLISHED_CONTENT_SHA256_METADATA_KEY,
+  getWebPreviewSnapshotId,
   isSessionArtifactRecord,
   selectActiveSideArtifactRecordUuids,
   stableSessionArtifactId,
@@ -1261,7 +1569,16 @@ export {
   isPrototypeMetadataKey,
   isReservedWorkspaceMetadataKey,
   isAdoptableContentFingerprintKey,
-  metadataBudgetBytes
+  metadataBudgetBytes,
+  MAX_ARTIFACT_BYTES,
+  sanitizeArtifactTitle,
+  validateSelfContained,
+  wrapArtifactHtml,
+  byteLength,
+  saveArtifactSnapshot,
+  readArtifactSnapshot,
+  retainArtifactSnapshot,
+  deleteArtifactSnapshot
 };
 /**
  * @license
@@ -1273,3 +1590,8 @@ export {
  * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */