@bardway/trpg-notebook-native 0.0.0-stage → 0.1.0

package/app.plugin.cjs

@@ -0,0 +1,69 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  withDangerousMod,
+  withMainApplication,
+  withAppBuildGradle,
+} = require('@expo/config-plugins');
+module.exports = (config, options = {}) => {
+  const fonts = options.fontResources || {};
+  for (const [key, value] of Object.entries(fonts)) {
+    if (
+      !/^(narrative-(400|700)|ui-(400|700)|data-400)\.ttf$/.test(key) ||
+      typeof value !== 'string' ||
+      !/^[_a-z][a-z0-9_]*$/.test(value)
+    )
+      throw new Error('Invalid reader font resource mapping');
+  }
+  config = withAppBuildGradle(config, (mod) => {
+    if (!mod.modResults.contents.includes('androidx.webkit:webkit:1.14.0'))
+      mod.modResults.contents = mod.modResults.contents.replace(
+        'dependencies {',
+        'dependencies {\n    implementation("androidx.webkit:webkit:1.14.0")',
+      );
+    return mod;
+  });
+  config = withMainApplication(config, (mod) => {
+    const registration = 'add(org.bardway.trpg.reader.TrpgMarkdownWebViewPackage())';
+    if (!mod.modResults.contents.includes(registration)) {
+      const marker = 'PackageList(this).packages.apply {';
+      if (!mod.modResults.contents.includes(marker))
+        throw new Error('Unsupported MainApplication package registration');
+      mod.modResults.contents = mod.modResults.contents.replace(
+        marker,
+        marker + '\n          ' + registration,
+      );
+    }
+    return mod;
+  });
+  return withDangerousMod(config, [
+    'android',
+    async (mod) => {
+      const project = mod.modRequest.platformProjectRoot;
+      const destination = path.join(project, 'app/src/main/java/org/bardway/trpg/reader');
+      fs.mkdirSync(destination, { recursive: true });
+      fs.copyFileSync(
+        path.join(__dirname, 'native/TrpgMarkdownWebViewManager.kt'),
+        path.join(destination, 'TrpgMarkdownWebViewManager.kt'),
+      );
+      const pairs = Object.entries(fonts).map(
+        ([key, value]) => JSON.stringify(key) + ' to ' + JSON.stringify(value),
+      );
+      fs.writeFileSync(
+        path.join(destination, 'TrpgReaderFontResources.kt'),
+        'package org.bardway.trpg.reader\ninternal object TrpgReaderFontResources { val fonts:Map<String,String> = mapOf(' +
+          pairs.join(',') +
+          ') }\n',
+      );
+      const readerRoot = path.dirname(require.resolve('@bardway/trpg-markdown/package.json'));
+      const assetDir = path.join(project, 'app/src/main/assets/markdown-reader');
+      fs.mkdirSync(assetDir, { recursive: true });
+      for (const file of ['reader.js', 'reader.css', 'index.html'])
+        fs.copyFileSync(path.join(readerRoot, 'reader', file), path.join(assetDir, file));
+      const notices = path.join(readerRoot, 'reader/third-party-licenses');
+      if (fs.existsSync(notices))
+        fs.cpSync(notices, path.join(assetDir, 'third-party-licenses'), { recursive: true });
+      return mod;
+    },
+  ]);
+};

package/dist/AppMarkdown.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { MarkdownVariant } from '@bardway/trpg-markdown/protocol';
+interface AppMarkdownProps {
+    children: string;
+    variant?: MarkdownVariant;
+    documentKey?: string;
+}
+/** Compatibility entry for a single body section inside a native scroll owner. */
+export declare const AppMarkdown: React.NamedExoticComponent<AppMarkdownProps>;
+export {};

package/dist/AppMarkdownSections.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+import type { MarkdownVariant } from '@bardway/trpg-markdown/protocol';
+export interface AppMarkdownSection {
+    id: string;
+    markdown: string;
+    header?: React.ReactNode;
+    headerHeight?: number;
+    leading?: React.ReactNode;
+    variant?: MarkdownVariant;
+    fragments?: readonly string[];
+}
+interface AppMarkdownSectionsProps {
+    documentKey: string;
+    sections: readonly AppMarkdownSection[];
+    variant?: MarkdownVariant;
+    leadingWidth?: number;
+    columns?: number;
+    style?: StyleProp<ViewStyle>;
+}
+/** One reader per native panel, with native labels in measured reserved spaces. */
+export declare const AppMarkdownSections: React.NamedExoticComponent<AppMarkdownSectionsProps>;
+export {};

