@chance722/dsh-inbox 0.1.0

package/lib/types/host/s3/client.d.ts

@@ -0,0 +1,216 @@
+/**
+ * The smallest S3 surface the inbox needs: list one prefix, read one object.
+ *
+ * Signing is implemented rather than imported. A dependency would be the
+ * obvious move, but this is ~60 lines of well-specified HMAC chaining, and the
+ * alternative is shipping a second network stack inside a vault plugin whose
+ * whole point is that nothing unexpected leaves the machine.
+ *
+ * Assumptions that keep it small, each of them honest about its limit:
+ *   - **path-style** addressing (`<endpoint>/<bucket>/<key>`), which is what
+ *     non-AWS S3 deployments such as 数据胶囊 accept;
+ *   - **SigV4** (`AWS4-HMAC-SHA256`), with the region configurable because the
+ *     signature covers it even when the server ignores it;
+ *   - `UNSIGNED-PAYLOAD` is *not* used: every body we send is empty, so the
+ *     payload hash is the SHA-256 of nothing.
+ */
+/** What the user fills in. The secret never lives here. */
+export interface S3Config {
+    /** e.g. `https://s3.cstcloud.cn` — no bucket, no trailing slash needed. */
+    endpoint: string;
+    bucket: string;
+    /** Covered by the signature; defaults to `us-east-1` for non-AWS servers. */
+    region?: string;
+    /** Only v4 is implemented; the field exists so the choice is visible. */
+    signatureVersion?: string;
+    /** What to send as `User-Agent`; empty falls back to the plugin's own. */
+    userAgent?: string;
+}
+/**
+ * The identity this request presents.
+ *
+ * Not cosmetic: 数据胶囊 binds an access key to an application and answers
+ * every request that does not claim to be that application with a body-less
+ * 401 — identical, from the outside, to a wrong secret. The signature never
+ * covers this header, so it can be set freely.
+ *
+ * @param config - endpoint, bucket, region, optional user agent.
+ * @returns the header value to send.
+ */
+export declare function userAgentOf(config: S3Config): string;
+/** One object found under the prefix. */
+export interface RemoteObject {
+    key: string;
+    lastModified?: string;
+    bytes?: number;
+}
+/** The subset of `fetch` this module uses, so tests can stand in for it. */
+export interface S3ResponseLike {
+    ok: boolean;
+    status: number;
+    text(): Promise<string>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    headers?: {
+        get(name: string): string | null;
+    };
+}
+export type S3FetchLike = (url: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body?: Uint8Array;
+}) => Promise<S3ResponseLike>;
+/** Everything a call needs besides the configuration. */
+export interface S3Deps {
+    fetch: S3FetchLike;
+    accessKeyId: string;
+    accessKeySecret: string;
+    /** Injected so tests are not clock-dependent. */
+    now?: Date;
+}
+/** `YYYYMMDDTHHMMSSZ`, the only date format SigV4 accepts. */
+export declare function amzDate(now: Date): string;
+/** The pieces of a signed request, exposed so a test can look at them. */
+export interface SignedRequest {
+    url: string;
+    headers: Record<string, string>;
+    canonicalRequest: string;
+    signature: string;
+}
+/** `RFC 1123` date, the only one SigV2 accepts. */
+export declare function rfc1123(now: Date): string;
+/**
+ * Sign one request with **SigV2**.
+ *
+ * Not legacy for its own sake: gateways that describe their older clients as
+ * needing "SSL/TLS and path-style addressing" are usually v2-only, and a v4
+ * request to one of them is answered with a bare 401 — which is exactly the
+ * shape of the failure this implementation exists to fix.
+ *
+ * SigV2 signs a different thing than v4: the date, the content type, and the
+ * *canonicalized resource* — and only the query parameters on the sub-resource
+ * list take part, not ordinary ones like `prefix`.
+ *
+ * @param config - endpoint, bucket, region.
+ * @param deps - credentials, fetch, clock.
+ * @param method - HTTP method.
+ * @param key - object key, empty for a bucket operation.
+ * @param query - query parameters.
+ * @returns the URL, headers, and the string that was signed.
+ */
+export declare function signRequestV2(config: S3Config, deps: S3Deps, method: string, key: string, query?: Record<string, string>): SignedRequest & {
+    stringToSign: string;
+};
+/**
+ * Sign one request.
+ *
+ * @param config - endpoint, bucket, region.
+ * @param deps - credentials, fetch, clock.
+ * @param method - HTTP method.
+ * @param key - object key, empty for a bucket operation.
+ * @param query - query parameters, already encoded values.
+ * @returns the URL, headers, and the intermediate values (for tests).
+ */
+export declare function signRequest(config: S3Config, deps: S3Deps, method: string, key: string, query?: Record<string, string>, 
+/**
+ * The bytes a write is about to send.
+ *
+ * SigV4 signs the *payload*: a PUT signed as if it were empty is refused by
+ * every strict gateway, which is why reads (no body) and writes (a body) must
+ * go through the same function with the difference made explicit.
+ */
+body?: Uint8Array): SignedRequest;
+/**
+ * SigV4 with the **minimum** signed headers: `host` and `x-amz-date` only.
+ *
+ * The full form also signs `x-amz-content-sha256`, which is what AWS expects.
+ * A gateway that implements a subset of v4 recomputes the canonical request
+ * from the two headers it knows and then rejects every signature we send —
+ * which is indistinguishable from a wrong key until you try this.
+ *
+ * @param config - endpoint, bucket, region.
+ * @param deps - credentials, fetch, clock.
+ * @param method - HTTP method.
+ * @param key - object key.
+ * @param query - query parameters.
+ * @returns the signed request.
+ */
+export declare function signRequestV4Minimal(config: S3Config, deps: S3Deps, method: string, key: string, query?: Record<string, string>): SignedRequest;
+/**
+ * SigV4 with **`UNSIGNED-PAYLOAD`** as the content hash — what the official SDKs
+ * send for a GET over HTTPS.
+ *
+ * This is the third and last shape worth trying: the full form signs the hash of
+ * the empty body, the minimal form omits the header, and this one declares the
+ * payload deliberately unsigned. A gateway that validates the *value* rather
+ * than recomputing it accepts only this one.
+ *
+ * @param config - endpoint, bucket, region.
+ * @param deps - credentials, fetch, clock.
+ * @param method - HTTP method.
+ * @param key - object key.
+ * @param query - query parameters.
+ * @returns the signed request.
+ */
+export declare function signRequestUnsignedPayload(config: S3Config, deps: S3Deps, method: string, key: string, query?: Record<string, string>): SignedRequest;
+/**
+ * Read a ListObjectsV2 answer.
+ *
+ * @param xml - the response body.
+ * @returns the objects it listed.
+ */
+export declare function parseListing(xml: string): RemoteObject[];
+/**
+ * List objects under a prefix.
+ *
+ * Tries ListObjects **V2** first and falls back to **V1** when the server
+ * refuses it. Both answer with the same `<Contents>` shape, so the parser does
+ * not care; what differs is that plenty of gateways implement only V1 and
+ * answer a `list-type=2` request with a server error rather than an S3 error —
+ * which is exactly the shape of a 500 that says "unknown runtime exception".
+ *
+ * @param config - endpoint, bucket, region.
+ * @param prefix - key prefix, e.g. `inbox/`.
+ * @param deps - credentials, fetch, clock.
+ * @returns the objects found.
+ */
+export declare function listPrefix(config: S3Config, prefix: string, deps: S3Deps): Promise<RemoteObject[]>;
+/** Fetch one object's bytes, with its content type when the server sends one. */
+export declare function readObject(config: S3Config, key: string, deps: S3Deps): Promise<{
+    bytes: Uint8Array;
+    contentType: string;
+}>;
+/**
+ * Write one object.
+ *
+ * The payload goes into the signature (see {@link signRequest}), which is the
+ * one thing that makes a write different from every read this client has done
+ * until now: a gateway that checks the payload hash refuses a PUT signed as if
+ * it had no body. `content-length` and `content-type` ride along unsigned —
+ * they are not part of `signedHeaders`, and servers accept exactly that.
+ *
+ * @param config - endpoint, bucket, region, signature version.
+ * @param key - object key.
+ * @param body - the bytes to store.
+ * @param deps - credentials, fetch, clock.
+ * @param contentType - what the bytes are, when the caller knows.
+ */
+export declare function putObject(config: S3Config, key: string, body: Uint8Array, deps: S3Deps, contentType?: string): Promise<void>;
+/**
+ * Remove one object.
+ *
+ * Idempotent on purpose: S3 answers 204 for a key that was never there, and the
+ * callers here delete objects they *believe* exist (a record's files, an
+ * attachment's bytes) — a missing one is the state they wanted, not a failure.
+ *
+ * @param config - endpoint, bucket, region, signature version.
+ * @param key - object key.
+ * @param deps - credentials, fetch, clock.
+ */
+export declare function deleteObject(config: S3Config, key: string, deps: S3Deps): Promise<void>;
+/**
+ * Pick the signer for a configuration.
+ *
+ * @param config - endpoint, bucket, region, signatureVersion.
+ * @returns the signer to use.
+ */
+export declare function signer(config: S3Config): (config: S3Config, deps: S3Deps, method: string, key: string, query?: Record<string, string>, body?: Uint8Array) => SignedRequest;

