alinea 2.0.0-preview.7 → 2.0.0-preview.8

package/dist/adapter/next/handler.js

@@ -10,17 +10,15 @@ import {
 import {
   createHandler as createCoreHandler
 } from "alinea/backend/Handler";
-import { generatedSource } from "alinea/backend/store/GeneratedSource";
 import { JWTPreviews } from "alinea/backend/util/JWTPreviews";
 import { CloudRemote } from "alinea/cloud/CloudRemote";
 import { Config } from "alinea/core/Config";
-import { LocalDB } from "alinea/core/db/LocalDB";
 import { trace } from "alinea/core/Trace";
 import { NextCMS } from "./cms.js";
 import { requestContext } from "./context.js";
 import { createDevRemote } from "./DevRemote.js";
 import { revalidateContentSha } from "./syncCheck.js";
-function createHandler(input) {
+function createHandlerWithDatabase(input, openGeneratedDatabase) {
   const options = input instanceof NextCMS ? { cms: input } : input;
   const config = options.cms.config;
   const backend = typeof options.backend === "function" ? options.backend : options.backend ? backendFromOptions(options.backend) : (context) => new CloudRemote(context, config);
@@ -28,10 +26,15 @@ function createHandler(input) {
   const span = trace(config, "alinea.next.handler.db");
   const db = PLazy.from(
     () => span(async () => {
-      const source = await generatedSource;
-      const db2 = new LocalDB(config, source);
-      await db2.sync();
-      return db2;
+      if (process.env.NEXT_RUNTIME === "edge")
+        throw new Error(
+          "The Alinea handler is not supported in Edge runtime environments."
+        );
+      if (!openGeneratedDatabase)
+        throw new Error(
+          "A generated database loader is required. Import createHandler from 'alinea/next'."
+        );
+      return openGeneratedDatabase(config);
     })
   );
   const handleBackend = createCoreHandler({
@@ -108,7 +111,11 @@ function rewrittenFilePath(config, request) {
     return;
   }
 }
+function createHandler(input) {
+  return createHandlerWithDatabase(input);
+}
 export {
   createHandler,
+  createHandlerWithDatabase,
   handlerPathname
 };

package/dist/adapter/next/node.d.ts

@@ -0,0 +1,5 @@
+import type { Config } from 'alinea/core/Config';
+import { NextCMS } from './cms.js';
+import { type NextHandlerOptions } from './handler.js';
+export declare function createCMS<Definition extends Config>(config: Definition): NextCMS<Definition>;
+export declare function createHandler(input: NextCMS | NextHandlerOptions): (request: Request) => Promise<Response>;

package/dist/adapter/next/node.js

@@ -0,0 +1,16 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/adapter/next/node.ts
+import { generatedDatabase } from "alinea/backend/store/GeneratedDatabaseNode";
+import { NextCMS } from "./cms.js";
+import { createHandlerWithDatabase } from "./handler.js";
+function createCMS(config) {
+  return new NextCMS(config, generatedDatabase);
+}
+function createHandler(input) {
+  return createHandlerWithDatabase(input, generatedDatabase);
+}
+export {
+  createCMS,
+  createHandler
+};

package/dist/adapter/next/previews.d.ts

@@ -1,10 +1,13 @@
+import { type PreviewStats } from 'alinea/preview/widget';
 export interface NextPreviewsProps {
     dashboardUrl: string;
     widget?: boolean;
+    /** Resolves once the render's CMS queries settled. */
+    stats?: Promise<PreviewStats>;
     root?: string;
     workspace?: string;
 }
-export default function NextPreviews({ dashboardUrl, widget, root, workspace }: NextPreviewsProps): import("react").JSX.Element | null;
+export default function NextPreviews({ dashboardUrl, widget, stats, root, workspace }: NextPreviewsProps): import("react").JSX.Element | null;
 /**
  * Wrapper around `router.refresh()` from `next/navigation` `useRouter()` to return Promise, and resolve after refresh completed
  * @returns Refresh function

package/dist/adapter/next/previews.js

@@ -11,12 +11,14 @@ import { jsx } from "react/jsx-runtime";
 function NextPreviews({
   dashboardUrl,
   widget,
+  stats,
   root,
   workspace
 }) {
   const refresh = useRouterRefresh();
   const [isLoading, setIsLoading] = useState(false);
   const [previewDisabled, setPreviewDisabled] = useState(false);
+  const [renderStats, setRenderStats] = useState();
   const pathname = usePathname();
   const adminUrl = new URL(dashboardUrl, location.origin);
   const host = window.parent !== window ? window.parent : window.opener;
@@ -43,13 +45,23 @@ function NextPreviews({
   useEffect(() => {
     if (widget) registerPreviewWidget();
   }, [widget]);
+  useEffect(() => {
+    let current = true;
+    stats?.then((value) => {
+      if (current) setRenderStats(JSON.stringify(value));
+    });
+    return () => {
+      current = false;
+    };
+  }, [stats]);
   if (!widget) return null;
   return /* @__PURE__ */ jsx(
     "alinea-preview",
     {
       adminUrl: String(adminUrl),
       editUrl: String(editUrl),
-      livePreview: isPreviewing ? isLoading ? "loading" : previewDisabled ? "warning" : "connected" : void 0
+      livePreview: isPreviewing ? isLoading ? "loading" : previewDisabled ? "warning" : "connected" : void 0,
+      stats: renderStats
     }
   );
 }

package/dist/adapter/next/renderStats.d.ts

@@ -0,0 +1,24 @@
+import type { GraphQuery } from 'alinea/core/Graph';
+import type { PreviewStat, PreviewStats } from 'alinea/preview/widget';
+/** Collects the CMS queries and syncs of one draft render. */
+export declare class RenderStats {
+    #private;
+    rows: Array<PreviewStat>;
+    statements: number;
+    sqlMs: number;
+    /** Add a row and count it as pending until `run` settles; see `timed`. */
+    track<T>(stat: Omit<PreviewStat, 'durationMs'>, run: (row: PreviewStat) => Promise<T>): Promise<T>;
+    statement(durationMs: number): void;
+    /**
+     * Resolves once nothing ran for `quietMs`, so queries of server components
+     * that render after the caller are counted, or after `maxMs` regardless.
+     */
+    settled(quietMs?: number, maxMs?: number): Promise<PreviewStats>;
+}
+/**
+ * Time the work a row stands for, such as answering a query without the sync
+ * it waited for.
+ */
+export declare function timed<T>(row: PreviewStat | undefined, run: () => Promise<T>): Promise<T>;
+/** A short description such as `first(type, url=/about)`. */
+export declare function summarizeQuery(query: GraphQuery): string;

package/dist/adapter/next/renderStats.js

@@ -0,0 +1,74 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/adapter/next/renderStats.ts
+var RenderStats = class {
+  rows = [];
+  statements = 0;
+  sqlMs = 0;
+  #pending = 0;
+  #idleSince = Date.now();
+  /** Add a row and count it as pending until `run` settles; see `timed`. */
+  async track(stat, run) {
+    const row = { ...stat, durationMs: 0 };
+    this.rows.push(row);
+    this.#pending++;
+    try {
+      return await run(row);
+    } finally {
+      this.#pending--;
+      this.#idleSince = Date.now();
+    }
+  }
+  statement(durationMs) {
+    this.statements++;
+    this.sqlMs += durationMs;
+  }
+  /**
+   * Resolves once nothing ran for `quietMs`, so queries of server components
+   * that render after the caller are counted, or after `maxMs` regardless.
+   */
+  async settled(quietMs = 50, maxMs = 5e3) {
+    const deadline = Date.now() + maxMs;
+    for (let now = Date.now(); now < deadline; now = Date.now()) {
+      const wait = this.#pending > 0 ? quietMs : this.#idleSince + quietMs - now;
+      if (wait <= 0) break;
+      await new Promise(
+        (resolve) => setTimeout(resolve, Math.min(wait, deadline - now))
+      );
+    }
+    const { rows, statements, sqlMs } = this;
+    return { rows: [...rows], statements, sqlMs };
+  }
+};
+async function timed(row, run) {
+  if (!row) return run();
+  const start = performance.now();
+  try {
+    return await run();
+  } finally {
+    row.durationMs += performance.now() - start;
+  }
+}
+var unlisted = /* @__PURE__ */ new Set([
+  "first",
+  "get",
+  "count",
+  "select",
+  "include",
+  "status",
+  "preview",
+  "syncInterval",
+  "disableSync"
+]);
+function summarizeQuery(query) {
+  const mode = query.count ? "count" : query.get ? "get" : query.first ? "first" : "find";
+  const parts = Object.entries(query).filter(([key, value]) => !unlisted.has(key) && value !== void 0).map(
+    ([key, value]) => typeof value === "string" || typeof value === "number" ? `${key}=${value}` : key
+  );
+  return `${mode}(${parts.join(", ")})`;
+}
+export {
+  RenderStats,
+  summarizeQuery,
+  timed
+};

package/dist/adapter/next/syncCheck.d.ts

@@ -1,5 +1,10 @@
 import type { Client } from 'alinea/core/Client';
-import type { LocalDB } from 'alinea/core/db/LocalDB';
+import type { SyncOptions } from 'alinea/core/db/LocalStore';
+import type { RemoteSource } from 'alinea/core/source/Source';
+interface SyncableDB {
+    readonly sha: string | Promise<string>;
+    syncWith(source: RemoteSource, options?: SyncOptions): Promise<string>;
+}
 export declare const CONTENT_SHA_TAG = "alinea-content-sha";
 export declare function revalidateContentSha(): Promise<void>;
 /**
@@ -9,4 +14,5 @@ export declare function revalidateContentSha(): Promise<void>;
  * Returns false when the sha could not be determined, so the caller falls
  * back to its existing throttle behavior.
  */
-export declare function syncIfStale(db: LocalDB, client: Client, syncInterval?: number): Promise<boolean>;
+export declare function syncIfStale(db: SyncableDB, client: Client, syncInterval?: number, options?: SyncOptions): Promise<boolean>;
+export {};

package/dist/adapter/next/syncCheck.js

@@ -41,15 +41,15 @@ async function revalidateContentSha() {
   } catch {
   }
 }
-async function syncIfStale(db, client, syncInterval) {
+async function syncIfStale(db, client, syncInterval, options) {
   if (syncInterval === Number.POSITIVE_INFINITY) return true;
   if (syncInterval === 0) {
-    await db.syncWith(client);
+    await db.syncWith(client, options);
     return true;
   }
   const expected = await latestSha(client);
   if (!expected) return false;
-  if (expected !== db.sha) await db.syncWith(client);
+  if (expected !== await db.sha) await db.syncWith(client, options);
   return true;
 }
 export {

package/dist/adapter/next/with-alinea.js

@@ -27,7 +27,6 @@ function withAlinea(config = {}) {
   } catch {
     console.warn("Alinea could not determine Next.js version, assuming 15+");
   }
-  const redirects = adminPath ? createRedirects(config, adminPath) : config.redirects;
   const rewrites = adminPath ? createRewrites(config, adminPath, settings.handlerUrl) : config.rewrites;
   const images = adminPath ? createImages(config, adminPath) : config.images;
   const env = settings ? {
@@ -45,7 +44,6 @@ function withAlinea(config = {}) {
           "@alinea/generated"
         ]
       },
-      redirects,
       rewrites,
       images,
       env
@@ -56,7 +54,6 @@ function withAlinea(config = {}) {
       ...config.serverExternalPackages ?? [],
       "@alinea/generated"
     ],
-    redirects,
     rewrites,
     images,
     env
@@ -82,21 +79,6 @@ function createImages(config, adminPath) {
     ]
   };
 }
-function createRedirects(config, adminPath) {
-  const dev = process.env.ALINEA_DEV_SERVER;
-  if (!dev) return config.redirects;
-  return async () => {
-    const existing = config.redirects ? await config.redirects() : [];
-    return [
-      ...existing,
-      {
-        permanent: true,
-        source: `${adminPath}/~dev`,
-        destination: `${dev}/~dev`
-      }
-    ];
-  };
-}
 var emptyRewrites = {
   beforeFiles: [],
   afterFiles: [],

package/dist/backend/Handler.d.ts

@@ -1,6 +1,6 @@
 import type { CMS } from 'alinea/core/CMS';
 import type { AuthedContext, RemoteConnection, RequestContext } from 'alinea/core/Connection';
-import { LocalDB } from 'alinea/core/db/LocalDB';
+import type { LocalStore } from 'alinea/core/db/LocalStore';
 import type { Mutation } from 'alinea/core/db/Mutation';
 export interface Handler {
     (request: Request, context: RequestContext): Promise<Response>;
@@ -18,7 +18,7 @@ export interface HandlerHooks {
 }
 export interface HandlerOptions extends HandlerHooks {
     cms: CMS;
-    db: LocalDB | Promise<LocalDB>;
+    db: LocalStore | Promise<LocalStore>;
     remote?: (context: RequestContext) => RemoteConnection;
     forwardMutations?(request: Request, context: AuthedContext): Promise<Response | undefined>;
 }

package/dist/backend/Handler.js

@@ -4,7 +4,7 @@ import {
   object,
   optional,
   string
-} from "../chunks/chunk-I4GC3E65.js";
+} from "../chunks/chunk-UPY2RUZF.js";
 import {
   PLazy
 } from "../chunks/chunk-IKINPSS5.js";
@@ -19,8 +19,10 @@ import {
 } from "alinea/core/BlobTransport";
 import { Config } from "alinea/core/Config";
 import { developmentKeyHeader } from "alinea/core/Connection";
+import { Entry } from "alinea/core/Entry";
 import { ErrorCode, HttpError } from "alinea/core/HttpError";
 import { MediaLocation } from "alinea/core/media/MediaLocation";
+import { MediaFile } from "alinea/core/media/MediaTypes";
 import { assertUploadSize } from "alinea/core/media/UploadLimits";
 import { Permission, Policy } from "alinea/core/Role";
 import { getScope } from "alinea/core/Scope";
@@ -51,9 +53,18 @@ function createHandler({
     const local = await db;
     const simulateLatency = process.env.ALINEA_LATENCY;
     if (simulateLatency) await new Promise((resolve) => setTimeout(resolve, 2e3));
+    async function syncForRead(cnx) {
+      try {
+        await local.syncWith(cnx);
+      } catch (error) {
+        console.warn(
+          `Alinea could not sync with the remote, serving current content: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
     async function periodicSync(cnx, syncInterval) {
       if (dev) return;
-      return throttle(() => local.syncWith(cnx), syncInterval);
+      return throttle(() => syncForRead(cnx), syncInterval);
     }
     try {
       const previews = new JWTPreviews(context.apiKey);
@@ -87,19 +98,29 @@ function createHandler({
           throw new HttpError(400, "Invalid file path");
         await periodicSync(cnx);
         const requestedUrl = Config.filePathname(cms.config, normalized);
-        const entry = local.index.findByUrl(
-          requestedUrl,
-          (entry2) => entry2.type === "MediaFile" && entry2.status === "published" && entry2.main
-        );
+        const select = {
+          url: Entry.url,
+          filePath: Entry.filePath,
+          workspace: Entry.workspace,
+          location: MediaFile.location,
+          previewUrl: MediaFile.previewUrl
+        };
+        const query = {
+          type: MediaFile,
+          status: "published",
+          main: true,
+          select
+        };
+        const entry = await local.first({ ...query, url: requestedUrl }) ?? await local.first({ ...query, alias: requestedUrl });
         if (!entry) return new Response("Not found", { status: 404 });
         if (entry.url !== requestedUrl && !proxy)
           return new Response(null, {
             status: 308,
             headers: { location: entry.url }
           });
-        const wasBuilt = local.index.initialSync?.has(entry.filePath) ?? false;
-        const previewUrl = entry.data.previewUrl;
-        const location = entry.data.location;
+        const wasBuilt = await local.includedAtBuild(entry.filePath);
+        const previewUrl = entry.previewUrl;
+        const location = entry.location;
         if (typeof location !== "string")
           return new Response("Not found", { status: 404 });
         const previewSource = typeof previewUrl === "string" && previewUrl ? new URL(previewUrl, request.url).href : void 0;
@@ -245,8 +266,8 @@ function createHandler({
           );
         } else {
           const preview = await decodePreviewRequest(query.preview);
-          if ("contentHash" in preview && local.sha !== preview.contentHash)
-            await local.syncWith(cnx);
+          if ("contentHash" in preview && await local.sha !== preview.contentHash)
+            await syncForRead(cnx);
           query.preview = await applyPreview(local, preview);
         }
         return Response.json(await local.resolve(query) ?? null);
@@ -322,7 +343,7 @@ function createHandler({
       if (action === HandleAction.Tree && request.method === "GET") {
         expectJson();
         const sha = string(url.searchParams.get("sha"));
-        await local.syncWith(cnx);
+        await syncForRead(cnx);
         const tree = await local.getTreeIfDifferent(sha);
         return compressResponse(request, Response.json(tree ?? null));
       }

package/dist/backend/api/CreateBackend.js

@@ -1,8 +1,20 @@
 import {
   driver_exports
-} from "../../chunks/chunk-X47OVDF3.js";
-import "../../chunks/chunk-G6E35DMJ.js";
-import "../../chunks/chunk-NWQXN4SB.js";
+} from "../../chunks/chunk-2U43BB6P.js";
+import "../../chunks/chunk-A42DP5T7.js";
+import "../../chunks/chunk-NLZLRQ5U.js";
+import "../../chunks/chunk-IL7FJQAY.js";
+import "../../chunks/chunk-M7KDJEGH.js";
+import "../../chunks/chunk-N47Y62CI.js";
+import "../../chunks/chunk-QBPYWU6C.js";
+import "../../chunks/chunk-2BJ2IFQM.js";
+import "../../chunks/chunk-XCZXR3C2.js";
+import "../../chunks/chunk-TFMUSWGG.js";
+import "../../chunks/chunk-76VMZTLN.js";
+import "../../chunks/chunk-2PIFHEYR.js";
+import "../../chunks/chunk-K62JP6HR.js";
+import "../../chunks/chunk-ATF42T2B.js";
+import "../../chunks/chunk-ETBQTP2S.js";
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/backend/api/CreateBackend.ts

package/dist/backend/api/DatabaseApi.js

@@ -1,21 +1,29 @@
 import {
-  Builder,
-  Column,
-  ColumnType,
-  column,
-  eq,
-  jsonAggregateArray,
-  jsonArray,
-  querySelection,
-  selectQuery,
+  include
+} from "../../chunks/chunk-XTWYBWP2.js";
+import {
+  blob,
+  id,
+  integer,
+  text,
+  varchar
+} from "../../chunks/chunk-K7LHQXI4.js";
+import {
+  Builder
+} from "../../chunks/chunk-2BJ2IFQM.js";
+import {
+  eq
+} from "../../chunks/chunk-XCZXR3C2.js";
+import {
   table
-} from "../../chunks/chunk-G6E35DMJ.js";
+} from "../../chunks/chunk-TFMUSWGG.js";
+import "../../chunks/chunk-76VMZTLN.js";
+import "../../chunks/chunk-2PIFHEYR.js";
+import "../../chunks/chunk-K62JP6HR.js";
+import "../../chunks/chunk-ATF42T2B.js";
 import {
-  getData,
-  internalData,
-  internalSql,
   sql
-} from "../../chunks/chunk-NWQXN4SB.js";
+} from "../../chunks/chunk-ETBQTP2S.js";
 import {
   PLazy
 } from "../../chunks/chunk-IKINPSS5.js";
@@ -26,127 +34,6 @@ import { createId } from "alinea/core/Id";
 import { assert } from "alinea/core/util/Assert";
 import { basename, extname } from "alinea/core/util/Paths";
 import { slugify } from "alinea/core/util/Slugs";
-
-// node_modules/rado/dist/universal/columns.js
-var idType = new ColumnType(
-  "id",
-  [],
-  sql.universal({
-    sqlite: sql`integer`,
-    postgres: sql`integer generated always as identity`,
-    mysql: sql`int not null auto_increment`
-  })
-);
-var blobType = new ColumnType(
-  "blob",
-  [],
-  sql.universal({
-    postgres: sql`bytea`,
-    default: sql`blob`
-  })
-);
-var numberType = new ColumnType(
-  "number",
-  [],
-  sql.universal({
-    mysql: sql`double`,
-    default: sql`numeric`
-  })
-);
-var jsonbType = new ColumnType(
-  "json",
-  [],
-  sql.universal({
-    mysql: sql`json`,
-    default: sql`jsonb`
-  })
-);
-function id(name) {
-  return new Column({
-    name,
-    type: idType,
-    primary: true,
-    notNull: true
-  });
-}
-function text(name) {
-  return new Column({ name, type: column.text() });
-}
-function varchar(name, options) {
-  return new Column({ name, type: column.varchar(options?.length) });
-}
-function integer(name) {
-  return new Column({ name, type: column.integer() });
-}
-function blob(name) {
-  return new Column({
-    name,
-    type: blobType,
-    mapFromDriverValue(value) {
-      return new Uint8Array(value);
-    }
-  });
-}
-
-// node_modules/rado/dist/core/expr/Include.js
-var Include = class {
-  [internalData];
-  constructor(data) {
-    this[internalData] = data;
-  }
-  #mapFromDriverValue = (value, specs) => {
-    const query = getData(this);
-    const parsed = specs.parsesJson ? value : JSON.parse(value);
-    const selected = querySelection(query);
-    if (query.first) {
-      const result = parsed ? selected.mapRow({ values: parsed, index: 0, specs }) : null;
-      return result;
-    }
-    if (!parsed) return [];
-    const rows = parsed;
-    const ctx = {
-      values: void 0,
-      index: 0,
-      specs
-    };
-    for (let i = 0; i < rows.length; i++) {
-      ctx.values = rows[i];
-      ctx.index = 0;
-      rows[i] = selected.mapRow(ctx);
-    }
-    return rows ?? [];
-  };
-  get [internalSql]() {
-    return includeQuery(getData(this)).mapWith({
-      mapFromDriverValue: this.#mapFromDriverValue
-    });
-  }
-};
-function include(select) {
-  return new Include({ ...getData(select), first: false });
-}
-((include2) => {
-  function one(select) {
-    return new Include({
-      ...getData(select),
-      first: true
-    });
-  }
-  include2.one = one;
-})(include || (include = {}));
-function includeQuery(query) {
-  const { first, limit, offset, orderBy } = query;
-  const wrapQuery = Boolean(limit || offset || orderBy);
-  const innerQuery = selectQuery(query);
-  const inner = wrapQuery ? sql`select * from (${innerQuery}) as __` : innerQuery;
-  const fields = querySelection(query).fieldNames();
-  const subject = jsonArray(
-    ...fields.map((name) => sql`_.${sql.identifier(name)}`)
-  );
-  return sql`(select ${first ? subject : jsonAggregateArray(subject)} from (${inner}) as _)`;
-}
-
-// src/backend/api/DatabaseApi.ts
 import { HandleAction } from "../HandleAction.js";
 var UploadTable = table("alinea_upload", {
   entryId: varchar(void 0, { length: 27 }).primaryKey(),

package/dist/backend/api/database.js

@@ -1,8 +1,20 @@
 import {
   driver_exports
-} from "../../chunks/chunk-X47OVDF3.js";
-import "../../chunks/chunk-G6E35DMJ.js";
-import "../../chunks/chunk-NWQXN4SB.js";
+} from "../../chunks/chunk-2U43BB6P.js";
+import "../../chunks/chunk-A42DP5T7.js";
+import "../../chunks/chunk-NLZLRQ5U.js";
+import "../../chunks/chunk-IL7FJQAY.js";
+import "../../chunks/chunk-M7KDJEGH.js";
+import "../../chunks/chunk-N47Y62CI.js";
+import "../../chunks/chunk-QBPYWU6C.js";
+import "../../chunks/chunk-2BJ2IFQM.js";
+import "../../chunks/chunk-XCZXR3C2.js";
+import "../../chunks/chunk-TFMUSWGG.js";
+import "../../chunks/chunk-76VMZTLN.js";
+import "../../chunks/chunk-2PIFHEYR.js";
+import "../../chunks/chunk-K62JP6HR.js";
+import "../../chunks/chunk-ATF42T2B.js";
+import "../../chunks/chunk-ETBQTP2S.js";
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/backend/api/database.ts

package/dist/backend/resolver/ParsePreview.d.ts

@@ -1,9 +1,9 @@
-import type { LocalDB } from 'alinea/core/db/LocalDB';
 import { Entry } from 'alinea/core/Entry';
 import type { PreviewRequest, PreviewUpdate } from 'alinea/core/Preview';
+import type { Graph } from 'alinea/core/Graph';
 export interface DecodedEntryPreview {
     entry: Entry;
 }
 export type DecodedPreviewRequest = PreviewUpdate | DecodedEntryPreview;
 export declare function decodePreviewRequest(preview: PreviewRequest): Promise<DecodedPreviewRequest>;
-export declare function applyPreview(local: LocalDB, preview: DecodedPreviewRequest): Promise<PreviewRequest | undefined>;
+export declare function applyPreview(local: Graph, preview: DecodedPreviewRequest): Promise<PreviewRequest | undefined>;

package/dist/backend/router/NodeHandler.js

@@ -5,6 +5,8 @@ import { Headers, Request } from "@alinea/iso";
 import { TLSSocket } from "node:tls";
 async function writeReadableStreamToWritable(stream, writable) {
   const reader = stream.getReader();
+  writable.once("close", () => reader.cancel().catch(() => {
+  }));
   async function read() {
     const { done, value } = await reader.read();
     if (done) return writable.end();