@jxsuite/studio 2.2.2 → 2.4.0

package/dist/chunks/studio-qhh8r5fz.js.map

@@ -1,13 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/services/references.ts", "../src/files/media-upload.ts", "../src/services/code-services.ts", "../src/files/media-paths.ts"],
-  "sourcesContent": [
-    "/**\n * References.ts — one usage query, three renderings, one cache.\n *\n * \"Where is this used?\" is asked by the inspector's **Used on N pages →**, by `Selection: Find\n * Usages`, and — the reason the query exists at all — by **every delete and rename confirmation**.\n * Destructive dialogs were graded by reversibility with no idea what they broke: deleting a\n * component used on seven pages looked exactly like deleting an unused one. Three surfaces asking\n * the same question must give the same answer, so they ask it through here.\n *\n * **The gate is a capability, and \"no answer\" is never zero.** `capability.findReferences` is\n * presence of the PAL member, and a host without it hides all three renderings rather than showing\n * a confident 0. When the query is supported but FAILS, {@link usageWarning} says so in the same\n * words the dialog would use for a real count — a confirmation may say \"unknown\", never \"nothing\".\n *\n * **Two caches, one truth.** The backend memoises the project sweep and drops it from its own fs\n * watcher (`@jxsuite/server/refactor/find-refs`). This module memoises the ROUND TRIP, so a panel\n * repainting sixty times a second is one request, and clears it on any filesystem event\n * (`invalidateUsages`, called from `files/fs-events.ts` and from Studio's own destructive ops).\n * Neither cache has a TTL: a usage count that expires on a timer is a count that is wrong at some\n * unannounced moment, which is the one thing a delete confirmation cannot be.\n *\n * @docs studio/projects/pages-layouts-components\n */\n\nimport { getPlatform, hasPlatform } from \"../platform\";\nimport { errorMessage } from \"@jxsuite/schema/parse\";\nimport type { ReferencesResult } from \"../types\";\n\n/** What to look for: a file path, a component tag, or both (a component document is both). */\nexport interface UsageQuery {\n  path?: string;\n  tagName?: string;\n}\n\n/** A resolved query, or the reason there is no number to show. */\nexport type UsageState =\n  | { status: \"unsupported\" }\n  | { status: \"pending\" }\n  | { status: \"ready\"; result: ReferencesResult }\n  | { status: \"failed\"; message: string };\n\n/** Whether this host can answer the question at all — the `capability.findReferences` test. */\nexport function usagesSupported(): boolean {\n  return hasPlatform() && typeof getPlatform().findReferences === \"function\";\n}\n\n/** The cache key. Both fields, because \"the file\" and \"the tag\" are different questions. */\nfunction keyOf(query: UsageQuery): string {\n  return `${query.path ?? \"\"}\u0000${query.tagName ?? \"\"}`;\n}\n\n/** Settled answers, by key. Cleared wholesale whenever the filesystem moves. */\nconst settled = new Map<string, UsageState>();\n/** In-flight round trips, so N repaints of the same panel are one request. */\nconst inFlight = new Map<string, Promise<UsageState>>();\n\n/**\n * The answer right now, WITHOUT starting a request.\n *\n * Templates call this: a lit render must be synchronous, and a render that kicked off I/O every\n * time it ran would re-request on its own repaint. `null` means \"nothing cached\" — the caller\n * decides whether this paint is the one that asks (see {@link loadUsages}).\n */\nexport function peekUsages(query: UsageQuery): UsageState | null {\n  if (!usagesSupported()) {\n    return { status: \"unsupported\" };\n  }\n  return settled.get(keyOf(query)) ?? (inFlight.has(keyOf(query)) ? { status: \"pending\" } : null);\n}\n\n/**\n * Ask, or join the ask already in flight. Never rejects — a failed query is a STATE, because every\n * caller has to render something and \"unknown\" is the honest something.\n *\n * @param query — a path, a tag, or both.\n */\nexport async function loadUsages(query: UsageQuery): Promise<UsageState> {\n  if (!usagesSupported()) {\n    return { status: \"unsupported\" };\n  }\n  if (!query.path && !query.tagName) {\n    return { status: \"failed\", message: \"no target to look for\" };\n  }\n  const key = keyOf(query);\n  const done = settled.get(key);\n  if (done) {\n    return done;\n  }\n  const running = inFlight.get(key);\n  if (running) {\n    return running;\n  }\n  const pending = (async (): Promise<UsageState> => {\n    try {\n      const result = await getPlatform().findReferences!({\n        ...(query.path === undefined ? {} : { path: query.path }),\n        ...(query.tagName === undefined ? {} : { tagName: query.tagName }),\n      });\n      return { result, status: \"ready\" };\n    } catch (error) {\n      return { message: errorMessage(error), status: \"failed\" };\n    } finally {\n      inFlight.delete(key);\n    }\n  })();\n  inFlight.set(key, pending);\n  const state = await pending;\n  // Failures are remembered too, and deliberately. A panel that repaints on the answer would ask\n  // Again the moment a failure left no trace, and a broken backend would become a request loop —\n  // So a failure is a settled state with a Retry, not an absence. {@link retryUsages} clears it.\n  settled.set(key, state);\n  return state;\n}\n\n/** Forget one answer and ask again — the Retry behind a failed count. */\nexport function retryUsages(query: UsageQuery): Promise<UsageState> {\n  settled.delete(keyOf(query));\n  return loadUsages(query);\n}\n\n/**\n * Drop every cached answer.\n *\n * Called from the filesystem-event subscription and from Studio's own renames and deletes — the\n * local write never round-trips through the watcher's echo filter, so it has to say so itself.\n */\nexport function invalidateUsages(): void {\n  settled.clear();\n}\n\n/**\n * Split a result into pages and everything else, by the file-based routing convention (`pages/` is\n * the route tree). The plan's phrase is \"Used on N **pages**\", and a component referenced only from\n * another component has not been placed on a page at all — a distinction the count has to keep.\n */\nexport function splitUsages(result: ReferencesResult): { pages: number; others: number } {\n  let pages = 0;\n  for (const file of result.files) {\n    if (file.path.startsWith(\"pages/\")) {\n      pages += 1;\n    }\n  }\n  return { others: result.files.length - pages, pages };\n}\n\n/** \"Used on 7 pages\" / \"Used in 3 files\" / \"Not used yet\" — the inspector's one line. */\nexport function usageHeadline(result: ReferencesResult): string {\n  const { others, pages } = splitUsages(result);\n  if (pages === 0 && others === 0) {\n    return \"Not used yet\";\n  }\n  const parts: string[] = [];\n  if (pages > 0) {\n    parts.push(`${pages} page${pages === 1 ? \"\" : \"s\"}`);\n  }\n  if (others > 0) {\n    parts.push(`${others} other file${others === 1 ? \"\" : \"s\"}`);\n  }\n  return `Used on ${parts.join(\" and \")}`;\n}\n\n/**\n * The sentence a destructive confirmation adds — what breaks, or why we cannot say.\n *\n * @param state — the resolved query for the file about to be deleted or renamed.\n * @param verb — `\"delete\"` or `\"rename\"`. A rename REPAIRS its references (the refactor pass\n *   rewrites them); a delete breaks them. Saying the same thing for both is what made the two feel\n *   equally safe.\n * @returns One sentence, or `null` when the host cannot answer and the dialog should stay silent\n *   rather than imply a count.\n */\nexport function usageWarning(state: UsageState, verb: \"delete\" | \"rename\"): string | null {\n  if (state.status === \"unsupported\") {\n    return null;\n  }\n  if (state.status === \"pending\") {\n    return \"Counting references…\";\n  }\n  if (state.status === \"failed\") {\n    return `References could not be counted (${state.message}) — this may break more than it appears to.`;\n  }\n  const { files, refsTotal } = state.result;\n  if (files.length === 0) {\n    return verb === \"delete\"\n      ? \"Nothing else in this project refers to it.\"\n      : \"Nothing else in this project refers to it, so nothing needs updating.\";\n  }\n  const where = `${refsTotal} reference${refsTotal === 1 ? \"\" : \"s\"} in ${files.length} file${\n    files.length === 1 ? \"\" : \"s\"\n  }`;\n  const floor =\n    state.result.errors.length > 0 ? \" (at least — some documents could not be read)\" : \"\";\n  return verb === \"delete\"\n    ? `${where}${floor} will break. Those files stay on disk; the references in them stop resolving.`\n    : `${where}${floor} will be updated automatically. Nothing else changes.`;\n}\n\n/** The referencing files, most-referenced first, for a Find Usages list. */\nexport function usageFiles(result: ReferencesResult): ReferencesResult[\"files\"] {\n  return result.files.toSorted((a, b) => b.count - a.count || a.path.localeCompare(b.path));\n}\n",
-    "/// <reference lib=\"dom\" />\n/**\n * Media upload core — the single path every upload surface goes through.\n *\n * Four surfaces feed it: the image field's Upload button (ui/media-picker), a file dropped on the\n * canvas (editor/file-drop-action), a file dropped on the Files tree (files/files), and the Manage\n * view's drop zone / Upload button (browse/browse). They differ only in how the destination\n * directory is chosen; naming, collision handling, the platform call, and cache invalidation are\n * shared here.\n *\n * Destination (specs/site-architecture.md §9.1/§9.3): a document inside a content collection keeps\n * its media co-located in `content/<collection>/images/` — the entry references it file-relatively\n * and the collection loader rewrites it to the asset mount. Everything else goes to `public/`,\n * which is served from the site root.\n *\n * @docs studio/projects/media\n */\n\nimport { errorMessage } from \"@jxsuite/schema/parse\";\nimport { getPlatform } from \"../platform\";\nimport { notify } from \"../services/notify\";\nimport { activeTab } from \"../workspace/workspace\";\n\n// ─── File classification ─────────────────────────────────────────────────────\n\n/** Extensions rendered as a thumbnail (media picker, Manage cards, file-tree icons). */\nexport const IMAGE_EXTENSIONS = new Set([\n  \".jpg\",\n  \".jpeg\",\n  \".png\",\n  \".gif\",\n  \".svg\",\n  \".webp\",\n  \".avif\",\n  \".ico\",\n]);\n\n/** Every extension Studio treats as project media. Superset of {@link IMAGE_EXTENSIONS}. */\nexport const MEDIA_EXTENSIONS = new Set([\n  ...IMAGE_EXTENSIONS,\n  \".mp4\",\n  \".webm\",\n  \".mp3\",\n  \".wav\",\n  \".ogg\",\n  \".pdf\",\n  \".woff\",\n  \".woff2\",\n  \".ttf\",\n  \".otf\",\n]);\n\n/** The `accept` attribute for every upload file input. */\nexport const UPLOAD_ACCEPT = [\n  \"image/*\",\n  \"video/*\",\n  \"audio/*\",\n  \".pdf\",\n  \".svg\",\n  \".woff\",\n  \".woff2\",\n  \".ttf\",\n  \".otf\",\n].join(\",\");\n\n/** What kind of element an uploaded asset wants to become. */\nexport type AssetKind = \"image\" | \"video\" | \"audio\" | \"file\";\n\n/** One successfully uploaded file. */\nexport interface UploadedAsset {\n  /** Project-relative path written, e.g. `public/hero.jpg`. */\n  path: string;\n  /** The filename actually used (may carry a collision suffix). */\n  name: string;\n  /** The reference to write into a document `src`/prop, e.g. `/hero.jpg`. */\n  ref: string;\n  kind: AssetKind;\n}\n\n/** Lowercased extension including the dot, or `\"\"` when the name carries none. */\nexport function extensionOf(name: string): string {\n  const dot = name.lastIndexOf(\".\");\n  return dot > 0 ? name.slice(dot).toLowerCase() : \"\";\n}\n\n/** Whether a file extension (with or without the leading dot) is a previewable image. */\nexport function isImage(ext: string): boolean {\n  return IMAGE_EXTENSIONS.has(ext.startsWith(\".\") ? ext.toLowerCase() : `.${ext.toLowerCase()}`);\n}\n\n/** Whether a filename is project media. */\nexport function isMediaFile(name: string): boolean {\n  return MEDIA_EXTENSIONS.has(extensionOf(name));\n}\n\nconst VIDEO_EXTENSIONS = new Set([\".mp4\", \".webm\", \".mov\", \".m4v\"]);\nconst AUDIO_EXTENSIONS = new Set([\".mp3\", \".wav\", \".ogg\", \".m4a\", \".flac\"]);\n\n/**\n * Classify a file by MIME type, falling back to its extension. A drop from the OS usually carries a\n * `type`, but it is empty for unrecognized extensions and for some Linux file managers.\n */\nexport function mediaKind(file: { name: string; type?: string }): AssetKind {\n  const mime = file.type ?? \"\";\n  if (mime.startsWith(\"image/\")) {\n    return \"image\";\n  }\n  if (mime.startsWith(\"video/\")) {\n    return \"video\";\n  }\n  if (mime.startsWith(\"audio/\")) {\n    return \"audio\";\n  }\n  const ext = extensionOf(file.name);\n  if (IMAGE_EXTENSIONS.has(ext)) {\n    return \"image\";\n  }\n  if (VIDEO_EXTENSIONS.has(ext)) {\n    return \"video\";\n  }\n  if (AUDIO_EXTENSIONS.has(ext)) {\n    return \"audio\";\n  }\n  return \"file\";\n}\n\n// ─── Destination resolution ──────────────────────────────────────────────────\n\n/** Matches a path inside a content collection: `content/<collection>/…`. */\nconst CONTENT_ENTRY = /^content\\/([^/]+)\\//;\n\n/**\n * The directory an upload lands in when the caller doesn't name one. A document inside a content\n * collection gets `content/<collection>/images`; everything else gets `public`.\n */\nexport function uploadDirFor(documentPath: string | null): string {\n  const match = documentPath ? CONTENT_ENTRY.exec(documentPath.replaceAll(\"\\\\\", \"/\")) : null;\n  return match ? `content/${match[1]}/images` : \"public\";\n}\n\n/**\n * The reference to write into a document for a file at `destPath`.\n *\n * `public/` is served from the site root, so its contents get a root-relative `/name`. A content\n * asset is referenced relative to the entry that owns it (`./images/name`) so the collection loader\n * rewrites it to the asset mount. Anything else is project-root relative (`./dir/name`), which is\n * how the compiler resolves a non-`/` path.\n */\nexport function assetRef(destPath: string): string {\n  const path = destPath.replaceAll(\"\\\\\", \"/\");\n  if (path.startsWith(\"public/\")) {\n    return path.slice(\"public\".length);\n  }\n  const content = /^content\\/[^/]+\\/(.+)$/.exec(path);\n  if (content) {\n    return `./${content[1]}`;\n  }\n  return `./${path}`;\n}\n\n/**\n * A filename that doesn't collide with `taken`, suffixing `-1`, `-2`, … before the extension. Never\n * overwrites existing media (the previous behaviour clobbered silently).\n */\nexport function uniqueName(name: string, taken: ReadonlySet<string>): string {\n  if (!taken.has(name)) {\n    return name;\n  }\n  const ext = extensionOf(name);\n  const base = ext ? name.slice(0, -ext.length) : name;\n  for (let i = 1; ; i++) {\n    const candidate = `${base}-${i}${ext}`;\n    if (!taken.has(candidate)) {\n      return candidate;\n    }\n  }\n}\n\n/** Join a directory and a filename, treating `.` (project root) as no prefix. */\nexport function joinDir(dir: string, name: string): string {\n  const normalized = dir.replaceAll(\"\\\\\", \"/\").replace(/\\/+$/, \"\");\n  return normalized === \".\" || normalized === \"\" ? name : `${normalized}/${name}`;\n}\n\n// ─── Cache invalidation (injected) ───────────────────────────────────────────\n\n/**\n * Called after a batch of uploads with the directory they landed in. Injected from studio.ts so\n * this module doesn't import the media-picker / Manage / file-tree caches it needs to invalidate\n * (they all import from here) — the same injection pattern as the canvas host's drop handlers.\n */\nlet mediaChangedHandler: ((dir: string) => void | Promise<void>) | null = null;\n\n/** Register the post-upload cache invalidator (see {@link mediaChangedHandler}). */\nexport function setMediaChangedHandler(fn: ((dir: string) => void | Promise<void>) | null): void {\n  mediaChangedHandler = fn;\n}\n\n// ─── Upload ──────────────────────────────────────────────────────────────────\n\n/**\n * Upload files into the project and report what landed.\n *\n * `opts.dir` names the destination explicitly (the file tree's target folder, the Manage view's\n * active category); without it the destination follows the active document via {@link uploadDirFor}.\n * Names are made collision-free against a single listing of the destination. A file that fails to\n * upload is reported and skipped — the rest of the batch still lands.\n */\nexport async function uploadAssets(\n  files: Iterable<File>,\n  opts: { dir?: string } = {},\n): Promise<UploadedAsset[]> {\n  const list = [...files];\n  if (list.length === 0) {\n    return [];\n  }\n  const platform = getPlatform();\n  const dir = opts.dir ?? uploadDirFor(activeTab.value?.documentPath ?? null);\n\n  let taken: Set<string>;\n  try {\n    const existing = await platform.listDirectory(dir);\n    taken = new Set(existing.map((entry) => entry.name));\n  } catch {\n    taken = new Set(); // Directory doesn't exist yet — the backend mkdir -p's on write.\n  }\n\n  const uploaded: UploadedAsset[] = [];\n  for (const file of list) {\n    const name = uniqueName(file.name, taken);\n    taken.add(name);\n    const path = joinDir(dir, name);\n    try {\n      await platform.uploadFile(path, file);\n      uploaded.push({ kind: mediaKind(file), name, path, ref: assetRef(path) });\n    } catch (error) {\n      notify.error(`Could not upload ${file.name}.`, {\n        detail: errorMessage(error),\n        path,\n        source: \"Media\",\n      });\n    }\n  }\n\n  if (uploaded.length > 0) {\n    notify.success(\n      uploaded.length === 1\n        ? `Uploaded ${uploaded[0]!.name} to ${dir}/`\n        : `Uploaded ${uploaded.length} files to ${dir}/`,\n    );\n    await mediaChangedHandler?.(dir);\n  }\n  return uploaded;\n}\n",
-    "/** OXC code services (server-backed) */\n\nimport { getPlatform } from \"../platform\";\nimport { isJsonObject, paramNames } from \"@jxsuite/schema/guards\";\nimport { projectState } from \"../state\";\nimport { getNodeAtPath } from \"../store\";\nimport { loadedMonaco } from \"./monaco-lazy\";\nimport type { JxPath } from \"../state\";\nimport type { JxFunctionDef, JxMutableNode } from \"@jxsuite/schema/types\";\nimport type { editor } from \"monaco-editor\";\n\nexport interface OxLintDiagnostic {\n  severity: string;\n  message: string;\n  help?: string;\n  code?: string;\n  url?: string;\n  labels?: { span: { line: number; column: number; length?: number } }[];\n}\n\n/**\n * @param {string} action\n * @param {unknown} payload\n */\nexport async function codeService(action: string, payload: unknown) {\n  const platform = getPlatform();\n  if (!platform.codeService) {\n    return null;\n  }\n  return platform.codeService(action, payload);\n}\n\n/**\n * Ask the server to locate a document by filename within the project root.\n *\n * @param {string} name\n */\nexport async function locateDocument(name: string) {\n  const platform = getPlatform();\n  if (!platform.locateFile) {\n    return null;\n  }\n  return platform.locateFile(name);\n}\n\n/** Schema returned by a plugin's `$prototype` module (loose superset used across panels). */\nexport interface PluginSchema {\n  type?: string;\n  description?: string;\n  properties?: Record<string, unknown>;\n  required?: string[];\n  returns?: { type?: string };\n  [key: string]: unknown;\n}\n\n/** Cache of plugin schemas keyed by \"$src::$prototype\". */\nexport const pluginSchemaCache = new Map<string, PluginSchema | null>();\n\n/**\n * Fetch and cache the schema for a $prototype module via the server. Works for both external\n * prototypes (with $src) and prototypes resolved from project.json imports.\n *\n * @param {{ $src?: string; $prototype?: string }} def\n * @param {{ documentPath?: string }} state\n */\nexport async function fetchPluginSchema(\n  def: { $src?: string; $prototype?: string },\n  state: { documentPath?: string },\n) {\n  const importedPath = def.$prototype\n    ? projectState?.projectConfig?.imports?.[def.$prototype]\n    : null;\n  const src = def.$src || importedPath;\n  if (!src || !def.$prototype) {\n    return null;\n  }\n  const cacheKey = `${src}::${def.$prototype}`;\n  if (pluginSchemaCache.has(cacheKey)) {\n    return pluginSchemaCache.get(cacheKey);\n  }\n\n  try {\n    const platform = getPlatform();\n    if (!platform.fetchPluginSchema) {\n      pluginSchemaCache.set(cacheKey, null);\n      return null;\n    }\n    const base =\n      !importedPath && state.documentPath ? `${location.origin}/${state.documentPath}` : undefined;\n    const schema = (await platform.fetchPluginSchema(\n      src,\n      def.$prototype,\n      base,\n    )) as PluginSchema | null;\n    pluginSchemaCache.set(cacheKey, schema);\n    return schema;\n  } catch {\n    pluginSchemaCache.set(cacheKey, null);\n    return null;\n  }\n}\n\n/**\n * @param {import(\"monaco-editor\").editor.IStandaloneCodeEditor} editor\n * @param {OxLintDiagnostic[]} diagnostics\n */\nexport function setLintMarkers(\n  editor: editor.IStandaloneCodeEditor,\n  diagnostics: OxLintDiagnostic[],\n) {\n  const model = editor.getModel();\n  if (!model) {\n    return;\n  }\n  // Reachable only with a live editor in hand, so Monaco is already loaded.\n  const monaco = loadedMonaco();\n  if (!monaco) {\n    return;\n  }\n  const markers = diagnostics\n    .map((d) => {\n      const label = d.labels?.[0];\n      if (!label) {\n        return null;\n      }\n      const { line, column, length } = label.span;\n      return {\n        code: d.url ? { target: monaco.Uri.parse(d.url), value: d.code } : d.code,\n        endColumn: column + (length || 1),\n        endLineNumber: line,\n        message: d.message + (d.help ? `\\n${d.help}` : \"\"),\n        severity:\n          d.severity === \"error\" ? monaco.MarkerSeverity.Error : monaco.MarkerSeverity.Warning,\n        source: \"oxlint\",\n        startColumn: column,\n        startLineNumber: line,\n      };\n    })\n    .filter(Boolean);\n  monaco.editor.setModelMarkers(model, \"oxlint\", markers as editor.IMarkerData[]);\n}\n\n/**\n * @param {{ type: string; defName?: string; path?: JxPath; eventKey?: string }} editing\n * @param {JxMutableNode | null | undefined} document\n */\nexport function getFunctionArgs(\n  editing: { type: string; defName?: string; path?: JxPath; eventKey?: string },\n  document: JxMutableNode | null | undefined,\n): string[] {\n  // Read parameters off any object-shaped def (covers legacy entries without $prototype).\n  const fromDef = (def: unknown): string[] | null => {\n    if (!isJsonObject(def)) {\n      return null;\n    }\n    const params = def.parameters;\n    if (!Array.isArray(params) || params.length === 0) {\n      return null;\n    }\n    return paramNames(params as JxFunctionDef[\"parameters\"]);\n  };\n  if (editing.type === \"def\") {\n    const args = editing.defName ? fromDef(document?.state?.[editing.defName]) : null;\n    if (args) {\n      return args;\n    }\n  } else if (editing.type === \"event\") {\n    if (!document || !editing.path) {\n      return [\"state\", \"event\"];\n    }\n    const node = getNodeAtPath(document, editing.path);\n    const args = node && editing.eventKey ? fromDef(node[editing.eventKey]) : null;\n    if (args) {\n      return args;\n    }\n  }\n  return [\"state\", \"event\"];\n}\n",
-    "/**\n * Media path math — the file, the URL it is published at, and the shapes an author writes.\n *\n * One media file has up to three names, and they are not interchangeable:\n *\n * | name             | example                          | who writes it                      |\n * | ---------------- | -------------------------------- | ---------------------------------- |\n * | the FILE         | `public/hero.jpg`                | the file tree, `uploadAssets`      |\n * | the SITE URL     | `/hero.jpg`                      | the browser, a preview `<img src>` |\n * | the AUTHORED ref | `/hero.jpg`, `./images/hero.png` | the document on disk               |\n *\n * `public/` is served from the site root, so a document that uses `public/hero.jpg` says\n * `/hero.jpg` — a string that shares not one path segment with the file it names. A content entry\n * says `./images/hero.png` and the collection loader republishes it at the content type's asset\n * mount (specs/site-architecture.md §9.3), so the same file can also be named\n * `/content/blog/images/hero.png` when the collection's `source` is not already `content/blog`.\n *\n * **Why this module exists at all.** `findReferences` resolves each authored ref the way the\n * compiler does — rooted values against the project root, relative ones against the referencing\n * document — and compares the RESULT to the path it was asked about. Ask it about `public/hero.jpg`\n * and every `/hero.jpg` in the project resolves to `hero.jpg`, matches nothing, and the answer is a\n * confident zero. That is the exact shape of bug that makes a delete look safe: seven pages break\n * and the dialog says nothing else refers to it. {@link authoredRefTargets} is the fix — it\n * enumerates what an authored reference to this file RESOLVES to, so the query is keyed on the ref\n * as written rather than on the file as stored.\n *\n * Everything here is pure string math over project-relative, forward-slashed paths. The only input\n * from outside is the open project's content sections, read the same way `content-assets.ts` reads\n * them.\n *\n * @docs studio/projects/media\n */\n\nimport { contentMountFor } from \"../canvas/content-assets\";\nimport { projectState } from \"../store\";\nimport type { AssetMount } from \"@jxsuite/schema/asset-paths\";\nimport type { ContentSectionEntry } from \"../types\";\n\n/** The directory whose contents are served from the site root. */\nconst PUBLIC_DIR = \"public\";\n\n/**\n * A project-relative path in the one spelling every function here expects: forward slashes, no `./`\n * prefix, no leading `/`, no trailing `/`.\n */\nexport function normalizeProjectPath(path: string): string {\n  return path.replaceAll(\"\\\\\", \"/\").replace(/^\\.\\//, \"\").replace(/^\\/+/, \"\").replace(/\\/+$/, \"\");\n}\n\n/** The filename of a project-relative path. */\nexport function baseName(path: string): string {\n  const normalized = normalizeProjectPath(path);\n  const slash = normalized.lastIndexOf(\"/\");\n  return slash === -1 ? normalized : normalized.slice(slash + 1);\n}\n\n/** The directory of a project-relative path, or `\".\"` for a file at the project root. */\nexport function dirName(path: string): string {\n  const normalized = normalizeProjectPath(path);\n  const slash = normalized.lastIndexOf(\"/\");\n  return slash === -1 ? \".\" : normalized.slice(0, slash);\n}\n\n/** The open project's content sections, or null when no project (or no `content:`) is loaded. */\nfunction contentSections(): Record<string, ContentSectionEntry> | null {\n  const content = projectState?.projectConfig?.content;\n  return (content as Record<string, ContentSectionEntry> | undefined) ?? null;\n}\n\n/**\n * The mount that publishes `path`, or null when it is not inside a content collection.\n *\n * `contentMountFor` takes a DOCUMENT path, but the test it performs — which collection directory\n * contains this path — is exactly the one an asset needs, so the media file is passed straight in\n * rather than duplicating the loop.\n */\nfunction mountOf(path: string): AssetMount | null {\n  return contentMountFor(path, contentSections());\n}\n\n/**\n * The path a content-mounted file is published under, project-root-relative and WITHOUT the leading\n * slash — `content/blog/images/hero.png` for `posts/images/hero.png` mounted at `/content/blog`.\n *\n * Built by string surgery rather than through `assetUrlFor` on purpose: that function\n * percent-encodes each segment for use in an HTML attribute, and this value is compared against\n * paths resolved from raw document strings, which are never decoded on the way in.\n */\nfunction mountedPath(path: string, mount: AssetMount): string {\n  const prefix = normalizeProjectPath(mount.urlPrefix);\n  return `${prefix}/${path.slice(mount.dir.length + 1)}`;\n}\n\n/**\n * The site URL a media file is published at — what a preview `<img>` in panel chrome should load.\n *\n * `public/` contents are served from the root, a content asset from its collection's mount, and\n * anything else from its own project-relative path (which is what the dev server serves).\n */\nexport function mediaSiteUrl(path: string): string {\n  const normalized = normalizeProjectPath(path);\n  if (normalized.startsWith(`${PUBLIC_DIR}/`)) {\n    return `/${normalized.slice(PUBLIC_DIR.length + 1)}`;\n  }\n  const mount = mountOf(normalized);\n  return mount ? `/${mountedPath(normalized, mount)}` : `/${normalized}`;\n}\n\n/**\n * Every path an authored reference to this media file resolves to — the keys a usage query must ask\n * about, most literal first.\n *\n * 1. The file itself. A sibling's `./images/hero.png`, a rooted `/content/blog/images/hero.png` and a\n *    bare `assets/logo.svg` all land here.\n * 2. Its served path, for `public/` media. `/hero.jpg` resolves to `hero.jpg`, which is not a file on\n *    disk and does not need to be — the sweep compares resolved strings, and this is the string\n *    every reference to a public asset produces.\n * 3. Its asset-mount path, when a collection's `source` differs from its mount prefix. Identical to\n *    (1) for the ordinary `content/<type>/` layout, and deduplicated when it is.\n *\n * The list is a UNION and is deliberately generous: over-counting a reference makes a delete dialog\n * more alarming than it needs to be, while missing one makes it lie.\n */\nexport function authoredRefTargets(path: string): string[] {\n  const normalized = normalizeProjectPath(path);\n  if (normalized === \"\") {\n    return [];\n  }\n  const targets = [normalized];\n  if (normalized.startsWith(`${PUBLIC_DIR}/`)) {\n    targets.push(normalized.slice(PUBLIC_DIR.length + 1));\n  }\n  const mount = mountOf(normalized);\n  if (mount) {\n    const mounted = mountedPath(normalized, mount);\n    if (!targets.includes(mounted)) {\n      targets.push(mounted);\n    }\n  }\n  return targets;\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "058163B6A8C10B5864756E2164756E21",
-  "names": []
-}