package/lib/types/host/s3/probe.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A connection self-test that tries every shape of request a list could take.
+ *
+ * Guessing at a gateway's quirks from a single 500 costs one round trip per
+ * guess. Asking it five questions at once costs one, and the answer says which
+ * shape it accepts — or, when none work, that the problem is not the shape.
+ *
+ * Read-only by construction: every probe is a GET, and none of them write.
+ */
+import { type S3Config, type S3Deps } from './client.js';
+/** One probe's outcome. */
+export interface ProbeResult {
+    /** What this probe asked for, in Chinese. */
+    label: string;
+    url: string;
+    status: number;
+    /** A short excerpt of the answer: the code that explains a refusal. */
+    detail: string;
+}
+/**
+ * Ask the gateway a handful of questions that differ only in shape.
+ *
+ * @param config - endpoint, bucket, region, signature version.
+ * @param deps - credentials, fetch, clock.
+ * @param prefix - the configured prefix, so its handling is under test too.
+ * @returns one result per probe, in the order they were tried.
+ */
+export declare function probeS3(config: S3Config, deps: S3Deps, prefix: string): Promise<ProbeResult[]>;

package/lib/types/host/tools.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The model-facing tools: what the vault looks like from inside a conversation.
+ *
+ * Two rules shape every string these tools return.
+ *
+ * 1. **Credentials never leave the vault.** A record classified as `secret`
+ *    answers with a refusal, not with its text — the model must not be able to
+ *    read one out by asking, and the session log must not collect it.
+ * 2. **Attachment bytes stay in the vault by default.** A tool result is model
+ *    visible and persisted, so an image is described by a marker the panel and
+ *    the tool card resolve locally; the picture itself is not part of the
+ *    result. That keeps a pasted ID document out of the cloud even when the
+ *    model is the one that fetched the record. The single exception is
+ *    `inbox_get` with `withImage: true` — the user asking "look at the picture
+ *    and tell me what it is" is a request the model cannot honour otherwise,
+ *    and it is opt-in per call, by name, never the default.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type AttachmentSummary, type EntrySummary } from '../shared/panel-wire.js';
+import type { Item } from './vault/spec.js';
+import type { Vault } from './vault/vault.js';
+/** How many records one search answers with before saying "there are more". */
+export declare const SEARCH_PAGE = 10;
+/** How much of a stored text the model reads; the rest stays in the vault. */
+export declare const TEXT_BUDGET = 1000;
+/** Marker the tool card turns into a thumbnail; the bytes stay off the wire. */
+export declare function attachmentMarker(attachmentId: string): string;
+/**
+ * Render a search answer.
+ *
+ * @param entries - the page of matches, newest first.
+ * @param matched - how many records matched in total.
+ * @returns the model-facing text.
+ */
+export declare function formatSearch(entries: readonly Item[], matched: number, 
+/** The image marker a line should carry, when the caller can find one. */
+pictureOf?: (item: Item) => string | undefined): string;
+/**
+ * Render one record in full, under the two rules above.
+ *
+ * @param vault - the open vault, for attachment metadata.
+ * @param item - the record to describe.
+ * @returns the model-facing text.
+ */
+export declare function formatDetail(vault: Vault, item: Item): string;
+/** Project one record down to what a card needs (kept for the card contract). */
+export declare function summaryOf(item: Item): EntrySummary;
+/** Attachment summary projection, shared with the panel wire. */
+export declare function attachmentsOf(vault: Vault, item: Item): AttachmentSummary[];
+/**
+ * Register the vault's model-facing tools.
+ *
+ * @param ctx - host context carrying the tool registry.
+ * @param vault - reads the currently open vault, which may not be open yet.
+ */
+export declare function registerInboxTools(ctx: Context, vault: () => Vault | undefined): void;

