nolo-cli 0.49.1 → 0.50.0

package/memberThunks-KVPBG4V7.js

@@ -0,0 +1,638 @@
+import {
+  appendRecoveredMemberships,
+  fetchRemoteSpace,
+  fetchRemoteUserSpaceMemberships,
+  getMemberSpaces,
+  hydrateMemberSpacesFromLocal,
+  membershipBelongsToUser,
+  selectSpaceRemoteAuth,
+  setMemberSpaces,
+  setMembershipLoading,
+  setMembershipRejected,
+  spaceListsUser
+} from "./chunk-SGSJBBKP.js";
+import {
+  getCurrentSpaceIdRaw,
+  updateCurrentSpaceIfMatch
+} from "./chunk-ZJ7UHBJS.js";
+import "./chunk-YDH3FDFQ.js";
+import "./chunk-BYXBJQAS.js";
+import {
+  createSpaceKey,
+  normalizeSpaceId
+} from "./chunk-UAD2WT54.js";
+import {
+  read,
+  remove,
+  write
+} from "./chunk-273FJUYI.js";
+import {
+  DB_PREFIX
+} from "./chunk-SVEUG45B.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-I42VC5KR.js";
+import "./chunk-SAJSBPI2.js";
+import "./chunk-QSJ3HFEF.js";
+import {
+  readAction
+} from "./chunk-EJFW7TRP.js";
+import "./chunk-BJIRLHJR.js";
+import {
+  DEVICE_LOCAL_OWNER_ID,
+  createAsyncThunk,
+  isDeviceLocalOwnerId,
+  isDeviceLocalSpaceMembership,
+  selectIdentityUserId
+} from "./chunk-XOJRZUPF.js";
+import {
+  logger
+} from "./chunk-QOKAKDPE.js";
+import "./chunk-OW765XBU.js";
+import {
+  isTombstoneRecord
+} from "./chunk-GBRG75BQ.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-KUG52IAP.js";
+import {
+  API_ENDPOINTS
+} from "./chunk-LCBAMY2M.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/create/space/member/isSpaceMembershipRemoteUnavailableError.ts
+var SPACE_MEMBERSHIP_REMOTE_UNAVAILABLE = "space_membership_remote_unavailable";
+var isSpaceMembershipRemoteUnavailableError = (error) => {
+  if (typeof error === "string") {
+    return error.includes(SPACE_MEMBERSHIP_REMOTE_UNAVAILABLE);
+  }
+  if (error instanceof Error) {
+    return error.message.includes(SPACE_MEMBERSHIP_REMOTE_UNAVAILABLE);
+  }
+  if (error && typeof error === "object" && "message" in error && typeof error.message === "string") {
+    return error.message.includes(
+      SPACE_MEMBERSHIP_REMOTE_UNAVAILABLE
+    );
+  }
+  return false;
+};
+
+// packages/create/space/member/fetchUserSpaceMembershipsAction.ts
+var CONTENT_SPACE_RECOVERY_TYPES = [
+  "app" /* APP */,
+  "page" /* DOC */,
+  "dialog" /* DIALOG */,
+  "image" /* IMAGE */,
+  "file" /* FILE */,
+  "table" /* TABLE */,
+  "agent" /* AGENT */
+];
+var readLocalSpaceData = async (db, spaceId) => {
+  const normalizedSpaceId = normalizeSpaceId(spaceId);
+  const spaceKey = createSpaceKey.space(normalizedSpaceId);
+  try {
+    return await db.get(spaceKey) ?? null;
+  } catch {
+    return null;
+  }
+};
+var membershipCheckUserId = (membership, activeUserId) => isDeviceLocalSpaceMembership(membership) ? DEVICE_LOCAL_OWNER_ID : activeUserId;
+var buildLocalMembershipPreview = async (userId, db, memberships) => {
+  const preview = await Promise.all(
+    memberships.map(async (membership) => {
+      if (isTombstoneRecord(membership)) return null;
+      const checkUserId = membershipCheckUserId(membership, userId);
+      if (!membershipBelongsToUser(membership, checkUserId)) return null;
+      const normalizedSpaceId = normalizeSpaceId(membership.spaceId);
+      const localSpaceData = await readLocalSpaceData(db, normalizedSpaceId);
+      if (!localSpaceData || isTombstoneRecord(localSpaceData)) return null;
+      if (!spaceListsUser(localSpaceData, checkUserId)) return null;
+      return {
+        ...membership,
+        spaceId: normalizedSpaceId
+      };
+    })
+  );
+  return preview.filter(
+    (membership) => !!membership
+  );
+};
+var fetchLocalForUser = async (userId, db) => {
+  try {
+    const memberships = [];
+    const prefix = `space-member-${userId}`;
+    let iterator = db.iterator({
+      gte: prefix,
+      lte: prefix + "\xFF"
+    });
+    if (iterator && typeof iterator.then === "function") {
+      iterator = await iterator;
+    }
+    for await (const [_, memberData] of iterator) {
+      if (memberData && typeof memberData === "object" && memberData.spaceId && !isTombstoneRecord(memberData)) {
+        memberships.push(memberData);
+      }
+    }
+    return memberships;
+  } catch (error) {
+    console.error("Error fetching local memberships:", error);
+    return [];
+  }
+};
+var fetchLocalUnion = async (userId, db) => {
+  const deviceLocalRows = await fetchLocalForUser(DEVICE_LOCAL_OWNER_ID, db);
+  const taggedLocal = deviceLocalRows.map(
+    (membership) => ({
+      ...membership,
+      spaceId: normalizeSpaceId(membership.spaceId),
+      deviceLocal: true,
+      userId: membership.userId || DEVICE_LOCAL_OWNER_ID
+    })
+  );
+  if (isDeviceLocalOwnerId(userId)) {
+    return taggedLocal;
+  }
+  const accountRows = await fetchLocalForUser(userId, db);
+  const taggedAccount = accountRows.map(
+    (membership) => ({
+      ...membership,
+      spaceId: normalizeSpaceId(membership.spaceId),
+      deviceLocal: false
+    })
+  );
+  return [...taggedLocal, ...taggedAccount];
+};
+var fetchRemoteContentSpaceIds = async (server, userId, token) => {
+  try {
+    const queryParams = new URLSearchParams({ limit: "200" });
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const authToken = asTrimmedString(token);
+    if (authToken) {
+      headers.Authorization = `Bearer ${authToken}`;
+    }
+    const response = await fetch(
+      `${server}${API_ENDPOINTS.DATABASE}/query/${encodeURIComponent(userId)}?${queryParams}`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          type: [...CONTENT_SPACE_RECOVERY_TYPES],
+          includeDeleted: true,
+          summary: true
+        })
+      }
+    );
+    if (!response.ok) return [];
+    const data = await response.json();
+    const records = Array.isArray(data?.data?.data) ? data.data.data : [];
+    return records.filter((record) => !isTombstoneRecord(record)).map(
+      (record) => typeof record?.spaceId === "string" ? normalizeSpaceId(record.spaceId) : ""
+    ).filter((spaceId) => spaceId.length > 0);
+  } catch {
+    return [];
+  }
+};
+var recoverMembershipsFromContentSpaces = async ({
+  servers,
+  token,
+  userId,
+  knownSpaceIds
+}) => {
+  const candidateSpaceIds = /* @__PURE__ */ new Set();
+  await Promise.all(
+    servers.map(async (server) => {
+      const spaceIds = await fetchRemoteContentSpaceIds(server, userId, token);
+      spaceIds.forEach((spaceId) => {
+        if (!knownSpaceIds.has(spaceId)) {
+          candidateSpaceIds.add(spaceId);
+        }
+      });
+    })
+  );
+  const results = await Promise.all(
+    [...candidateSpaceIds].map(async (spaceId) => {
+      try {
+        for (const server of servers) {
+          const remoteSpace = await fetchRemoteSpace(server, token, spaceId);
+          if (!spaceListsUser(remoteSpace, userId)) continue;
+          return {
+            userId,
+            spaceId,
+            spaceName: typeof remoteSpace?.name === "string" && remoteSpace.name.trim() ? remoteSpace.name : spaceId,
+            role: remoteSpace?.ownerId === userId ? "owner" /* OWNER */ : "member" /* MEMBER */,
+            joinedAt: remoteSpace?.updatedAt ?? remoteSpace?.createdAt ?? Date.now(),
+            sourceServer: server
+          };
+        }
+      } catch {
+      }
+      return null;
+    })
+  );
+  const recovered = results.filter(
+    (m) => m !== null
+  );
+  return recovered;
+};
+var fetchUserSpaceMembershipsAction = async (userId, thunkAPI) => {
+  const state = thunkAPI.getState();
+  const db = thunkAPI.extra.db;
+  const { token, servers } = selectSpaceRemoteAuth(state);
+  const isLocalActor = isDeviceLocalOwnerId(userId);
+  const localMembershipsPromise = fetchLocalUnion(userId, db);
+  const remoteResultsPromise = isLocalActor ? Promise.resolve([]) : Promise.all(
+    servers.map(
+      (server) => fetchRemoteUserSpaceMemberships(server, token, userId)
+    )
+  );
+  const localMemberships = await localMembershipsPromise;
+  if (getMemberSpaces() === null && localMemberships.length > 0) {
+    const localPreview = await buildLocalMembershipPreview(
+      userId,
+      db,
+      localMemberships
+    );
+    if (localPreview.length > 0) {
+      hydrateMemberSpacesFromLocal(localPreview);
+    }
+  }
+  const remoteResults = await remoteResultsPromise;
+  const successfulRemoteResults = remoteResults.filter((result) => result.ok);
+  const successfulRemoteMemberships = successfulRemoteResults.flatMap(
+    (result) => result.memberships.map((membership) => ({
+      ...membership,
+      sourceServer: result.server
+    }))
+  );
+  const hasSuccessfulRemoteFetch = successfulRemoteResults.length > 0;
+  const hasRemoteAuthority = !isLocalActor && !!token && servers.length > 0;
+  if (hasRemoteAuthority && !hasSuccessfulRemoteFetch) {
+    throw new Error(
+      `${SPACE_MEMBERSHIP_REMOTE_UNAVAILABLE}: unable to refresh memberships from ${servers.join(", ")}`
+    );
+  }
+  const remoteSpaceIds = new Set(
+    successfulRemoteMemberships.map(
+      (membership) => normalizeSpaceId(membership.spaceId)
+    )
+  );
+  const filteredLocalMemberships = hasSuccessfulRemoteFetch ? (await Promise.all(
+    localMemberships.map(async (membership) => {
+      const normalizedSpaceId = normalizeSpaceId(membership.spaceId);
+      if (membership.deviceLocal || isDeviceLocalSpaceMembership(membership)) {
+        return {
+          ...membership,
+          spaceId: normalizedSpaceId,
+          deviceLocal: true
+        };
+      }
+      if (remoteSpaceIds.has(normalizedSpaceId)) {
+        return {
+          ...membership,
+          spaceId: normalizedSpaceId
+        };
+      }
+      console.warn(
+        `[SpaceMembership] Membership missing from remote index, verifying space record: user=${userId}, spaceId=${normalizedSpaceId}`
+      );
+      return {
+        ...membership,
+        spaceId: normalizedSpaceId,
+        requiresRemoteSpaceVerification: true
+      };
+    })
+  )).filter((membership) => !!membership) : localMemberships.map((membership) => ({
+    ...membership,
+    spaceId: normalizeSpaceId(membership.spaceId)
+  }));
+  const verifyActiveSpaceMembership = async (membership) => {
+    if (isTombstoneRecord(membership)) return null;
+    const checkUserId = membershipCheckUserId(membership, userId);
+    if (!membershipBelongsToUser(membership, checkUserId)) return null;
+    const normalizedSpaceId = normalizeSpaceId(membership.spaceId);
+    const localSpaceData = await readLocalSpaceData(db, normalizedSpaceId);
+    const isDeviceLocal = membership.deviceLocal || isDeviceLocalSpaceMembership(membership);
+    if (isDeviceLocal) {
+      if (!localSpaceData || isTombstoneRecord(localSpaceData)) return null;
+      if (!spaceListsUser(localSpaceData, checkUserId)) {
+        return null;
+      }
+      const {
+        sourceServer: _s,
+        requiresRemoteSpaceVerification: _r,
+        deviceLocal: _d,
+        ...visible
+      } = membership;
+      return {
+        ...visible,
+        spaceId: normalizedSpaceId,
+        userId: DEVICE_LOCAL_OWNER_ID
+      };
+    }
+    if (membership.sourceServer || membership.requiresRemoteSpaceVerification) {
+      if (localSpaceData && isTombstoneRecord(localSpaceData)) return null;
+      if (membership.sourceServer && !membership.requiresRemoteSpaceVerification) {
+        const { sourceServer: _ss, ...verifiedMembership } = membership;
+        return {
+          ...verifiedMembership,
+          spaceId: normalizedSpaceId
+        };
+      }
+      try {
+        const remoteSpaceServers = Array.from(
+          new Set(
+            [membership.sourceServer, ...servers].filter(
+              (server) => typeof server === "string" && server.length > 0
+            )
+          )
+        );
+        let remoteSpace = null;
+        for (const server of remoteSpaceServers) {
+          remoteSpace = await fetchRemoteSpace(
+            server,
+            token,
+            normalizedSpaceId
+          );
+          if (remoteSpace) break;
+        }
+        if (!spaceListsUser(remoteSpace, userId)) return null;
+        const {
+          requiresRemoteSpaceVerification,
+          deviceLocal: _dl,
+          ...verifiedMembership
+        } = membership;
+        return {
+          ...verifiedMembership,
+          spaceId: normalizedSpaceId
+        };
+      } catch {
+        return null;
+      }
+    }
+    if (localSpaceData) {
+      return !spaceListsUser(localSpaceData, userId) ? null : {
+        ...membership,
+        spaceId: normalizedSpaceId
+      };
+    }
+    if (!membership.sourceServer && servers.length === 0) {
+      return {
+        ...membership,
+        spaceId: normalizedSpaceId
+      };
+    }
+    try {
+      const remoteSpace = await readAction(
+        {
+          dbKey: createSpaceKey.space(normalizedSpaceId),
+          preferredServerOrigin: membership.sourceServer
+        },
+        thunkAPI
+      );
+      if (!spaceListsUser(remoteSpace, userId)) return null;
+      return {
+        ...membership,
+        spaceId: normalizedSpaceId
+      };
+    } catch {
+      return null;
+    }
+  };
+  const activeMemberships = (await Promise.all(
+    [...filteredLocalMemberships, ...successfulRemoteMemberships].map(
+      verifyActiveSpaceMembership
+    )
+  )).filter((membership) => !!membership);
+  const knownSpaceIds = new Set(
+    [
+      ...filteredLocalMemberships,
+      ...successfulRemoteMemberships,
+      ...activeMemberships
+    ].map((membership) => normalizeSpaceId(membership.spaceId))
+  );
+  if (hasRemoteAuthority && hasSuccessfulRemoteFetch && !isLocalActor) {
+    void recoverMembershipsFromContentSpaces({
+      servers,
+      token,
+      userId,
+      knownSpaceIds
+    }).then((rawRecovered) => {
+      const activeUserId = thunkAPI.getState()?.auth?.currentUser?.userId ?? null;
+      if (activeUserId !== userId) return;
+      if (rawRecovered.length === 0) return;
+      const cleaned = rawRecovered.map((membership) => {
+        const {
+          sourceServer: _ss,
+          requiresRemoteSpaceVerification: _rv,
+          deviceLocal: _dl,
+          ...visible
+        } = membership;
+        return { ...visible, spaceId: normalizeSpaceId(membership.spaceId) };
+      });
+      appendRecoveredMemberships(cleaned);
+    }).catch(() => {
+    });
+  }
+  const membershipMap = /* @__PURE__ */ new Map();
+  const preferAccountOnCollision = (existing, next) => {
+    if (!existing) return next;
+    const existingLocal = isDeviceLocalSpaceMembership(existing);
+    const nextLocal = isDeviceLocalSpaceMembership(next);
+    if (existingLocal && !nextLocal) return next;
+    if (!existingLocal && nextLocal) return existing;
+    return next;
+  };
+  [...activeMemberships].forEach((membership) => {
+    const normalizedSpaceId = normalizeSpaceId(membership.spaceId);
+    const {
+      sourceServer: _sourceServer,
+      requiresRemoteSpaceVerification: _req,
+      deviceLocal: _deviceLocal,
+      ...visibleMembership
+    } = membership;
+    const cleaned = {
+      ...visibleMembership,
+      spaceId: normalizedSpaceId
+    };
+    const existing = membershipMap.get(normalizedSpaceId);
+    membershipMap.set(
+      normalizedSpaceId,
+      preferAccountOnCollision(existing, cleaned)
+    );
+  });
+  const finalMemberships = Array.from(membershipMap.values()).sort(
+    (a, b) => (b.joinedAt || 0) - (a.joinedAt || 0)
+  );
+  return finalMemberships;
+};
+
+// packages/database/thunkApiTypes.ts
+var dbThunkState = (thunkApi) => thunkApi.getState();
+var dbThunkExtra = (thunkApi) => thunkApi.extra;
+
+// packages/create/space/member/addMemberAction.ts
+var addMemberAction = async (input, thunkAPI) => {
+  const { spaceId, memberId, role = "member" /* MEMBER */ } = input;
+  const { dispatch } = thunkAPI;
+  const state = dbThunkState(thunkAPI);
+  const currentUserId = selectIdentityUserId(state);
+  const { db } = dbThunkExtra(thunkAPI);
+  const resolvedMemberId = db ? await resolveMemberId(db, memberId) : memberId.trim();
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceData = await dispatch(read({
+    dbKey: spaceKey
+  })).unwrap();
+  if (!spaceData) {
+    throw new Error("Space not found");
+  }
+  if (!currentUserId) {
+    throw new Error("User is not logged in.");
+  }
+  if (!spaceData.members.includes(currentUserId)) {
+    throw new Error("\u5F53\u524D\u7528\u6237\u4E0D\u662F\u7A7A\u95F4\u6210\u5458\uFF0C\u65E0\u6CD5\u6DFB\u52A0\u6210\u5458");
+  }
+  if (spaceData.members.includes(resolvedMemberId)) {
+    throw new Error("\u6210\u5458\u5DF2\u5B58\u5728");
+  }
+  const updatedSpaceData = {
+    ...spaceData,
+    members: [...spaceData.members, resolvedMemberId],
+    updatedAt: Date.now()
+  };
+  await dispatch(
+    write({ data: updatedSpaceData, customKey: spaceKey })
+  ).unwrap();
+  const now = Date.now();
+  const spaceMemberData = {
+    userId: resolvedMemberId,
+    role,
+    // 使用传入的 role，默认为 MEMBER
+    joinedAt: now,
+    updatedAt: now,
+    // 可选字段，初始化时设置为当前时间
+    spaceId,
+    spaceName: spaceData.name,
+    ownerId: spaceData.ownerId,
+    visibility: spaceData.visibility,
+    type: "space" /* SPACE */
+    // 添加 type 字段
+  };
+  const spaceMemberKey = createSpaceKey.member(resolvedMemberId, spaceId);
+  await dispatch(
+    write({
+      data: spaceMemberData,
+      customKey: spaceMemberKey
+    })
+  ).unwrap();
+  return { spaceId, updatedSpaceData };
+};
+async function resolveMemberId(db, identifier) {
+  const trimmed = identifier.trim();
+  let foundUserId = null;
+  let matchCount = 0;
+  try {
+    for await (const [key, value] of db.iterator({
+      gte: `${DB_PREFIX.USER}`,
+      lte: `${DB_PREFIX.USER}\uFFFF`
+    })) {
+      if (value.username === trimmed) {
+        foundUserId = key.slice(DB_PREFIX.USER.length);
+        matchCount++;
+      }
+    }
+  } catch (err) {
+    logger.warn({ err, identifier: trimmed }, "Failed to scan users by username");
+  }
+  if (matchCount > 1) {
+    throw new Error(
+      `\u627E\u5230\u591A\u4E2A\u7528\u6237\u540D\u4E3A ${trimmed} \u7684\u7528\u6237\uFF0C\u8BF7\u4F7F\u7528\u7528\u6237 ID \u9080\u8BF7`
+    );
+  }
+  if (matchCount === 1 && foundUserId) {
+    return foundUserId;
+  }
+  return trimmed;
+}
+
+// packages/create/space/member/removeMemberAction.ts
+var removeMemberAction = async (input, thunkAPI) => {
+  const { spaceId, memberId } = input;
+  const { dispatch, getState } = thunkAPI;
+  const state = getState();
+  const currentUserId = selectIdentityUserId(state);
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceData = await dispatch(read({
+    dbKey: spaceKey
+  })).unwrap();
+  if (!spaceData) {
+    throw new Error("Space not found");
+  }
+  if (spaceData.ownerId !== currentUserId) {
+    throw new Error("\u53EA\u6709\u7A7A\u95F4\u6240\u6709\u8005\u624D\u80FD\u5220\u9664\u6210\u5458");
+  }
+  if (!spaceData.members.includes(memberId)) {
+    throw new Error("\u5F85\u5220\u9664\u7684\u6210\u5458\u4E0D\u5B58\u5728");
+  }
+  const updatedSpaceData = {
+    ...spaceData,
+    members: spaceData.members.filter((id) => id !== memberId),
+    updatedAt: Date.now()
+  };
+  const memberKey = createSpaceKey.member(memberId, spaceId);
+  await Promise.all([
+    dispatch(write({ data: updatedSpaceData, customKey: spaceKey })).unwrap(),
+    dispatch(remove(memberKey)).unwrap()
+    // 使用 remove 替代 del
+  ]);
+  return { spaceId, updatedSpaceData };
+};
+
+// packages/create/space/member/memberThunks.ts
+var fetchUserSpaceMemberships = createAsyncThunk(
+  "space/fetchUserSpaceMemberships",
+  async (arg, thunkAPI) => {
+    setMembershipLoading();
+    try {
+      const payload = await fetchUserSpaceMembershipsAction(arg, thunkAPI);
+      setMemberSpaces(payload);
+      return payload;
+    } catch (error) {
+      setMembershipRejected(
+        error?.message,
+        isSpaceMembershipRemoteUnavailableError(error)
+      );
+      throw error;
+    }
+  }
+);
+var addMember = createAsyncThunk(
+  "space/addMember",
+  async (arg, thunkAPI) => {
+    const payload = await addMemberAction(arg, thunkAPI);
+    if (getCurrentSpaceIdRaw() === payload.spaceId) {
+      updateCurrentSpaceIfMatch(payload.spaceId, payload.updatedSpaceData);
+    }
+    return payload;
+  }
+);
+var removeMember = createAsyncThunk(
+  "space/removeMember",
+  async (arg, thunkAPI) => {
+    const payload = await removeMemberAction(arg, thunkAPI);
+    if (getCurrentSpaceIdRaw() === payload.spaceId) {
+      updateCurrentSpaceIfMatch(payload.spaceId, payload.updatedSpaceData);
+    }
+    return payload;
+  }
+);
+export {
+  addMember,
+  fetchUserSpaceMemberships,
+  removeMember
+};

