@jxsuite/studio 2.4.2 → 3.0.0

package/src/settings/preferences-keymap.ts

@@ -34,12 +34,14 @@
  */
 
 import { normalizeChord, overlappingScopes, parseChord } from "../commands/keymap";
+import { SETTINGS } from "../services/settings/definitions";
+import { clearSettings, readStoredSetting, setSetting } from "../services/settings/kernel";
 import type { KeybindingOverrides } from "../commands/keymap";
 import type { KeyScope } from "../commands/levels";
 import type { AnyCommand, CommandRegistry } from "../commands/registry";
 
 /** Where the user's layer is kept. One key, one JSON object of `id → chords`. */
-export const KEYBINDINGS_STORAGE_KEY = "jx.keybindings";
+export const KEYBINDINGS_STORAGE_KEY = SETTINGS.keybindings.key;
 
 /** Keys that type nothing, and so may be bound without a modifier. */
 const UNMODIFIED_KEYS = new Set([
@@ -114,12 +116,7 @@ export function isBindableChord(chord: string): boolean {
 }
 
 function readRaw(): string {
-  try {
-    return globalThis.localStorage?.getItem(KEYBINDINGS_STORAGE_KEY) ?? "";
-  } catch {
-    // Storage unavailable (private mode): every command keeps the chord it declared.
-    return "";
-  }
+  return readStoredSetting(SETTINGS.keybindings);
 }
 
 /** Every chord in one stored entry, canonicalised — or `null` if any of them is not a chord. */
@@ -175,18 +172,11 @@ export function loadKeybindingOverrides(): Map<string, string[]> {
 }
 
 function store(layer: KeybindingOverrides): void {
-  try {
-    if (layer.size === 0) {
-      globalThis.localStorage?.removeItem(KEYBINDINGS_STORAGE_KEY);
-      return;
-    }
-    globalThis.localStorage?.setItem(
-      KEYBINDINGS_STORAGE_KEY,
-      JSON.stringify(Object.fromEntries(layer)),
-    );
-  } catch {
-    // Storage unavailable — the rebinding is live in this window and is not remembered.
+  if (layer.size === 0) {
+    clearSettings([SETTINGS.keybindings]);
+    return;
   }
+  setSetting(SETTINGS.keybindings, JSON.stringify(Object.fromEntries(layer)));
 }
 
 /**

package/src/settings/schema-field-ui.ts

@@ -5,7 +5,7 @@
  */
 
 import { html, nothing } from "lit-html";
-import { camelToLabel } from "../utils/studio-utils";
+import { camelToLabel, isMediaFormat } from "../utils/studio-utils";
 
 export interface SchemaProperty {
   type?: string;
@@ -483,7 +483,7 @@ export function yamlDefault(type: string, format?: string) {
   if (format === "date") {
     return new Date().toISOString().split("T")[0];
   }
-  if (format === "image") {
+  if (isMediaFormat(format)) {
     return '""';
   }
   switch (type) {

package/src/shell.ts

@@ -22,6 +22,8 @@
  */
 
 import { effect, effectScope, reactive } from "./reactivity";
+import { SETTINGS } from "./services/settings/definitions";
+import { readStoredSetting, setSetting } from "./services/settings/kernel";
 import { loadedMonaco } from "./services/monaco-lazy";
 import { applyStartupProfile } from "./services/profile";
 import { workspace } from "./workspace/workspace";
@@ -349,8 +351,6 @@ export interface ShellState {
 
 const DOCK_STORAGE_KEY = "jx-studio-panel-widths";
 
-const THEME_STORAGE_KEY = "jx-studio-theme";
-
 /**
  * The per-project record's key prefix — one namespaced record per project root (§4.4).
  *
@@ -378,14 +378,10 @@ function isChromeTheme(value: unknown): value is ChromeTheme {
   return typeof value === "string" && (CHROME_THEMES as readonly string[]).includes(value);
 }
 
-/** Read the persisted theme, falling back to {@link DEFAULT_THEME} on absent/corrupt storage. */
+/** Read the persisted theme, falling back to {@link DEFAULT_THEME} on an absent/unknown value. */
 function readPersistedTheme(): ChromeTheme {
-  try {
-    const stored = localStorage.getItem(THEME_STORAGE_KEY);
-    return isChromeTheme(stored) ? stored : DEFAULT_THEME;
-  } catch {
-    return DEFAULT_THEME;
-  }
+  const stored = readStoredSetting(SETTINGS.theme);
+  return isChromeTheme(stored) ? stored : DEFAULT_THEME;
 }
 
 export const DOCK_IDS: DockId[] = ["left", "right", "bottom"];
@@ -1168,11 +1164,7 @@ export function setChromeTheme(theme: ChromeTheme): void {
     return;
   }
   shell.theme = theme;
-  try {
-    localStorage.setItem(THEME_STORAGE_KEY, theme);
-  } catch {
-    // Storage full or unavailable — the theme is still applied, just not remembered.
-  }
+  setSetting(SETTINGS.theme, theme);
 }
 
 /**

package/src/studio.ts

@@ -204,7 +204,12 @@ import { initQuickSearch } from "./panels/quick-search";
 import { hydrateAccountStatus } from "./account-status";
 import { hydrateProjectList } from "./project-list";
 import { addRecentProject, hydrateRecentProjects, removeRecentProject } from "./recent-projects";
-import { hydrateSettings } from "./services/settings-store";
+import {
+  hydrateSettings,
+  onSettingsChanged,
+  settingsSettled,
+  watchRemoteSettings,
+} from "./services/settings/kernel";
 import { initWelcome } from "./panels/welcome-screen";
 import {
   openAddRepoModal,
@@ -1136,6 +1141,32 @@ void hydrateSettings().then(() => {
   render();
 });
 
+/*
+ * A setting changing repaints, wherever the change came from — this window's Preferences, or
+ * hydration landing after boot. Key-gated surfaces (the assistant's setup notice, the New Project
+ * gates, the Accounts list) read the store on the render path rather than caching a copy, so this
+ * one subscription is what keeps every one of them honest.
+ */
+onSettingsChanged(() => {
+  render();
+});
+
+/*
+ * Another window changing a setting is news this one wants. Nothing is lost without it — a patch
+ * cannot clobber a key it does not name — but a second window would otherwise show a provider that
+ * had been reconfigured somewhere else until it was restarted.
+ */
+watchRemoteSettings();
+
+/*
+ * Settings are written on a queue that coalesces a burst into one send, so a change made in the
+ * last moments before the window closes may still be in flight. Draining it here is the difference
+ * between "your provider was saved" and a settings file that never heard about it.
+ */
+globalThis.addEventListener("beforeunload", () => {
+  void settingsSettled();
+});
+
 // ─── Left panel: delegated to panels/left-panel.js ───────────────────────────
 
 function renderLeftPanel() {

package/src/types.ts

@@ -13,6 +13,7 @@ import type {
 
 import type {
   AppInfo,
+  AssetCapabilities,
   CfConnection,
   CodeServiceResult,
   ComponentMeta,
@@ -42,7 +43,9 @@ import type {
   RenameResult,
   SecretsSetRequest,
   SecretsSetResponse,
+  SettingsPatch,
   StarterInfo,
+  UploadResult,
 } from "@jxsuite/protocol";
 
 export type {
@@ -93,6 +96,7 @@ export type {
   SecretsListResponse,
   SecretsSetRequest,
   SecretsSetResponse,
+  SettingsPatch,
   StarterInfo,
 } from "@jxsuite/protocol";
 
@@ -200,6 +204,33 @@ export interface StudioPlatform {
    * trailing `/` is added: without it `new URL` drops the last segment.
    */
   documentBaseUrl?: string;
+  /**
+   * What the canvas ORIGIN answers for a SITE URL — and therefore how Studio must address media.
+   *
+   * `"site"` (the default when absent): the canvas origin already serves the published site URL
+   * space, so `/hero.jpg` and `/styles/main.css` resolve on their own and Studio touches neither.
+   * The dev server and the desktop loopback both do — `serveProjectFile` in `@jxsuite/server` IS
+   * that URL space — so neither declares anything here and both stay byte-identical.
+   *
+   * `"repo"`: the host serves PROJECT-RELATIVE paths under {@link documentBaseUrl}, and nothing
+   * answers the site URL space. Studio resolves each authored reference to the project file it
+   * names and rebases that path onto `documentBaseUrl`. Inert without one — a host that says its
+   * site URLs are wrong without saying what is right has told Studio nothing it can act on.
+   *
+   * This is about the ORIGIN, not the backend: a host whose files are perfectly reachable can still
+   * be `"repo"` space, because what decides it is what answers `GET /hero.jpg` on the document the
+   * canvas is running in.
+   */
+  assetSpace?: "site" | "repo";
+  /**
+   * What this backend will accept as an upload, when it says.
+   *
+   * Absent, or any field absent, means "no declared limit", and Studio must not invent one — a
+   * limit it made up is a file the user cannot upload for no reason anyone can name. A DECLARED
+   * limit is different: Studio refuses before spending the round trip and names the number in the
+   * refusal, and narrows the file picker's `accept` to match.
+   */
+  assetCapabilities?: AssetCapabilities;
   activate: (root?: string) => Promise<void>;
   openProject: () => Promise<{
     config: ProjectConfig;
@@ -224,7 +255,16 @@ export interface StudioPlatform {
   listDirectory: (dir: string) => Promise<DirEntry[]>;
   readFile: (path: string) => Promise<string>;
   writeFile: (path: string, content: string) => Promise<void>;
-  uploadFile: (path: string, data: string | File | Blob | ArrayBuffer) => Promise<unknown>;
+  /**
+   * Store bytes at a project path, and report where they really landed.
+   *
+   * The result's `path` is the ANSWER, not an echo: a backend may de-duplicate by content hash,
+   * append a collision suffix, or normalize a name, and the reference Studio writes into the
+   * document has to name what was actually written. This was `Promise<unknown>` and every caller
+   * used the REQUESTED path, so any such backend produced documents pointing at files that are not
+   * there.
+   */
+  uploadFile: (path: string, data: string | File | Blob | ArrayBuffer) => Promise<UploadResult>;
   deleteFile: (path: string) => Promise<void>;
   renameFile: (from: string, to: string) => Promise<RenameResult>;
   /**
@@ -508,8 +548,26 @@ export interface StudioPlatform {
    * settings live in localStorage only.
    */
   getSettings?: () => Promise<Record<string, string>>;
-  /** Persist the full user-level settings map to the backend store. */
-  saveSettings?: (settings: Record<string, string>) => Promise<void>;
+  /**
+   * Apply a set of changes to the backend store, and answer with the store as it then stands.
+   *
+   * A PATCH rather than the whole map, which is a correctness property and not an optimisation: a
+   * key named by neither `set` nor `remove` must be left exactly as it was found. Writing the whole
+   * map let any window overwrite the shared file with its own view of it, and on the chromium
+   * launcher every window is a separate process with a separate browser profile — so a window that
+   * held no settings could, and did, clear the credentials another window had just stored. It also
+   * preserves keys this build does not know: one written by a newer version, or by hand.
+   */
+  patchSettings?: (patch: SettingsPatch) => Promise<Record<string, string>>;
+  /**
+   * Be told when the backend store changes — by another window, or by hand. Returns the
+   * unsubscribe.
+   *
+   * Optional, and a display concern rather than a correctness one: `patchSettings` already stops a
+   * window from clobbering another's keys, so a platform without this leaves a second window
+   * showing a stale value until its next boot rather than losing anything.
+   */
+  subscribeSettings?: (handler: (settings: Record<string, string>) => void) => () => void;
 }
 
 // ─── Studio Types ───────────────────────────────────────────────────────────

package/src/ui/ai-credentials-form.ts

@@ -19,16 +19,15 @@
  */
 
 import { html, nothing } from "lit-html";
+import { live } from "lit-html/directives/live.js";
 import type { TemplateResult } from "lit-html";
-import { fetchAvailableModels, invalidateModelCache } from "../services/ai-models";
+import { fetchAvailableModels } from "../services/ai-models";
 import {
   getBaseUrl,
-  getModel,
   getOpenAiKey,
   hasOpenAiKey,
-  setBaseUrl,
-  setModel,
-  setOpenAiKey,
+  saveAiProvider,
+  storedModel,
 } from "../services/ai-settings";
 
 export interface AiCredentialsFormOptions {
@@ -64,11 +63,23 @@ export function createAiCredentialsForm(opts: AiCredentialsFormOptions): AiCrede
   let modelsLoading = false;
   let modelsError = "";
 
-  /** Open the form pre-filled with the current settings, and load the model list. */
-  function startEdit() {
+  /**
+   * Load the drafts from what is stored.
+   *
+   * The model comes from {@link storedModel} rather than `getModel()`, so a user who has never
+   * picked one drafts an empty field instead of the `"gpt-4o"` default. Saving a prefilled default
+   * writes a choice nobody made, and `jx.ai.model: "gpt-4o"` is exactly what a broken install was
+   * left holding.
+   */
+  function loadDrafts() {
     keyDraft = getOpenAiKey();
     baseUrlDraft = getBaseUrl();
-    modelDraft = getModel();
+    modelDraft = storedModel();
+  }
+
+  /** Open the form pre-filled with the current settings, and load the model list. */
+  function startEdit() {
+    loadDrafts();
     opts.requestRender();
     // Auto-fetch available models if not already loaded.
     if (availableModels.length === 0 && !modelsLoading) {
@@ -76,26 +87,33 @@ export function createAiCredentialsForm(opts: AiCredentialsFormOptions): AiCrede
     }
   }
 
-  /** Persist the drafted key + endpoint + model and notify the host. */
+  /**
+   * Persist the drafted key + endpoint + model and notify the host.
+   *
+   * **Re-seeds the drafts; it must never blank them.** Preferences is a place rather than a wizard
+   * step, so the sheet stays open across Save and `startEdit` is not called again — which meant
+   * every field emptied the instant a save succeeded. That reads as "it didn't take", and the
+   * obvious response to it destroyed the credentials: a blank draft is what
+   * `setOpenAiKey`/`setBaseUrl` treat as _clear_, so pressing Save a second time on the emptied
+   * form deleted the key and endpoint that the first press had just stored. Reading back through
+   * the getters also shows what was actually kept — trimmed, and with the endpoint's trailing slash
+   * stripped — rather than what was typed.
+   */
   function save() {
-    setOpenAiKey(keyDraft);
-    setBaseUrl(baseUrlDraft);
-    setModel(modelDraft);
-    keyDraft = "";
-    baseUrlDraft = "";
-    modelDraft = "";
-    // Clear fetched models so they're re-fetched with the new credentials next time.
-    availableModels = [];
-    invalidateModelCache();
+    saveAiProvider({ apiKey: keyDraft, baseUrl: baseUrlDraft, model: modelDraft });
+    loadDrafts();
+    modelsError = "";
+    /* The fetched list stays: it was listed under exactly these credentials, and dropping it
+       collapsed the model combobox back to a free-text field on every save. The module cache is
+       dropped by ai-models' own settings subscription, so this form does not have to remember to. */
     opts.onSaved?.();
     opts.requestRender();
   }
 
   /** Dismiss the form without saving (only offered when a key already exists). */
   function cancel() {
-    keyDraft = "";
-    baseUrlDraft = "";
-    modelDraft = "";
+    loadDrafts();
+    modelsError = "";
     opts.onCancel?.();
     opts.requestRender();
   }
@@ -104,6 +122,11 @@ export function createAiCredentialsForm(opts: AiCredentialsFormOptions): AiCrede
    * Fetch available models via src/services/ai-models.ts, preferring the in-form drafts over the
    * stored settings so the list reflects the credentials being edited. Always forces past the
    * module cache — this runs on explicit user action (or first open) with possibly-new drafts.
+   *
+   * Both lines below read draft-first. The key used to read stored-first, against this paragraph
+   * and against the line beside it: editing a key in place and pressing Fetch models listed the OLD
+   * key's models, and — worse — a form whose drafts had been blanked still fetched successfully
+   * from storage, which is what made an emptied form look like it was working.
    */
   async function fetchModels() {
     modelsLoading = true;
@@ -111,8 +134,10 @@ export function createAiCredentialsForm(opts: AiCredentialsFormOptions): AiCrede
     opts.requestRender();
     try {
       availableModels = await fetchAvailableModels({
-        apiKey: getOpenAiKey() || keyDraft,
-        baseUrl: baseUrlDraft || getBaseUrl(),
+        credentials: {
+          apiKey: keyDraft || getOpenAiKey(),
+          baseUrl: baseUrlDraft || getBaseUrl(),
+        },
         force: true,
       });
     } catch (error: unknown) {
@@ -144,7 +169,7 @@ export function createAiCredentialsForm(opts: AiCredentialsFormOptions): AiCrede
           type="password"
           size="s"
           placeholder="sk-… or any compatible key"
-          .value=${keyDraft}
+          .value=${live(keyDraft)}
           @input=${(e: Event) => {
             keyDraft = (e.target as HTMLInputElement).value;
           }}
@@ -157,7 +182,7 @@ export function createAiCredentialsForm(opts: AiCredentialsFormOptions): AiCrede
                   class="ai-creds-field"
                   size="s"
                   allows-custom-value
-                  .value=${modelDraft}
+                  .value=${live(modelDraft)}
                   @change=${(e: Event) => {
                     modelDraft = (e.target as HTMLInputElement).value;
                   }}
@@ -175,7 +200,7 @@ export function createAiCredentialsForm(opts: AiCredentialsFormOptions): AiCrede
                   class="ai-creds-field"
                   size="s"
                   placeholder="Model ID (e.g. gpt-4o, claude-sonnet-4-20250514, etc.)"
-                  .value=${modelDraft}
+                  .value=${live(modelDraft)}
                   @input=${(e: Event) => {
                     modelDraft = (e.target as HTMLInputElement).value;
                   }}
@@ -198,7 +223,7 @@ export function createAiCredentialsForm(opts: AiCredentialsFormOptions): AiCrede
           class="ai-creds-field"
           size="s"
           placeholder="Endpoint (optional, e.g. http://localhost:11434/v1)"
-          .value=${baseUrlDraft}
+          .value=${live(baseUrlDraft)}
           @input=${(e: Event) => {
             baseUrlDraft = (e.target as HTMLInputElement).value;
           }}

package/src/ui/media-picker.ts

@@ -26,12 +26,11 @@ import { debouncedStyleCommit, renderOnly } from "../store";
 import { getLayerSlot, popoverLayerFor } from "./layers";
 import type { LayerKind } from "./layers";
 import { rectOf } from "../utils/geometry";
-import { loopbackAssetSrc } from "../canvas/canvas-origin";
-import { previewAssetSrc } from "../canvas/content-assets";
+import { previewAssetSrc } from "../canvas/asset-refs";
 import {
   IMAGE_EXTENSIONS,
   MEDIA_EXTENSIONS,
-  UPLOAD_ACCEPT,
+  uploadAccept,
   extensionOf,
   uploadAssets,
 } from "../files/media-upload";
@@ -42,7 +41,7 @@ import {
   recordImageSize,
   seedMediaMeta,
 } from "../files/media-meta";
-import { mediaSiteUrl } from "../files/media-paths";
+import { mediaSiteUrl, previewFileSrc } from "../files/media-paths";
 
 // ─── Media file cache ────────────────────────────────────────────────────────
 
@@ -283,7 +282,7 @@ function renderMediaPickerPopover() {
                         m.isImage
                           ? html`<img
                               slot="icon"
-                              src=${loopbackAssetSrc(m.path)}
+                              src=${previewFileSrc(m.file)}
                               alt=""
                               style="width:24px;height:24px;object-fit:cover;border-radius:var(--spectrum-corner-radius-75, 2px)"
                               @load=${(e: Event) => noteImageSize(m.file, e.target)}
@@ -394,7 +393,7 @@ function pickAndUpload(onCommit: (val: string) => void) {
   const input = document.createElement("input");
   input.type = "file";
   input.multiple = true;
-  input.accept = UPLOAD_ACCEPT;
+  input.accept = uploadAccept();
   input.addEventListener("change", () => {
     if (input.files?.length) {
       void uploadAndAssign(input.files, onCommit);
@@ -422,11 +421,7 @@ export function renderMediaPicker(prop: string, value: string, onCommit: (val: s
     <div class="media-picker">
       ${
         isImage && currentValue
-          ? html`<img
-              class="media-picker-thumb"
-              src=${loopbackAssetSrc(previewAssetSrc(currentValue))}
-              alt=""
-            />`
+          ? html`<img class="media-picker-thumb" src=${previewAssetSrc(currentValue)} alt="" />`
           : nothing
       }
       <sp-textfield

package/src/utils/studio-utils.ts

@@ -117,6 +117,35 @@ export function abbreviateValue(val: string) {
   return map[val] || val;
 }
 
+/**
+ * The placeholder a content type's `source` may carry to say "one directory per locale".
+ *
+ * Held here rather than imported out of the parser extension's content loader ({@link
+ * file://../../../../extensions/parser/src/content-loader.ts}): that module reads the filesystem
+ * and this one runs in a browser. It is also an extension, and core may not import one.
+ */
+const LOCALE_PLACEHOLDER = "{locale}";
+
+/**
+ * True when a schema `format` names a MEDIA reference.
+ *
+ * Two spellings, and both are real. `"uri-reference"` is JSON Schema's own and the one the spec
+ * uses — it is what the content loader keys its asset rewrite on (`rewriteEntryAssets`) and what a
+ * schema written against the documentation says. `"image"` is Studio's own shorthand, used by
+ * component props and settings schemas.
+ *
+ * They were accepted in different places, so which editor a field got depended on which panel was
+ * asking: `inferInputType` took both, the frontmatter panel took only `"image"`, and the drop
+ * target, the signals panel and the data grid each took only one. One predicate, so a field is a
+ * media field everywhere or nowhere.
+ *
+ * @param {unknown} format - A schema entry's `format`
+ * @returns {boolean}
+ */
+export function isMediaFormat(format: unknown): boolean {
+  return format === "image" || format === "uri-reference";
+}
+
 /**
  * Determine input widget type from a css-meta entry
  *
@@ -136,7 +165,7 @@ export function inferInputType(entry: Record<string, unknown>) {
   if (entry.format === "color") {
     return "color";
   }
-  if (entry.format === "uri-reference") {
+  if (isMediaFormat(entry.format)) {
     return "media";
   }
   if (entry.$units !== undefined) {
@@ -179,7 +208,7 @@ export function findContentTypeSchema(
       continue;
     }
     const src = def.source.replace(/^\.\//, "").replace(/\/$/, "");
-    const hasExt = src.includes(".") && !src.endsWith("/");
+    const hasExt = src.includes(".") && !src.endsWith("/") && !src.includes(LOCALE_PLACEHOLDER);
     if (hasExt) {
       if (docPath === src || docPath.endsWith(`/${src}`)) {
         return { name, schema: def.schema };
@@ -191,7 +220,20 @@ export function findContentTypeSchema(
           : (formatByName(def.format)?.extensions[0] ??
             defaultContentFormat()?.extensions[0] ??
             ".json");
-      if (docPath.startsWith(`${src}/`) && docPath.endsWith(ext)) {
+      /* A localized source is N directories, one content type: `content/posts/{locale}` matches
+         `content/posts/fr/hello.md` and carries the SAME schema, because a translation is the same
+         post. Without this the placeholder was compared literally, matched no path anybody has, and
+         a translated entry showed no frontmatter fields at all. */
+      const prefix = src.includes(LOCALE_PLACEHOLDER)
+        ? new RegExp(
+            `^${src
+              .split(LOCALE_PLACEHOLDER)
+              .map((part) => part.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`))
+              .join("[^/]+")}/`,
+          )
+        : null;
+      const matches = prefix ? prefix.test(docPath) : docPath.startsWith(`${src}/`);
+      if (matches && docPath.endsWith(ext)) {
         return { name, schema: def.schema };
       }
     }

package/dist/chunks/studio-a7pzveq1.js

@@ -1,110 +0,0 @@
-import {
-  getPlatform,
-  hasPlatform
-} from "./studio-sas7mt3k.js";
-
-// src/services/settings-store.ts
-var PERSISTED_SETTINGS_KEYS = [
-  "jx.ai.openaiKey",
-  "jx.ai.baseUrl",
-  "jx.ai.model",
-  "jx.cf.token",
-  "jx.cf.accountId"
-];
-function readLocal(key) {
-  try {
-    return globalThis.localStorage?.getItem(key) ?? "";
-  } catch {
-    return "";
-  }
-}
-async function hydrateSettings() {
-  if (!hasPlatform()) {
-    return;
-  }
-  const platform = getPlatform();
-  if (!platform.getSettings) {
-    return;
-  }
-  let stored;
-  try {
-    stored = await platform.getSettings();
-  } catch {
-    return;
-  }
-  const merged = { ...stored };
-  let needsMigration = false;
-  for (const key of PERSISTED_SETTINGS_KEYS) {
-    const backendValue = stored[key];
-    if (backendValue) {
-      try {
-        globalThis.localStorage?.setItem(key, backendValue);
-      } catch {}
-    } else {
-      const localValue = readLocal(key);
-      if (localValue) {
-        merged[key] = localValue;
-        needsMigration = true;
-      }
-    }
-  }
-  if (needsMigration && platform.saveSettings) {
-    platform.saveSettings(merged).catch(() => {});
-  }
-}
-function persistSettings() {
-  if (!hasPlatform()) {
-    return;
-  }
-  const platform = getPlatform();
-  if (!platform.saveSettings) {
-    return;
-  }
-  const settings = {};
-  for (const key of PERSISTED_SETTINGS_KEYS) {
-    const value = readLocal(key);
-    if (value) {
-      settings[key] = value;
-    }
-  }
-  platform.saveSettings(settings).catch(() => {});
-}
-
-// src/services/cf-settings.ts
-var TOKEN_STORAGE = "jx.cf.token";
-var ACCOUNT_STORAGE = "jx.cf.accountId";
-function read(key) {
-  try {
-    return globalThis.localStorage?.getItem(key) ?? "";
-  } catch {
-    return "";
-  }
-}
-function write(key, value) {
-  try {
-    const trimmed = (value || "").trim();
-    if (trimmed) {
-      globalThis.localStorage?.setItem(key, trimmed);
-    } else {
-      globalThis.localStorage?.removeItem(key);
-    }
-  } catch {}
-  persistSettings();
-}
-function getCfToken() {
-  return read(TOKEN_STORAGE);
-}
-function setCfToken(token) {
-  write(TOKEN_STORAGE, token);
-}
-function getCfAccountId() {
-  return read(ACCOUNT_STORAGE);
-}
-function setCfAccountId(accountId) {
-  write(ACCOUNT_STORAGE, accountId);
-}
-
-export { hydrateSettings, persistSettings, getCfToken, setCfToken, getCfAccountId, setCfAccountId };
-
-//# debugId=521A72F1905394A564756E2164756E21
-//# sourceMappingURL=studio-a7pzveq1.js.map