package/lib/types/host/ui/config.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The panel's own preferences — how it looks, not what it holds.
+ *
+ * Deliberately a namespace of its own rather than more fields on the remote
+ * namespace: "which WebDAV server do I pull from" and "how dense should the
+ * list be" are different questions that happen to share a storage service, and
+ * merging them would make the remote config the home of unrelated UI state.
+ *
+ * It lives in dsh's settings (not `localStorage`) for the same reason the
+ * theme's font size does: a preference is user state, and the user should find
+ * it where they find their other settings.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { type UiPrefs } from '../../shared/panel-wire.js';
+/** Namespace this plugin owns for panel preferences. */
+export declare const UI_SETTINGS_NAMESPACE = "dsh-inbox-ui";
+/** What a fresh install looks like: two columns of cards, the roomier of the two. */
+export declare const DEFAULT_UI_PREFS: UiPrefs;
+/** The namespace's schema; every field optional so a partial layer is valid. */
+export declare const UiPrefsSchema: z<Schemastery.ObjectS<{
+    listMode: z<"grid" | "compact", "grid" | "compact">;
+}>, Schemastery.ObjectT<{
+    listMode: z<"grid" | "compact", "grid" | "compact">;
+}>>;
+/**
+ * Declare the namespace. Registering more than once in a process throws, so a
+ * second activation of the plugin simply keeps the first declaration.
+ *
+ * @param ctx - host context.
+ */
+export declare function installUiSettings(ctx: Context): void;
+/**
+ * Read the panel preferences, falling back to the defaults.
+ *
+ * @param ctx - host context.
+ * @returns the preferences, plus whether a settings service was there at all.
+ */
+export declare function readUiPrefs(ctx: Context): UiPrefs & {
+    settingsAvailable: boolean;
+};
+/**
+ * Persist a preference change.
+ *
+ * @param ctx - host context.
+ * @param patch - what to change; an absent field changes nothing.
+ * @returns whether the write went through, and why not when it did not.
+ */
+export declare function saveUiPrefs(ctx: Context, patch: {
+    listMode?: string;
+}): {
+    ok: boolean;
+    reason?: string;
+};