package/{models-4QF4BJVY.js → models-CW5EL6Z7.js}

@@ -1,7 +1,7 @@
 import {
   ALL_MODELS
-} from "./chunk-56W233KG.js";
-import "./chunk-WL3UOGYO.js";
+} from "./chunk-YWY25N4V.js";
+import "./chunk-G4WSLTQF.js";
 import "./chunk-QSJ3HFEF.js";
 import "./chunk-4VNS5WPM.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.49.1",
+  "version": "0.50.0",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
@@ -16,7 +16,6 @@
   },
   "dependencies": {
     "level": "^10.0.0",
-    "ulid": "^2.3.0",
-    "tweetnacl": "^1.0.3"
+    "ulid": "^2.3.0"
   }
 }

package/{read-J7RVVCHH.js → read-NIOV5F7W.js}

@@ -1,14 +1,14 @@
 import {
   readAction
-} from "./chunk-2JYSSXLY.js";
+} from "./chunk-EJFW7TRP.js";
 import "./chunk-BJIRLHJR.js";
-import "./chunk-HHBXCRJS.js";
-import "./chunk-L3JWI7WX.js";
+import "./chunk-XOJRZUPF.js";
+import "./chunk-QOKAKDPE.js";
 import "./chunk-OW765XBU.js";
 import "./chunk-GBRG75BQ.js";
-import "./chunk-KUG52IAP.js";
 import "./chunk-3EUW3WEO.js";
 import "./chunk-U6VC4MU4.js";
+import "./chunk-KUG52IAP.js";
 import "./chunk-LCBAMY2M.js";
 import "./chunk-4SN6J65J.js";
 import "./chunk-CF7PE763.js";

package/{readDocTool-G2WBM4IH.js → readDocTool-ULKJ5BEM.js}

@@ -4,7 +4,7 @@ import {
   readDocFunctionSchema,
   readPageFunc,
   readPageFunctionSchema
-} from "./chunk-5XCW6RQG.js";
+} from "./chunk-BUBPRCIU.js";
 import "./chunk-HNMXYYJR.js";
 import "./chunk-4VNS5WPM.js";
 export {