package/dist/NotebookPage.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { type WorkspaceInput } from '@bardway/trpg-notebook/react';
+export interface NotebookPageProps extends WorkspaceInput {
+    accountId: string;
+    sessionId: string;
+    isActive: boolean;
+}
+export declare const NotebookPage: React.NamedExoticComponent<NotebookPageProps>;

package/dist/NotebookReaderFrame.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { type MarkdownDocumentViewProps } from './reader/MarkdownDocumentView.js';
+interface NotebookReaderFrameProps {
+    scopeKey: string;
+    readerProps: MarkdownDocumentViewProps | null;
+    loading: boolean;
+    active: boolean;
+    loadingColor: string;
+    loadingBackground: string;
+    children?: React.ReactNode;
+}
+/** A session keeps its one reader even while the next document is being read. */
+export declare function NotebookReaderFrame({ scopeKey, readerProps, loading, active, loadingColor, loadingBackground, children, }: NotebookReaderFrameProps): React.JSX.Element;
+export {};

package/dist/chunked-secure.d.ts

@@ -0,0 +1,19 @@
+import type { KeyValueDriver, AsyncKeyValueDriver } from './storage-drivers.js';
+export declare class SupersededStorageOperationError extends Error {
+    constructor();
+}
+export interface ChunkedSecureStorageOptions {
+    logger: {
+        warn(...values: unknown[]): void;
+    };
+    now: () => number;
+    legacy: KeyValueDriver;
+    secure: AsyncKeyValueDriver;
+    legacyKeys?: (key: string) => readonly string[];
+}
+/** SecureStore commits a manifest only after every chunk is written and read back. */
+export declare const createChunkedSecureStorage: (options: ChunkedSecureStorageOptions) => {
+    getItem: (key: string, isCurrent?: () => boolean) => Promise<string | null>;
+    setItem: (key: string, value: string, isCurrent?: () => boolean) => Promise<void>;
+    removeItem: (key: string, isCurrent?: () => boolean) => Promise<void>;
+};

package/dist/chunked-secure.js