package/lib/types/host/vault/lease.d.ts

@@ -0,0 +1,54 @@
+/**
+ * One vault per process, however many times this plugin gets loaded.
+ *
+ * dsh composes the plugin **twice**: the profile bundle gives the host half (the
+ * panel needs it there), and the agent preset lists it again so a session's
+ * assistant can see `inbox_search` / `inbox_get` — the tool registry is
+ * per-session, so a plugin that is only in the profile is invisible to the
+ * model. Two loads, one process, and `ctx.storageDomain` enforces **single-open
+ * per domain name** (`DomainError: domain 'dsh_inbox' is already open`, thrown
+ * from the facility's `reserved` set). The second instance therefore failed to
+ * open and every tool it registered answered 「仓库没有打开」 — measured
+ * 2026-09-20 in a real session, with the panel working fine at the same time
+ * (that one was the profile instance, holding the domain).
+ *
+ * So the domain is a process resource, not a per-instance one. The first caller
+ * opens it and becomes the owner; every later caller borrows the same {@link Vault}
+ * and the last release closes it. Two consequences worth knowing:
+ *
+ * - **One vault, one key.** The panel's unlock and the conversation tools now
+ *   share the in-memory key, which is what "unlock once" always meant.
+ * - **The pull on open happens once per process**, for whoever opened it. Every
+ *   later session starts against the same live data, and 「刷新」 is still the
+ *   way to pull again.
+ *
+ * The registry lives on `globalThis` rather than module scope: two copies of the
+ * package (a versioned install plus a linked checkout, say) would otherwise each
+ * keep their own map and the collision would come back.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { Vault } from './vault.js';
+/**
+ * A consumer's claim on the process's vault.
+ *
+ * `current` is undefined while the domain is still loading and stays undefined
+ * when the open failed — a caller must report that, not pretend the vault is
+ * empty.
+ */
+export interface VaultLease {
+    /** The vault, once it is open. */
+    current(): Vault | undefined;
+    /** The failure message, when the open attempt ended badly. */
+    failure(): string | undefined;
+    /** Give the claim back; the last one out closes the vault. */
+    release(): Promise<void>;
+}
+/**
+ * Claim the process's vault, opening it if this is the first claim.
+ *
+ * @param ctx - host context carrying the storage domain facility.
+ * @param onOpened - called once, by the instance that actually opened the
+ *   domain (the first one), for work that belongs to "the vault just came up".
+ * @returns the lease; the caller releases it from its own disposer.
+ */
+export declare function leaseVault(ctx: Context, onOpened?: (vault: Vault) => void): VaultLease;

