@fias/arche-sdk 2.27.0 → 2.29.0

package/dist/index.mjs

@@ -273,6 +273,8 @@ var FiasBridge = class {
     this.vendoredAssets = null;
     this.textModels = null;
     this.textModelListeners = /* @__PURE__ */ new Set();
+    this.holder = null;
+    this.holderListeners = /* @__PURE__ */ new Set();
     this.currentPath = "";
     this.hostOrigin = "";
     this.themeListeners = /* @__PURE__ */ new Set();
@@ -327,12 +329,16 @@ var FiasBridge = class {
         this.theme = mergeThemeWithDefaults(initMsg.payload.theme);
         this.vendoredAssets = initMsg.payload.vendoredAssets ?? null;
         this.textModels = initMsg.payload.textModels ?? null;
+        this.holder = initMsg.payload.holder ?? null;
         this.currentPath = initMsg.payload.currentPath;
         this.initialized = true;
         this.initResolve?.();
         for (const listener of this.navigationListeners) {
           listener(this.currentPath);
         }
+        for (const listener of this.holderListeners) {
+          listener(this.holder);
+        }
         return;
       }
       if (this.hostOrigin && event.origin !== this.hostOrigin) return;
@@ -593,6 +599,19 @@ var FiasBridge = class {
   getTextModels() {
     return this.textModels;
   }
+  /**
+   * The workspace the plugin was opened in, or null before init, without
+   * `user:profile:read` / `data:workspace`, or from an older host. Fixed for
+   * the life of the plugin. See `useFiasHolder`.
+   */
+  getHolder() {
+    return this.holder;
+  }
+  /** Called once, when init delivers the holder. */
+  onHolderReady(listener) {
+    this.holderListeners.add(listener);
+    return () => this.holderListeners.delete(listener);
+  }
   onTextModelsUpdate(listener) {
     this.textModelListeners.add(listener);
     return () => this.textModelListeners.delete(listener);
@@ -725,6 +744,7 @@ var FiasBridge = class {
     this.pendingRequests.clear();
     this.themeListeners.clear();
     this.textModelListeners.clear();
+    this.holderListeners.clear();
     this.navigationListeners.clear();
     this.stepNavigationListeners.clear();
     this.previewStateProviders.clear();
@@ -1071,14 +1091,40 @@ var VAULT_ARCHE_DOCUMENTS_ENTITY_ID = "ent_intg_vault_arche_docs_000000";
 var COMMUNITY_ASSETS_ENTITY_ID = "ent_intg_community_assets_000000";
 var DOCUMENT_SIGN_ENTITY_ID = "ent_intg_document_sign_000000000";
 var COMPANY_EMAIL_SEND_ENTITY_ID = "ent_intg_company_email_send_0000";
+var CONNECTIONS_ENTITY_ID = "ent_intg_connections_00000000000";
+var CONNECTIONS_CONNECT_ENTITY_ID = "ent_intg_connections_connect_000";
+var X_ENTITY_ID = "ent_intg_twitter_000000000000000";
+var LINKEDIN_ENTITY_ID = "ent_intg_linkedin_00000000000000";
+var ACTION_CONFIRMATION_ENTITY_ID = "ent_intg_action_confirmation_000";
+var SCHEDULED_INVOCATIONS_ENTITY_ID = "ent_intg_scheduled_invocations00";
+var CONFIRM_TIMEOUT_MS = 10 * 60 * 1e3;
+var APPROVED_CALL_TIMEOUT_MS = 2 * 60 * 1e3;
 var COMMUNITY_ASSET_MAX_URL_BATCH = 50;
 var COMMUNITY_ASSET_MAX_PUBLISH_BATCH = 20;
 async function invokeEntityOp(bridge, entityId, op, args = {}) {
-  const res = await bridge.request("entity_invoke", {
-    entityId,
-    payload: { op, ...args }
-  });
-  return res.output;
+  const payload = { op, ...args };
+  const res = await bridge.request("entity_invoke", { entityId, payload });
+  if (!res.confirmationRequired) return res.output;
+  return confirmAndResend(bridge, entityId, payload, res.confirmationRequired.pendingActionId);
+}
+async function confirmAndResend(bridge, entityId, payload, pendingActionId) {
+  const answer = await bridge.request(
+    "client_entity_invoke",
+    { entityId: ACTION_CONFIRMATION_ENTITY_ID, input: { pendingActionId } },
+    CONFIRM_TIMEOUT_MS
+  );
+  if (answer && "error" in answer) {
+    throw new FiasBridgeError(answer.error.message, answer.error.code);
+  }
+  if (!answer?.approved) {
+    throw new FiasBridgeError("The person declined this action", "USER_DECLINED");
+  }
+  const done = await bridge.request(
+    "entity_invoke",
+    { entityId, payload, pendingActionId },
+    APPROVED_CALL_TIMEOUT_MS
+  );
+  return done.output;
 }
 async function invokeStoreOp(bridge, op, args = {}) {
   return bridge.request("entity_invoke", {
@@ -1259,6 +1305,15 @@ function useTextModels() {
   }, [bridge]);
   return models;
 }
+function useFiasHolder() {
+  const bridge = useBridge();
+  const [holder, setHolder] = useState2(bridge.getHolder());
+  useEffect2(() => {
+    setHolder(bridge.getHolder());
+    return bridge.onHolderReady(setHolder);
+  }, [bridge]);
+  return holder;
+}
 var IMAGE_GENERATE_TIMEOUT_MS = 32e4;
 function useImageGeneration() {
   const bridge = useBridge();
@@ -1763,6 +1818,15 @@ function useFiasWorkspaces() {
     },
     [bridge]
   );
+  const openForWorkspace = useCallback(async () => {
+    const res = await invokeEntityOp(
+      bridge,
+      PLUGIN_WORKSPACES_ENTITY_ID,
+      "create",
+      { forActingHolder: true }
+    );
+    return res.workspace;
+  }, [bridge]);
   const list = useCallback(async () => {
     const res = await invokeEntityOp(
       bridge,
@@ -1840,8 +1904,28 @@ function useFiasWorkspaces() {
     [bridge]
   );
   return useMemo2(
-    () => ({ create, list, get, archive, listMembers, addMember, updateMember, removeMember }),
-    [create, list, get, archive, listMembers, addMember, updateMember, removeMember]
+    () => ({
+      create,
+      openForWorkspace,
+      list,
+      get,
+      archive,
+      listMembers,
+      addMember,
+      updateMember,
+      removeMember
+    }),
+    [
+      create,
+      openForWorkspace,
+      list,
+      get,
+      archive,
+      listMembers,
+      addMember,
+      updateMember,
+      removeMember
+    ]
   );
 }
 function useFiasStore() {
@@ -2240,7 +2324,8 @@ function useArcheAssets() {
       return bridge.request("arche_assets_list", {
         cursor: options?.cursor,
         limit: options?.limit,
-        tags: options?.tags
+        tags: options?.tags,
+        kinds: options?.kinds
       });
     },
     [bridge]
@@ -2249,7 +2334,8 @@ function useArcheAssets() {
     async (options) => {
       return bridge.request("arche_assets_index", {
         tags: options?.tags,
-        groupBy: options?.groupBy
+        groupBy: options?.groupBy,
+        kinds: options?.kinds
       });
     },
     [bridge]
@@ -2262,7 +2348,327 @@ function useArcheAssets() {
   );
   return useMemo2(() => ({ list, index, getUrl }), [list, index, getUrl]);
 }
+function useArcheAssetBytes() {
+  const bridge = useBridge();
+  const getBytes = useCallback(
+    async (asset) => {
+      let ref;
+      if (typeof asset === "string") {
+        try {
+          ref = await bridge.request("arche_assets_get_url", { assetId: asset });
+        } catch (err) {
+          throw toArcheAssetError(err);
+        }
+      } else {
+        ref = asset;
+      }
+      return enqueueAssetByteRead(bridge, ref);
+    },
+    [bridge]
+  );
+  const getMany = useCallback(
+    async (assets) => {
+      const read = await readAssetBytesBatch(bridge, assets);
+      const out = {};
+      for (const [assetId, result] of read) out[assetId] = result;
+      return out;
+    },
+    [bridge]
+  );
+  return useMemo2(() => ({ getBytes, getMany }), [getBytes, getMany]);
+}
+var ARCHE_ASSET_BYTES_ENTITY_ID = "ent_intg_arche_asset_bytes_00000";
+var ArcheAssetError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "ArcheAssetError";
+  }
+};
+var ASSET_URL_MIN_REMAINING_SECONDS = 30;
+var ASSET_BYTES_MAX_URLS_PER_CALL = 100;
+var ASSET_URL_MAX_REFRESHES_PER_BATCH = 10;
+async function readSignedUrls(bridge, signedUrls) {
+  let response;
+  try {
+    response = await bridge.request(
+      "client_entity_invoke",
+      { entityId: ARCHE_ASSET_BYTES_ENTITY_ID, input: { verb: "read", signedUrls } },
+      CLIENT_ENTITY_INVOKE_TIMEOUT_MS
+    );
+  } catch (err) {
+    throw toArcheAssetError(err);
+  }
+  if ("error" in response) {
+    throw new ArcheAssetError(response.error.message, response.error.code);
+  }
+  return response.results;
+}
+function fileError(result) {
+  return result && "error" in result ? new ArcheAssetError(result.error.message, result.error.code) : new ArcheAssetError("the asset could not be read", "ASSET_UNAVAILABLE");
+}
+async function readInBatches(bridge, items, out) {
+  const lapsed = [];
+  let queue = items;
+  while (queue.length > 0) {
+    const overBudget = [];
+    let readCount = 0;
+    for (let at = 0; at < queue.length; at += ASSET_BYTES_MAX_URLS_PER_CALL) {
+      const chunk = queue.slice(at, at + ASSET_BYTES_MAX_URLS_PER_CALL);
+      const results = await readSignedUrls(
+        bridge,
+        chunk.map((item) => item.signedUrl)
+      );
+      chunk.forEach((item, i) => {
+        const result = results[i];
+        if (result && !("error" in result)) {
+          out.set(item.assetId, result);
+          readCount += 1;
+        } else if (result?.error.code === "ASSET_URL_EXPIRED" && !item.refreshed) {
+          lapsed.push(item);
+        } else if (result?.error.code === "ASSET_TOO_LARGE" && chunk.length > 1) {
+          overBudget.push(item);
+        } else {
+          out.set(item.assetId, fileError(result));
+        }
+      });
+    }
+    if (readCount === 0) {
+      for (const item of overBudget) {
+        out.set(
+          item.assetId,
+          new ArcheAssetError("the asset is too large to read", "ASSET_TOO_LARGE")
+        );
+      }
+      break;
+    }
+    queue = overBudget;
+  }
+  return lapsed;
+}
+async function readAssetBytesBatch(bridge, refs) {
+  const out = /* @__PURE__ */ new Map();
+  let refreshesLeft = ASSET_URL_MAX_REFRESHES_PER_BATCH;
+  const refresh = async (assetIds) => {
+    const fresh = [];
+    for (const assetId of assetIds) {
+      if (refreshesLeft <= 0) {
+        out.set(
+          assetId,
+          new ArcheAssetError(
+            "the asset URL has expired; list the assets again for fresh URLs",
+            "ASSET_URL_EXPIRED"
+          )
+        );
+        continue;
+      }
+      refreshesLeft -= 1;
+      try {
+        const asset = await bridge.request("arche_assets_get_url", { assetId });
+        fresh.push({ assetId, signedUrl: asset.signedUrl, refreshed: true });
+      } catch (err) {
+        out.set(assetId, toArcheAssetError(err));
+      }
+    }
+    return fresh;
+  };
+  const unique = /* @__PURE__ */ new Map();
+  for (const ref of refs) if (!unique.has(ref.assetId)) unique.set(ref.assetId, ref);
+  const nowSeconds = Date.now() / 1e3;
+  const reusable = [];
+  const stale = [];
+  for (const ref of unique.values()) {
+    if (ref.expiresAt - nowSeconds > ASSET_URL_MIN_REMAINING_SECONDS) {
+      reusable.push({ assetId: ref.assetId, signedUrl: ref.signedUrl, refreshed: false });
+    } else {
+      stale.push(ref.assetId);
+    }
+  }
+  const pending = [...reusable, ...await refresh(stale)];
+  const lapsed = await readInBatches(bridge, pending, out);
+  if (lapsed.length > 0) {
+    await readInBatches(bridge, await refresh(lapsed.map((item) => item.assetId)), out);
+  }
+  return out;
+}
+var pendingAssetByteReads = /* @__PURE__ */ new WeakMap();
+function enqueueAssetByteRead(bridge, ref) {
+  let batch = pendingAssetByteReads.get(bridge);
+  if (!batch) {
+    const created = { refs: [], waiters: [] };
+    pendingAssetByteReads.set(bridge, created);
+    batch = created;
+    void Promise.resolve().then(() => flushAssetByteReads(bridge, created));
+  }
+  batch.refs.push(ref);
+  const queued = batch;
+  return new Promise((resolve, reject) => {
+    queued.waiters.push({ assetId: ref.assetId, resolve, reject });
+  });
+}
+async function flushAssetByteReads(bridge, batch) {
+  pendingAssetByteReads.delete(bridge);
+  let results;
+  try {
+    results = await readAssetBytesBatch(bridge, batch.refs);
+  } catch (err) {
+    const failure = toArcheAssetError(err);
+    for (const waiter of batch.waiters) waiter.reject(failure);
+    return;
+  }
+  const handedOut = /* @__PURE__ */ new Set();
+  for (const waiter of batch.waiters) {
+    const result = results.get(waiter.assetId) ?? new ArcheAssetError("the asset could not be read", "ASSET_UNAVAILABLE");
+    if (result instanceof ArcheAssetError) {
+      waiter.reject(result);
+    } else if (handedOut.has(waiter.assetId)) {
+      waiter.resolve({ ...result, bytes: result.bytes.slice(0) });
+    } else {
+      handedOut.add(waiter.assetId);
+      waiter.resolve(result);
+    }
+  }
+}
+function toArcheAssetError(err) {
+  if (err instanceof ArcheAssetError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  const code = err?.code;
+  if (/permission denied/i.test(message)) {
+    return new ArcheAssetError(
+      `${message} \u2014 useArcheAssetBytes needs both "assets:read" and "entities:client_invoke" in fias-plugin.json`,
+      "PERMISSION_DENIED"
+    );
+  }
+  if (code === "RATE_LIMITED" || code === "RATE_LIMIT" || /rate limit/i.test(message)) {
+    return new ArcheAssetError(message, "RATE_LIMIT");
+  }
+  if (/rapid-fire loop|runaway loop/i.test(message)) {
+    return new ArcheAssetError(
+      `${message} Load many assets with useArcheAssetBytes().getMany(entries) \u2014 one call per 100.`,
+      "RATE_LIMIT"
+    );
+  }
+  return new ArcheAssetError(message, "ASSET_UNAVAILABLE");
+}
 var PLUGIN_CONTENT_ENTITY_ID = "ent_intg_plugin_content_00000000";
+var PLUGIN_LOCAL_STORE_ENTITY_ID = "ent_intg_plugin_local_store_0000";
+var FiasLocalStoreError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "FiasLocalStoreError";
+  }
+};
+function toLocalStoreError(err) {
+  if (err instanceof FiasLocalStoreError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  const raw = err?.code;
+  const code = raw === "PERMISSION_DENIED" || /permission denied/i.test(message) ? "PERMISSION_DENIED" : raw === "RATE_LIMIT" || raw === "RATE_LIMITED" || /rate limit/i.test(message) ? "RATE_LIMIT" : "LOCAL_STORE_UNAVAILABLE";
+  return new FiasLocalStoreError(message, code);
+}
+function useLocalStore() {
+  const bridge = useBridge();
+  const call = useCallback(
+    async (input) => {
+      let response;
+      try {
+        response = await bridge.request(
+          "client_entity_invoke",
+          { entityId: PLUGIN_LOCAL_STORE_ENTITY_ID, input },
+          CLIENT_ENTITY_INVOKE_TIMEOUT_MS
+        );
+      } catch (err) {
+        throw toLocalStoreError(err);
+      }
+      if (response?.error) {
+        throw new FiasLocalStoreError(response.error.message, response.error.code);
+      }
+      return response ?? {};
+    },
+    [bridge]
+  );
+  const get = useCallback(
+    async (key) => (await call({ verb: "get", key })).entry ?? null,
+    [call]
+  );
+  const getText = useCallback(
+    async (key) => {
+      const entry = await get(key);
+      if (!entry) return null;
+      if (typeof entry.value !== "string") {
+        throw new FiasLocalStoreError(`"${key}" does not hold text`, "LOCAL_STORE_WRONG_KIND");
+      }
+      return entry.value;
+    },
+    [get]
+  );
+  const getBytes = useCallback(
+    async (key) => {
+      const entry = await get(key);
+      if (!entry) return null;
+      if (!(entry.value instanceof ArrayBuffer)) {
+        throw new FiasLocalStoreError(`"${key}" does not hold bytes`, "LOCAL_STORE_WRONG_KIND");
+      }
+      return entry.value;
+    },
+    [get]
+  );
+  const getJson = useCallback(
+    async (key) => {
+      const entry = await get(key);
+      if (!entry) return null;
+      if (entry.value instanceof ArrayBuffer) {
+        throw new FiasLocalStoreError(`"${key}" holds bytes, not JSON`, "LOCAL_STORE_WRONG_KIND");
+      }
+      if (typeof entry.value === "string") {
+        try {
+          return JSON.parse(entry.value);
+        } catch {
+          throw new FiasLocalStoreError(
+            `"${key}" holds text that is not JSON`,
+            "LOCAL_STORE_WRONG_KIND"
+          );
+        }
+      }
+      return entry.value;
+    },
+    [get]
+  );
+  const getMany = useCallback(
+    async (keys) => (await call({ verb: "get_many", keys })).entries ?? [],
+    [call]
+  );
+  const put = useCallback(
+    async (key, value) => ({
+      sizeBytes: (await call({ verb: "put", key, value })).sizeBytes ?? 0
+    }),
+    [call]
+  );
+  const del = useCallback(
+    async (key) => {
+      await call({ verb: "delete", key });
+    },
+    [call]
+  );
+  const list = useCallback(
+    async (prefix) => (await call({ verb: "list", ...prefix !== void 0 ? { prefix } : {} })).entries ?? [],
+    [call]
+  );
+  const clear = useCallback(
+    async () => ({
+      deleted: (await call({ verb: "clear" })).deleted ?? 0
+    }),
+    [call]
+  );
+  const estimate = useCallback(async () => {
+    const res = await call({ verb: "estimate" });
+    return { usedBytes: res.usedBytes ?? 0, budgetBytes: res.budgetBytes ?? 0 };
+  }, [call]);
+  return useMemo2(
+    () => ({ get, getMany, getText, getBytes, getJson, put, delete: del, list, clear, estimate }),
+    [get, getMany, getText, getBytes, getJson, put, del, list, clear, estimate]
+  );
+}
 var FiasContentError = class extends Error {
   constructor(message, code, path) {
     super(message);
@@ -2662,6 +3068,117 @@ async function fetchCommunityAssetUrls(bridge, assetIds) {
   }
   return hits;
 }
+var CONNECT_TIMEOUT_MS = 10 * 60 * 1e3;
+function useFiasConnections() {
+  const bridge = useBridge();
+  const list = useCallback(async () => {
+    const res = await invokeEntityOp(
+      bridge,
+      CONNECTIONS_ENTITY_ID,
+      "list"
+    );
+    return res.connections;
+  }, [bridge]);
+  const connect = useCallback(
+    async (provider) => {
+      const result = await bridge.request(
+        "client_entity_invoke",
+        { entityId: CONNECTIONS_CONNECT_ENTITY_ID, input: { provider } },
+        CONNECT_TIMEOUT_MS
+      );
+      if (result && "error" in result) {
+        throw new FiasBridgeError(result.error.message, result.error.code);
+      }
+      return result;
+    },
+    [bridge]
+  );
+  const release = useCallback(
+    async (connectionId) => {
+      await invokeEntityOp(bridge, CONNECTIONS_ENTITY_ID, "release", { connectionId });
+    },
+    [bridge]
+  );
+  return useMemo2(() => ({ list, connect, release }), [list, connect, release]);
+}
+function useFiasX() {
+  const bridge = useBridge();
+  return useMemo2(
+    () => ({
+      publishPost: (params) => invokeEntityOp(bridge, X_ENTITY_ID, "publish_post", { ...params }),
+      searchUsers: async (connectionId, query, options) => (await invokeEntityOp(bridge, X_ENTITY_ID, "search_users", {
+        connectionId,
+        query,
+        ...options
+      })).users,
+      getUserPosts: async (connectionId, options) => (await invokeEntityOp(bridge, X_ENTITY_ID, "get_user_posts", {
+        connectionId,
+        ...options
+      })).posts,
+      getPostMetrics: async (connectionId, postIds) => (await invokeEntityOp(
+        bridge,
+        X_ENTITY_ID,
+        "get_post_metrics",
+        { connectionId, postIds }
+      )).metrics,
+      getAccountStats: (connectionId) => invokeEntityOp(bridge, X_ENTITY_ID, "get_account_stats", {
+        connectionId
+      })
+    }),
+    [bridge]
+  );
+}
+function useFiasSchedules() {
+  const bridge = useBridge();
+  return useMemo2(
+    () => ({
+      schedule: (params) => invokeEntityOp(
+        bridge,
+        SCHEDULED_INVOCATIONS_ENTITY_ID,
+        "schedule",
+        {
+          entityId: params.entityId,
+          verb: params.verb,
+          payload: params.payload,
+          fireAt: params.fireAt instanceof Date ? params.fireAt.toISOString() : params.fireAt
+        }
+      ),
+      list: async (options) => (await invokeEntityOp(
+        bridge,
+        SCHEDULED_INVOCATIONS_ENTITY_ID,
+        "list",
+        {
+          ...options?.limit !== void 0 ? { limit: options.limit } : {},
+          ...options?.scheduleIds ? { scheduleIds: options.scheduleIds } : {}
+        }
+      )).schedules,
+      cancel: async (scheduleId) => {
+        await invokeEntityOp(bridge, SCHEDULED_INVOCATIONS_ENTITY_ID, "cancel", { scheduleId });
+      }
+    }),
+    [bridge]
+  );
+}
+function useFiasLinkedIn() {
+  const bridge = useBridge();
+  return useMemo2(
+    () => ({
+      publishPost: (params) => invokeEntityOp(
+        bridge,
+        LINKEDIN_ENTITY_ID,
+        "publish_post",
+        { ...params }
+      ),
+      searchOrganizations: async (connectionId, vanityName) => (await invokeEntityOp(
+        bridge,
+        LINKEDIN_ENTITY_ID,
+        "search_organizations",
+        { connectionId, query: vanityName }
+      )).organizations
+    }),
+    [bridge]
+  );
+}
 function useCompanyEmail() {
   const bridge = useBridge();
   const send = useCallback(
@@ -2948,6 +3465,7 @@ var VALID_PLUGIN_PERMISSIONS = [
   "assets:community:publish",
   "assets:community:read",
   "assets:read",
+  "connections:use",
   "data:agents",
   "data:search",
   "data:store",
@@ -2962,6 +3480,8 @@ var VALID_PLUGIN_PERMISSIONS = [
   "entities:web_search",
   "navigation:open_arche",
   "sandbox:vendored-libraries",
+  "schedule:invoke",
+  "storage:local",
   "storage:sandbox",
   "store:purchase",
   "theme:read",
@@ -2981,7 +3501,8 @@ var PLUGIN_PERMISSION_DESCRIPTIONS = {
   "ai:actions": "Let Fias AI operate this arche for you \u2014 only actions you could do yourself in its interface, and risky ones ask you first.",
   "assets:community:publish": "Share images you made here so other people using this arche can see them, and manage what you have shared.",
   "assets:community:read": "Show you images that other people using this arche have shared. Everything shared is checked before anyone can see it.",
-  "assets:read": "Show images from this arche's published asset library.",
+  "assets:read": "Show images and play sounds from this arche's published asset library.",
+  "connections:use": "Use outside accounts (like X or LinkedIn) that you connect and let it use \u2014 you choose each account and each workspace, approve what it posts, and can take access away any time in Workspace Controls.",
   "data:agents": "Let Fias AI, and assistants you connect with an API key and allow here, read this arche's data \u2014 and change it where it says so \u2014 even while it is closed.",
   "data:search": "Search this arche's own data semantically \u2014 costs credits per search.",
   "data:store": "Save structured data in this arche's own private database.",
@@ -2996,6 +3517,8 @@ var PLUGIN_PERMISSION_DESCRIPTIONS = {
   "entities:web_search": "Search the live web on your behalf \u2014 costs credits.",
   "navigation:open_arche": "Open other arches for you (navigation only).",
   "sandbox:vendored-libraries": "Load platform-hosted libraries (like the PDF renderer) from the trusted CDN.",
+  "schedule:invoke": "Schedule an action for later \u2014 like a post at 9 AM tomorrow. You approve exactly what will be sent and when, and can see or cancel what it scheduled.",
+  "storage:local": "Keep its working files on this device, so a refresh or crash does not lose your work. Nothing leaves your device; cleared when you sign out or when someone else signs in here.",
   "storage:sandbox": "Save files in this arche's own private storage.",
   "store:purchase": "Offer purchases inside the arche (you approve each purchase).",
   "theme:read": "Match your platform theme.",
@@ -5092,6 +5615,63 @@ function useFiasFonts() {
   return useMemo3(() => ({ fonts: FONT_CATALOG, ensureFontLoaded }), []);
 }
 
+// src/limits.ts
+var X_PUBLISH_LIMITS = {
+  MAX_TEXT_CHARACTERS: 25e3,
+  MAX_IMAGES_PER_POST: 4,
+  MAX_IMAGES_PER_PUBLISH: 4,
+  MAX_THREAD_POSTS: 10,
+  MIN_POLL_OPTIONS: 2,
+  MAX_POLL_OPTIONS: 4,
+  MAX_POLL_OPTION_CHARACTERS: 25,
+  MIN_POLL_MINUTES: 5,
+  MAX_POLL_MINUTES: 10080,
+  IMAGE_MIME_TYPES: ["image/png", "image/jpeg", "image/webp", "image/gif"],
+  MAX_IMAGE_BYTES: 5 * 1024 * 1024
+};
+var LINKEDIN_PUBLISH_LIMITS = {
+  MAX_TEXT_CHARACTERS: 3e3,
+  MAX_IMAGES: 9,
+  IMAGE_MIME_TYPES: ["image/png", "image/jpeg", "image/gif"],
+  MAX_IMAGE_BYTES: 8 * 1024 * 1024
+};
+var SCHEDULE_LIMITS = {
+  /** Waiting at once, per person, per app. */
+  MAX_ACTIVE_PER_USER_ARCHE: 25,
+  /** The earliest a call may be scheduled, from now. */
+  MIN_LEAD_SECONDS: 5 * 60,
+  /** The latest, from now. */
+  MAX_LEAD_DAYS: 60
+};
+var DATA_STORE_LIMITS = {
+  /** One document's `data`, serialized. */
+  MAX_DOCUMENT_SIZE_BYTES: 100 * 1024,
+  /** Per owner — one user, one workspace, or the app's shared data — per collection. */
+  MAX_DOCUMENTS_PER_OWNER_PER_COLLECTION: 1e4,
+  /** Writes in one atomic `batch`. */
+  MAX_BATCH_OPERATIONS: 100
+};
+var DATA_STORE_RATE_LIMITS_PER_MINUTE = {
+  put: 120,
+  get: 300,
+  query: 60,
+  delete: 60,
+  /** Counted in units of 25 operations: a full 100-op batch is 4. */
+  batch: 30
+};
+var FIAS_AI_MANIFEST_LIMITS = {
+  MAX_ACTIONS: 30,
+  MAX_ID_LENGTH: 100,
+  MAX_DESCRIPTION_LENGTH: 1e3,
+  MAX_CATEGORY_LENGTH: 100,
+  MAX_BLOCK_DESCRIPTION_LENGTH: 2e3,
+  MAX_PARAMETER_SCHEMA_BYTES: 4096,
+  MAX_AVAILABLE_WHEN_KEYS: 8,
+  MAX_AVAILABLE_WHEN_KEY_LENGTH: 64,
+  MAX_AVAILABLE_WHEN_STRING_LENGTH: 100,
+  MAX_BLOCK_SERIALIZED_BYTES: 32 * 1024
+};
+
 // src/panels.ts
 var PANEL_MIN_ELEMENTS = 1;
 var PANEL_MAX_ELEMENTS = 24;
@@ -5485,6 +6065,7 @@ function validatePanelCatalog(value) {
   return issues.length === 0 ? { ok: true, issues: [] } : { ok: false, issues };
 }
 export {
+  ARCHE_ASSET_BYTES_ENTITY_ID,
   AUDIO_AUDIO_ISOLATION_SURFACE_KEY,
   AUDIO_FORCED_ALIGNMENT_SURFACE_KEY,
   AUDIO_GEMINI_TRANSCRIBE_SURFACE_KEY,
@@ -5496,14 +6077,19 @@ export {
   AUDIO_TTS_SURFACE_KEY,
   AUDIO_VOICE_CHANGER_SURFACE_KEY,
   AUDIO_VOICE_DESIGN_SURFACE_KEY,
+  ArcheAssetError,
   DARK_THEME,
+  DATA_STORE_LIMITS,
+  DATA_STORE_RATE_LIMITS_PER_MINUTE,
   ENTITY_INVOCATION_HISTORY_LIMITS,
   ENTITY_INVOCATION_REQUEST_LIMITS,
+  FIAS_AI_MANIFEST_LIMITS,
   FONT_CATALOG,
   FONT_PAIRINGS,
   FiasBridge,
   FiasBridgeError,
   FiasContentError,
+  FiasLocalStoreError,
   FiasProvider,
   GRAMMAR_CHECK_ENTITY_ID,
   IMAGE_SMART_CONTROL_SURFACE_KEY,
@@ -5519,6 +6105,8 @@ export {
   IMAGE_SMART_VECTORIZE_SURFACE_KEY,
   INTEGRATION_WEB_SEARCH_SURFACE_KEY,
   LIGHT_THEME,
+  LINKEDIN_ENTITY_ID,
+  LINKEDIN_PUBLISH_LIMITS,
   NLLB_LANGUAGES,
   NLLB_TRANSLATION_ENTITY_ID,
   PANEL_BUTTON_LABEL_MAX_LENGTH,
@@ -5537,12 +6125,16 @@ export {
   PANEL_THEME_Z_MAX,
   PANEL_TITLE_MAX_LENGTH,
   PLUGIN_CONTENT_ENTITY_ID,
+  PLUGIN_LOCAL_STORE_ENTITY_ID,
   PLUGIN_PERMISSION_DESCRIPTIONS,
   REASONING_EFFORTS,
+  SCHEDULE_LIMITS,
   SDK_BRIDGE_PROTOCOL_VERSION,
   SDK_REQUIRES_HOST_PROTOCOL_VERSION,
   THEME_CATALOG,
   VALID_PLUGIN_PERMISSIONS,
+  X_ENTITY_ID,
+  X_PUBLISH_LIMITS,
   checkInvocationHistory,
   checkInvocationRequestSize,
   checkReasoningParameter,
@@ -5557,6 +6149,7 @@ export {
   invocationPayloadByteLimit,
   isValidPluginPermission,
   resetBridge,
+  useArcheAssetBytes,
   useArcheAssets,
   useArcheHandoff,
   useAudioGeneration,
@@ -5575,22 +6168,28 @@ export {
   useElevenLabsVoiceDesign,
   useEntityInvocation,
   useFiasAIActions,
+  useFiasConnections,
   useFiasContent,
   useFiasDataStore,
   useFiasFonts,
+  useFiasHolder,
+  useFiasLinkedIn,
   useFiasNavigation,
   useFiasPreviewState,
+  useFiasSchedules,
   useFiasStorage,
   useFiasStore,
   useFiasTheme,
   useFiasUser,
   useFiasVendoredAssets,
   useFiasWorkspaces,
+  useFiasX,
   useGeminiTranscribe,
   useGeminiTts,
   useImageEntities,
   useImageGeneration,
   useIntegrationWebSearch,
+  useLocalStore,
   useLyriaMusic,
   usePersistentState,
   useSmartControl,