@@ -0,0 +1,180 @@
+// src/chunked-secure.ts
+var SupersededStorageOperationError = class extends Error {
+  constructor() {
+    super("Storage operation superseded");
+    this.name = "SupersededStorageOperationError";
+  }
+};
+var CHUNK_BYTE_LIMIT = 1800;
+var MAX_AUTH_BYTES = 1048576;
+var MAX_CHUNKS = 1024;
+var manifestKey = (key) => `${key}.secure.v1`;
+var chunkKey = (key, manifest, index) => `${key}.secure.${manifest.generation}.${index}`;
+var parseManifest = (raw) => {
+  const value = JSON.parse(raw);
+  if (typeof value !== "object" || value === null || Array.isArray(value) || !("version" in value) || value.version !== 1 || !("generation" in value) || typeof value.generation !== "string" || !/^[a-z0-9-]+$/i.test(value.generation) || !("chunks" in value) || typeof value.chunks !== "number" || !Number.isInteger(value.chunks) || value.chunks < 0 || value.chunks > MAX_CHUNKS || !("length" in value) || typeof value.length !== "number" || !Number.isInteger(value.length) || value.length < 0 || value.length > MAX_AUTH_BYTES || value.chunks === 0 && value.length !== 0) {
+    throw new Error("\u5B89\u5168\u767B\u5F55\u51ED\u636E\u4E0D\u5B8C\u6574\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u3002");
+  }
+  return { version: 1, generation: value.generation, chunks: value.chunks, length: value.length };
+};
+var splitValue = (value) => {
+  const chunks = [];
+  let chunk = "";
+  let chunkBytes = 0;
+  let totalBytes = 0;
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    const bytes = codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
+    totalBytes += bytes;
+    if (totalBytes > MAX_AUTH_BYTES) throw new Error("\u767B\u5F55\u51ED\u636E\u8FC7\u5927\uFF0C\u65E0\u6CD5\u5B89\u5168\u4FDD\u5B58\u3002");
+    if (chunkBytes + bytes > CHUNK_BYTE_LIMIT) {
+      chunks.push(chunk);
+      chunk = "";
+      chunkBytes = 0;
+    }
+    chunk += character;
+    chunkBytes += bytes;
+  }
+  chunks.push(chunk);
+  return chunks;
+};
+var createChunkedSecureStorage = (options) => {
+  const logger = options.logger;
+  const legacy = options.legacy;
+  const secure = options.secure;
+  let pending = Promise.resolve();
+  let sequence = 0;
+  const serialize = (action) => {
+    const operation = pending.then(action);
+    pending = operation.then(
+      () => void 0,
+      () => void 0
+    );
+    return operation;
+  };
+  const oldKeys = (key) => [key, ...options.legacyKeys?.(key) ?? []];
+  const clearLegacy = (key) => oldKeys(key).forEach((oldKey) => legacy.delete(oldKey));
+  const assertCurrent = (isCurrent) => {
+    if (!isCurrent()) throw new SupersededStorageOperationError();
+  };
+  const readManifest = async (key, isCurrent) => {
+    const raw = await secure.getString(manifestKey(key));
+    assertCurrent(isCurrent);
+    return raw === null ? null : parseManifest(raw);
+  };
+  const readPreviousManifest = async (key, isCurrent) => {
+    const raw = await secure.getString(manifestKey(key));
+    assertCurrent(isCurrent);
+    if (raw === null) return null;
+    try {
+      return parseManifest(raw);
+    } catch {
+      return null;
+    }
+  };
+  const readChunks = async (key, manifest, isCurrent) => {
+    if (manifest.chunks === 0) return null;
+    const chunks = [];
+    for (let index = 0; index < manifest.chunks; index += 1) {
+      const chunk = await secure.getString(chunkKey(key, manifest, index));
+      assertCurrent(isCurrent);
+      if (chunk === null) throw new Error("\u5B89\u5168\u767B\u5F55\u51ED\u636E\u4E0D\u5B8C\u6574\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u3002");
+      chunks.push(chunk);
+    }
+    const value = chunks.join("");
+    if (value.length !== manifest.length) throw new Error("\u5B89\u5168\u767B\u5F55\u51ED\u636E\u6821\u9A8C\u5931\u8D25\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u3002");
+    return value;
+  };
+  const removeChunks = async (key, manifest) => {
+    if (!manifest) return;
+    for (let index = 0; index < manifest.chunks; index += 1) {
+      await secure.delete(chunkKey(key, manifest, index));
+    }
+  };
+  const storeValue = async (key, value, previous, isCurrent) => {
+    const chunks = splitValue(value);
+    let generation = `${options.now().toString(36)}-${(++sequence).toString(36)}`;
+    if (generation === previous?.generation) generation += `-${(++sequence).toString(36)}`;
+    const manifest = {
+      version: 1,
+      generation,
+      chunks: chunks.length,
+      length: value.length
+    };
+    let committing = false;
+    try {
+      for (let index = 0; index < chunks.length; index += 1) {
+        await secure.set(chunkKey(key, manifest, index), chunks[index]);
+        assertCurrent(isCurrent);
+      }
+      if (await readChunks(key, manifest, isCurrent) !== value)
+        throw new Error("\u5B89\u5168\u767B\u5F55\u51ED\u636E\u5199\u5165\u6821\u9A8C\u5931\u8D25\u3002");
+      assertCurrent(isCurrent);
+      committing = true;
+      await secure.set(manifestKey(key), JSON.stringify(manifest));
+      const committed = await readManifest(key, isCurrent);
+      if (!committed || committed.generation !== generation || await readChunks(key, committed, isCurrent) !== value) {
+        throw new Error("\u5B89\u5168\u767B\u5F55\u51ED\u636E\u5199\u5165\u6821\u9A8C\u5931\u8D25\u3002");
+      }
+      assertCurrent(isCurrent);
+    } catch (error) {
+      try {
+        if (committing) {
+          if (previous) await secure.set(manifestKey(key), JSON.stringify(previous));
+          else await secure.delete(manifestKey(key));
+        }
+        await removeChunks(key, manifest);
+      } catch {
+        logger.warn("[AuthStorage] incomplete secure chunks could not be removed");
+      }
+      throw error;
+    }
+    clearLegacy(key);
+    try {
+      await removeChunks(key, previous);
+    } catch {
+      logger.warn("[AuthStorage] superseded secure chunks could not be removed");
+    }
+  };
+  return {
+    getItem: (key, isCurrent = () => true) => serialize(async () => {
+      assertCurrent(isCurrent);
+      const manifest = await readManifest(key, isCurrent);
+      if (manifest) {
+        const value2 = await readChunks(key, manifest, isCurrent);
+        assertCurrent(isCurrent);
+        clearLegacy(key);
+        return value2;
+      }
+      const value = oldKeys(key).map((oldKey) => legacy.getString(oldKey)).find((entry) => entry !== void 0);
+      if (value === void 0) return null;
+      await storeValue(key, value, null, isCurrent);
+      return value;
+    }),
+    setItem: (key, value, isCurrent = () => true) => serialize(async () => {
+      assertCurrent(isCurrent);
+      await storeValue(key, value, await readPreviousManifest(key, isCurrent), isCurrent);
+    }),
+    removeItem: (key, isCurrent = () => true) => serialize(async () => {
+      assertCurrent(isCurrent);
+      const previous = await readPreviousManifest(key, isCurrent);
+      assertCurrent(isCurrent);
+      await secure.set(
+        manifestKey(key),
+        JSON.stringify({ version: 1, generation: "deleted", chunks: 0, length: 0 })
+      );
+      const tombstone = await readManifest(key, isCurrent);
+      if (tombstone?.chunks !== 0 || tombstone.generation !== "deleted") {
+        throw new Error("\u5B89\u5168\u767B\u5F55\u51ED\u636E\u6E05\u7406\u6821\u9A8C\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5\u3002");
+      }
+      assertCurrent(isCurrent);
+      clearLegacy(key);
+      await removeChunks(key, previous);
+    })
+  };
+};
+export {
+  SupersededStorageOperationError,
+  createChunkedSecureStorage
+};
+//# sourceMappingURL=chunked-secure.js.map