package/lib/types/host/vault/query.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Pure filtering over items.
+ *
+ * The official storage form is a key-value domain with no query language, so
+ * selection is an in-memory pass. At this vault's scale (thousands of records)
+ * that is the right trade: no index to build, no migration to run, and the
+ * whole rule set is testable without any storage at all.
+ */
+import type { Category, Kind } from '../../shared/vocabulary.js';
+import type { Item } from './spec.js';
+export interface ItemQuery {
+    /** Case-insensitive substring match over title, linkTitle, text, url, note and tags. */
+    text?: string;
+    categories?: readonly Category[];
+    kinds?: readonly Kind[];
+    /** Filter to records flagged 待看 (or explicitly to those not flagged). */
+    watchLater?: boolean;
+    /** Every listed tag must be present (AND). */
+    tags?: readonly string[];
+    /** Soft-deleted items are excluded unless this is true. */
+    includeDeleted?: boolean;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Select and order items.
+ *
+ * Newest first — a vault is read as a timeline far more often than as an
+ * alphabetical list. `limit`/`offset` apply after ordering, so paging is stable
+ * as long as nothing is written in between.
+ *
+ * @param items - the candidate records, in any order.
+ * @param query - filters, paging and ordering input.
+ * @returns the matching records, newest first.
+ */
+export declare function selectItems(items: readonly Item[], query?: ItemQuery): Item[];
+/** Count the records flagged 待看 — the number the sidebar badge would show. */
+export declare function countWatchLater(items: readonly Item[]): number;

package/lib/types/host/vault/spec.d.ts

@@ -0,0 +1,193 @@
+/**
+ * The vault's domain declaration: identity, version, layout, and the zod
+ * schemas every stored record must satisfy.
+ *
+ * Layout is `per-record` — one document per item — for two reasons that matter
+ * to a personal vault: a write only rewrites the item it touched, and a single
+ * damaged document cannot take the whole vault down with it.
+ *
+ * The default invalid-record behaviour is kept (the whole `open` rejects),
+ * because these records are authoritative user data: silently skipping one
+ * would hide a real problem. Additive schema changes should extend
+ * `compatibleVersions` instead of loosening this.
+ */
+import { z } from 'zod';
+export declare const itemSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        link: "link";
+        text: "text";
+        image: "image";
+        file: "file";
+    }>;
+    category: z.ZodEnum<{
+        image: "image";
+        idea: "idea";
+        article: "article";
+        media: "media";
+        document: "document";
+        secret: "secret";
+        other: "other";
+    }>;
+    categorySource: z.ZodOptional<z.ZodEnum<{
+        rule: "rule";
+        model: "model";
+        user: "user";
+    }>>;
+    watchLater: z.ZodOptional<z.ZodBoolean>;
+    source: z.ZodEnum<{
+        panel: "panel";
+        chat: "chat";
+        webdav: "webdav";
+        import: "import";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    linkTitle: z.ZodOptional<z.ZodString>;
+    linkTitleError: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodString>;
+    secretDigest: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+    deletedAt: z.ZodOptional<z.ZodString>;
+    tags: z.ZodArray<z.ZodString>;
+    attachmentIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const attachmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    storeId: z.ZodString;
+    mime: z.ZodString;
+    bytes: z.ZodNumber;
+    createdAt: z.ZodString;
+    filename: z.ZodOptional<z.ZodString>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    sha256: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * One global slot per domain. Sync state lives here because it belongs to the
+ * vault as a whole, not to any item; M6 fills it in.
+ */
+export declare const vaultGlobalSchema: z.ZodObject<{
+    sync: z.ZodObject<{
+        lastPullAt: z.ZodOptional<z.ZodString>;
+        lastPushAt: z.ZodOptional<z.ZodString>;
+        cursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    master: z.ZodOptional<z.ZodObject<{
+        version: z.ZodNumber;
+        salt: z.ZodString;
+        kdf: z.ZodObject<{
+            n: z.ZodNumber;
+            r: z.ZodNumber;
+            p: z.ZodNumber;
+        }, z.core.$strip>;
+        verifier: z.ZodString;
+    }, z.core.$strip>>;
+    model: z.ZodOptional<z.ZodObject<{
+        day: z.ZodString;
+        calls: z.ZodNumber;
+        tokens: z.ZodNumber;
+        last: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Item = z.infer<typeof itemSchema>;
+export type Attachment = z.infer<typeof attachmentSchema>;
+export type VaultGlobal = z.infer<typeof vaultGlobalSchema>;
+/**
+ * Domain name doubles as the backend unit name: `<DSH_HOME>/storages/dsh_inbox/…`.
+ * `defineDomain` enforces `/^[a-z][a-z0-9_]*$/` at module load — no hyphens.
+ */
+export declare const vaultSpec: {
+    name: string;
+    /**
+     * Version 2 added the optional `categorySource`; version 3 swaps
+     * `status` for `watchLater` and drops the `待看` tag. Both older shapes still
+     * validate — the removed `status` key is simply ignored, and `watchLater` is
+     * optional — and `Vault.open` rewrites them once so the flag is real.
+     *
+     * Version 4 adds the optional `linkTitle` (the fetched page headline). It is
+     * a pure addition, so every older record still validates unchanged.
+     * Version 4 adds the optional `linkTitle` (the fetched page headline), version
+     * 5 the optional `linkTitleError` that explains a miss. Both are pure
+     * additions, so every older record still validates unchanged.
+     *
+     * Version 6 adds the optional `secret` / `secretDigest`: a credential's text
+     * moves out of `text` and into a sealed envelope. Also a pure addition — a
+     * version-5 record with plaintext simply gets migrated on the next unlock.
+     *
+     * Version 7 adds `sync.lastPushAt`: the cursor that keeps a push to "what
+     * changed since last time" instead of re-uploading the vault on every pass.
+     * A `global` field, so no record shape changes at all.
+     */
+    version: number;
+    compatibleVersions: number[];
+    layout: "per-record";
+    global: {
+        schema: z.ZodObject<{
+            sync: z.ZodObject<{
+                lastPullAt: z.ZodOptional<z.ZodString>;
+                lastPushAt: z.ZodOptional<z.ZodString>;
+                cursor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            master: z.ZodOptional<z.ZodObject<{
+                version: z.ZodNumber;
+                salt: z.ZodString;
+                kdf: z.ZodObject<{
+                    n: z.ZodNumber;
+                    r: z.ZodNumber;
+                    p: z.ZodNumber;
+                }, z.core.$strip>;
+                verifier: z.ZodString;
+            }, z.core.$strip>>;
+            model: z.ZodOptional<z.ZodObject<{
+                day: z.ZodString;
+                calls: z.ZodNumber;
+                tokens: z.ZodNumber;
+                last: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        initial: {
+            sync: {};
+        };
+    };
+    tables: {
+        items: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            id: string;
+            kind: "link" | "text" | "image" | "file";
+            category: "image" | "idea" | "article" | "media" | "document" | "secret" | "other";
+            source: "panel" | "chat" | "webdav" | "import";
+            createdAt: string;
+            updatedAt: string;
+            tags: string[];
+            attachmentIds: string[];
+            categorySource?: "rule" | "model" | "user" | undefined;
+            watchLater?: boolean | undefined;
+            title?: string | undefined;
+            linkTitle?: string | undefined;
+            linkTitleError?: string | undefined;
+            text?: string | undefined;
+            secret?: string | undefined;
+            secretDigest?: string | undefined;
+            url?: string | undefined;
+            platform?: string | undefined;
+            note?: string | undefined;
+            deletedAt?: string | undefined;
+        }>;
+        attachments: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            id: string;
+            storeId: string;
+            mime: string;
+            bytes: number;
+            createdAt: string;
+            filename?: string | undefined;
+            width?: number | undefined;
+            height?: number | undefined;
+            sha256?: string | undefined;
+        }>;
+    };
+};
+export type VaultSpec = typeof vaultSpec;