@telepath-computer/vault-server 0.4.2 → 0.5.0

package/dist/src/server.d.ts

@@ -1,14 +1,13 @@
-/** Composes the vault HTTP API, filesystem watcher, and WebSocket subscriptions. */
-import { type Server } from "node:http";
-import express from "express";
-import { type RecordContent } from "./notes.ts";
+import { type IncomingMessage } from "node:http";
+import type { Duplex } from "node:stream";
+import { FileServer, type ListenOptions } from "@telepath-computer/file-server";
+import { type BodyFormat, type LinkFormat, type RecordContent } from "./notes.ts";
 /** A record in the form it will be stored, offered for approval before it is written. */
 export type ValidatedRecord = RecordContent & {
     path: string;
 };
 export type Validate = (record: ValidatedRecord) => void | Promise<void>;
-export type LinkFormat = "wikilink" | "markdown";
-export type BodyFormat = "markdown" | "raw";
+export type { BodyFormat, LinkFormat, ListenOptions };
 export type VaultServerOptions = {
     root: string;
     linkFormat?: LinkFormat;
@@ -17,48 +16,53 @@ export type VaultServerOptions = {
     jsonLimit?: string | number;
     pingIntervalMs?: number;
 };
+/** A file server with cached structured views for visible markdown files. */
 export declare class VaultServer {
-    readonly app: express.Express;
-    readonly server: Server;
-    /** Resolves once the watcher has indexed the vault and the root is known good. */
+    readonly app: FileServer["app"];
+    readonly server: FileServer["server"];
     readonly ready: Promise<void>;
-    private readonly root;
-    private readonly index;
+    private readonly files;
     private readonly validate;
-    private readonly watcher;
-    private readonly webSockets;
-    private readonly sockets;
-    private readonly pendingIndexRefreshes;
-    private readonly pendingWatcherEvents;
-    private readonly pingTimer;
-    private isReady;
-    private isClosing;
-    private startupRefreshFailed;
-    private startupRefreshError;
-    private boundHost;
+    private readonly maximumJsonBytes;
+    private readonly activeChanges;
+    private readonly changesByPath;
+    private readonly bootstrapPathGenerations;
+    private readonly directories;
+    private readonly pathView;
+    private root;
+    private index;
+    private linkFormat;
+    private bodyFormat;
+    private resolveIndex;
+    private readonly indexAvailable;
+    private changeGeneration;
+    private bootstrapComplete;
     constructor(options: VaultServerOptions);
-    /** The address the server is bound to, or undefined before listening. */
+    /** The URL currently bound, or undefined before listening and after closing. */
     get url(): string | undefined;
-    /** The port actually bound, which for port 0 is the one the OS chose. */
+    /** The port currently bound, including an operating-system-selected port. */
     get port(): number | undefined;
-    /** Every visible disk path currently held by the live index. */
+    /** Every visible regular-file disk path currently held by the live index. */
     get paths(): Iterable<string>;
-    /** Replace runtime formatting settings, rebuilding data derived from bodies. */
+    /** Replace runtime formatting settings, rebuilding data derived from bodies synchronously. */
     configure(options: {
         linkFormat?: LinkFormat;
         bodyFormat?: BodyFormat | ((path: string) => BodyFormat);
     }): void;
-    /** Accept connections, once the vault is indexed. Resolves with the server. */
-    listen(options?: {
-        host?: string;
-        port?: number;
-    }): Promise<this>;
+    /** Start accepting connections after the base watcher and record index are ready. */
+    listen(options?: ListenOptions): Promise<this>;
+    /** Release the embedded file server resources. */
     close(): Promise<void>;
-    private context;
-    private readonly runMutation;
-    private emitEvent;
-    private handleWatcherChange;
-    private flushWatcherEvent;
-    private cancelPendingWatcherEvent;
-    private refreshIndex;
+    /** Delegate a mount-relative WebSocket upgrade after the record index is ready. */
+    handleUpgrade(request: IncomingMessage, socket: Duplex, head: Buffer, requestTarget?: string): Promise<void>;
+    private bootstrap;
+    private refreshTree;
+    private bootstrapGenerationFor;
+    private drainBootstrapChanges;
+    private handle;
+    private mutateRecord;
+    private approve;
+    private change;
+    private refreshChange;
+    private forgetDirectoryTree;
 }