package/dist/chunked-secure.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/chunked-secure.ts"],
+  "sourcesContent": ["import type { KeyValueDriver, AsyncKeyValueDriver } from './storage-drivers.js';\nexport class SupersededStorageOperationError extends Error {\n  constructor() {\n    super('Storage operation superseded');\n    this.name = 'SupersededStorageOperationError';\n  }\n}\n\nconst CHUNK_BYTE_LIMIT = 1800;\nconst MAX_AUTH_BYTES = 1_048_576;\nconst MAX_CHUNKS = 1024;\n\ninterface SecureAuthManifest {\n  version: 1;\n  generation: string;\n  chunks: number;\n  length: number;\n}\n\nexport interface ChunkedSecureStorageOptions {\n  logger: { warn(...values: unknown[]): void };\n  now: () => number;\n  legacy: KeyValueDriver;\n  secure: AsyncKeyValueDriver;\n  legacyKeys?: (key: string) => readonly string[];\n}\n\nconst manifestKey = (key: string): string => `${key}.secure.v1`;\nconst chunkKey = (key: string, manifest: SecureAuthManifest, index: number): string =>\n  `${key}.secure.${manifest.generation}.${index}`;\n\nconst parseManifest = (raw: string): SecureAuthManifest => {\n  const value: unknown = JSON.parse(raw);\n  if (\n    typeof value !== 'object' ||\n    value === null ||\n    Array.isArray(value) ||\n    !('version' in value) ||\n    value.version !== 1 ||\n    !('generation' in value) ||\n    typeof value.generation !== 'string' ||\n    !/^[a-z0-9-]+$/i.test(value.generation) ||\n    !('chunks' in value) ||\n    typeof value.chunks !== 'number' ||\n    !Number.isInteger(value.chunks) ||\n    value.chunks < 0 ||\n    value.chunks > MAX_CHUNKS ||\n    !('length' in value) ||\n    typeof value.length !== 'number' ||\n    !Number.isInteger(value.length) ||\n    value.length < 0 ||\n    value.length > MAX_AUTH_BYTES ||\n    (value.chunks === 0 && value.length !== 0)\n  ) {\n    throw new Error('\u5B89\u5168\u767B\u5F55\u51ED\u636E\u4E0D\u5B8C\u6574\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u3002');\n  }\n  return { version: 1, generation: value.generation, chunks: value.chunks, length: value.length };\n};\n\nconst splitValue = (value: string): string[] => {\n  const chunks: string[] = [];\n  let chunk = '';\n  let chunkBytes = 0;\n  let totalBytes = 0;\n  for (const character of value) {\n    const codePoint = character.codePointAt(0) ?? 0;\n    const bytes = codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4;\n    totalBytes += bytes;\n    if (totalBytes > MAX_AUTH_BYTES) throw new Error('\u767B\u5F55\u51ED\u636E\u8FC7\u5927\uFF0C\u65E0\u6CD5\u5B89\u5168\u4FDD\u5B58\u3002');\n    if (chunkBytes + bytes > CHUNK_BYTE_LIMIT) {\n      chunks.push(chunk);\n      chunk = '';\n      chunkBytes = 0;\n    }\n    chunk += character;\n    chunkBytes += bytes;\n  }\n  chunks.push(chunk);\n  return chunks;\n};\n\n/** SecureStore commits a manifest only after every chunk is written and read back. */\nexport const createChunkedSecureStorage = (options: ChunkedSecureStorageOptions) => {\n  const logger = options.logger;\n  const legacy = options.legacy;\n  const secure = options.secure;\n  let pending: Promise<void> = Promise.resolve();\n  let sequence = 0;\n\n  const serialize = <T>(action: () => Promise<T>): Promise<T> => {\n    const operation = pending.then(action);\n    pending = operation.then(\n      () => undefined,\n      () => undefined,\n    );\n    return operation;\n  };\n  const oldKeys = (key: string): readonly string[] => [key, ...(options.legacyKeys?.(key) ?? [])];\n  const clearLegacy = (key: string): void =>\n    oldKeys(key).forEach((oldKey) => legacy.delete(oldKey));\n  const assertCurrent = (isCurrent: () => boolean): void => {\n    if (!isCurrent()) throw new SupersededStorageOperationError();\n  };\n  const readManifest = async (\n    key: string,\n    isCurrent: () => boolean,\n  ): Promise<SecureAuthManifest | null> => {\n    const raw = await secure.getString(manifestKey(key));\n    assertCurrent(isCurrent);\n    return raw === null ? null : parseManifest(raw);\n  };\n  const readPreviousManifest = async (\n    key: string,\n    isCurrent: () => boolean,\n  ): Promise<SecureAuthManifest | null> => {\n    const raw = await secure.getString(manifestKey(key));\n    assertCurrent(isCurrent);\n    if (raw === null) return null;\n    try {\n      return parseManifest(raw);\n    } catch {\n      return null;\n    } // Login/logout may replace corrupt metadata; reads still reject it.\n  };\n  const readChunks = async (\n    key: string,\n    manifest: SecureAuthManifest,\n    isCurrent: () => boolean,\n  ): Promise<string | null> => {\n    if (manifest.chunks === 0) return null;\n    const chunks: string[] = [];\n    for (let index = 0; index < manifest.chunks; index += 1) {\n      const chunk = await secure.getString(chunkKey(key, manifest, index));\n      assertCurrent(isCurrent);\n      if (chunk === null) throw new Error('\u5B89\u5168\u767B\u5F55\u51ED\u636E\u4E0D\u5B8C\u6574\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u3002');\n      chunks.push(chunk);\n    }\n    const value = chunks.join('');\n    if (value.length !== manifest.length) throw new Error('\u5B89\u5168\u767B\u5F55\u51ED\u636E\u6821\u9A8C\u5931\u8D25\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u3002');\n    return value;\n  };\n  const removeChunks = async (key: string, manifest: SecureAuthManifest | null): Promise<void> => {\n    if (!manifest) return;\n    for (let index = 0; index < manifest.chunks; index += 1) {\n      await secure.delete(chunkKey(key, manifest, index));\n    }\n  };\n  const storeValue = async (\n    key: string,\n    value: string,\n    previous: SecureAuthManifest | null,\n    isCurrent: () => boolean,\n  ): Promise<void> => {\n    const chunks = splitValue(value);\n    let generation = `${options.now().toString(36)}-${(++sequence).toString(36)}`;\n    if (generation === previous?.generation) generation += `-${(++sequence).toString(36)}`;\n    const manifest: SecureAuthManifest = {\n      version: 1,\n      generation,\n      chunks: chunks.length,\n      length: value.length,\n    };\n    let committing = false;\n    try {\n      for (let index = 0; index < chunks.length; index += 1) {\n        await secure.set(chunkKey(key, manifest, index), chunks[index]);\n        assertCurrent(isCurrent);\n      }\n      if ((await readChunks(key, manifest, isCurrent)) !== value)\n        throw new Error('\u5B89\u5168\u767B\u5F55\u51ED\u636E\u5199\u5165\u6821\u9A8C\u5931\u8D25\u3002');\n      assertCurrent(isCurrent);\n      committing = true;\n      await secure.set(manifestKey(key), JSON.stringify(manifest));\n      const committed = await readManifest(key, isCurrent);\n      if (\n        !committed ||\n        committed.generation !== generation ||\n        (await readChunks(key, committed, isCurrent)) !== value\n      ) {\n        throw new Error('\u5B89\u5168\u767B\u5F55\u51ED\u636E\u5199\u5165\u6821\u9A8C\u5931\u8D25\u3002');\n      }\n      assertCurrent(isCurrent);\n    } catch (error) {\n      // A failed commit must leave the prior generation usable and retain plaintext migration input.\n      try {\n        if (committing) {\n          if (previous) await secure.set(manifestKey(key), JSON.stringify(previous));\n          else await secure.delete(manifestKey(key));\n        }\n        await removeChunks(key, manifest);\n      } catch {\n        logger.warn('[AuthStorage] incomplete secure chunks could not be removed');\n      }\n      throw error;\n    }\n    clearLegacy(key);\n    try {\n      await removeChunks(key, previous);\n    } catch {\n      logger.warn('[AuthStorage] superseded secure chunks could not be removed');\n    }\n  };\n\n  return {\n    getItem: (key: string, isCurrent: () => boolean = () => true): Promise<string | null> =>\n      serialize(async () => {\n        assertCurrent(isCurrent);\n        const manifest = await readManifest(key, isCurrent);\n        if (manifest) {\n          const value = await readChunks(key, manifest, isCurrent);\n          assertCurrent(isCurrent);\n          clearLegacy(key);\n          return value;\n        }\n        const value = oldKeys(key)\n          .map((oldKey) => legacy.getString(oldKey))\n          .find((entry) => entry !== undefined);\n        if (value === undefined) return null;\n        await storeValue(key, value, null, isCurrent);\n        return value;\n      }),\n    setItem: (key: string, value: string, isCurrent: () => boolean = () => true): Promise<void> =>\n      serialize(async () => {\n        assertCurrent(isCurrent);\n        await storeValue(key, value, await readPreviousManifest(key, isCurrent), isCurrent);\n      }),\n    removeItem: (key: string, isCurrent: () => boolean = () => true): Promise<void> =>\n      serialize(async () => {\n        assertCurrent(isCurrent);\n        const previous = await readPreviousManifest(key, isCurrent);\n        assertCurrent(isCurrent);\n        // The tombstone also prevents an interrupted legacy cleanup from restoring an old session.\n        await secure.set(\n          manifestKey(key),\n          JSON.stringify({ version: 1, generation: 'deleted', chunks: 0, length: 0 }),\n        );\n        const tombstone = await readManifest(key, isCurrent);\n        if (tombstone?.chunks !== 0 || tombstone.generation !== 'deleted') {\n          throw new Error('\u5B89\u5168\u767B\u5F55\u51ED\u636E\u6E05\u7406\u6821\u9A8C\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5\u3002');\n        }\n        assertCurrent(isCurrent);\n        clearLegacy(key);\n        await removeChunks(key, previous);\n      }),\n  };\n};\n"],
+  "mappings": "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",
+  "names": ["value"]
+}

package/dist/importPicker.d.ts

@@ -0,0 +1,7 @@
+export interface NotebookPickedFile {
+    uri: string;
+    name: string;
+    size?: number;
+}
+export declare const pickNotebookMarkdownFiles: () => Promise<NotebookPickedFile[] | null>;
+export declare const cleanupNotebookImportCopy: (uri: string) => void;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './storage.js';
+export * from './importPicker.js';
+export * from './reader/ReaderHost.js';
+export * from './reader/MarkdownView.js';
+export * from './reader/MarkdownDocumentView.js';
+export * from './NotebookReaderFrame.js';
+export * from './NotebookPage.js';
+export * from './AppMarkdown.js';
+export * from './AppMarkdownSections.js';