dscs-server 0.0.0-stage → 0.0.1

package/dist/shared/chain.js

@@ -0,0 +1,139 @@
+import { sha256 } from './crypto.js';
+const HASH_PATTERN = /^[0-9a-f]{64}$/u;
+export function assertChain(chain) {
+    chain.forEach((frame, position)=>{
+        if (frame.index !== position) throw new Error(`第 ${position} 帧的下标是 ${frame.index}，链不连续`);
+        if (!HASH_PATTERN.test(frame.chainHash)) throw new Error(`第 ${position} 帧的 chainHash 不是 64 位十六进制`);
+        if (!Number.isSafeInteger(frame.seqFrom) || !Number.isSafeInteger(frame.seqTo)) throw new Error(`第 ${position} 帧的 seq 不是整数`);
+        if (position === 0) {
+            if (frame.seqFrom !== -1 || frame.seqTo !== -1) throw new Error('header 帧的 seq 必须是 -1');
+            return;
+        }
+        const previous = chain[position - 1];
+        if (frame.seqFrom < 0 || frame.seqTo < frame.seqFrom) throw new Error(`第 ${position} 帧的 seq 区间非法`);
+        if (previous.seqTo + 1 !== frame.seqFrom) {
+            throw new Error(`第 ${position} 帧的 seq 应从 ${previous.seqTo + 1} 开始，实际是 ${frame.seqFrom}`);
+        }
+    });
+}
+export function commonPrefix(local, remote) {
+    let index = 0;
+    while(index < local.length && index < remote.length && local[index].chainHash === remote[index].chainHash)index += 1;
+    return index;
+}
+export function diffChains(local, remote) {
+    assertChain(local);
+    assertChain(remote);
+    const common = commonPrefix(local, remote);
+    const pull = remote.slice(common);
+    const push = local.slice(common);
+    if (pull.length === 0 && push.length === 0) return {
+        status: 'equal',
+        common,
+        pull,
+        push
+    };
+    if (push.length === 0) return {
+        status: 'remote-ahead',
+        common,
+        pull,
+        push
+    };
+    if (pull.length === 0) return {
+        status: 'local-ahead',
+        common,
+        pull,
+        push
+    };
+    if (pull.length === 1 && push.length === 1 && pull[0].index === push[0].index) {
+        return {
+            status: 'tail-mismatch',
+            common,
+            pull,
+            push
+        };
+    }
+    return {
+        status: 'diverged',
+        common,
+        pull,
+        push
+    };
+}
+export function buildManifest(input) {
+    input.frames.forEach((frame, position)=>{
+        if (frame.index !== position) throw new Error(`manifest 第 ${position} 条的 index 是 ${frame.index}`);
+        if (!HASH_PATTERN.test(frame.chainHash) || !HASH_PATTERN.test(frame.blobSha256)) throw new Error(`manifest 第 ${position} 条的哈希非法`);
+        if (frame.sealedVersion < 1) throw new Error(`manifest 第 ${position} 条的封帧版本非法`);
+    });
+    const last = input.frames[input.frames.length - 1];
+    const lastSeq = last === undefined ? -1 : last.seqTo;
+    return {
+        sessionId: input.sessionId,
+        formatVersion: input.formatVersion,
+        createdAt: input.createdAt,
+        lastSeq,
+        ...input.workspaceKey === undefined ? {} : {
+            workspaceKey: input.workspaceKey
+        },
+        ...input.tailOpen === undefined ? {} : {
+            tailOpen: input.tailOpen
+        },
+        ...input.safeThroughSeq === undefined ? {} : {
+            safeThroughSeq: input.safeThroughSeq
+        },
+        frames: input.frames,
+        updatedAt: input.updatedAt
+    };
+}
+export function assertManifest(manifest) {
+    manifest.frames.forEach((frame, position)=>{
+        if (frame.index !== position) throw new Error(`manifest 第 ${position} 条的 index 是 ${frame.index}`);
+        if (!HASH_PATTERN.test(frame.chainHash) || !HASH_PATTERN.test(frame.blobSha256)) throw new Error(`manifest 第 ${position} 条的哈希非法`);
+    });
+    const last = manifest.frames[manifest.frames.length - 1];
+    if ((last === undefined ? -1 : last.seqTo) !== manifest.lastSeq) throw new Error('manifest 的 lastSeq 与最后一帧不一致');
+    const safe = manifest.safeThroughSeq ?? manifest.lastSeq;
+    if (!Number.isSafeInteger(safe) || safe < -1 || safe > manifest.lastSeq) throw new Error('manifest 的 safeThroughSeq 非法');
+    if (manifest.workspaceKey !== undefined && !/^[A-Za-z0-9_-]{16,64}$/u.test(manifest.workspaceKey)) {
+        throw new Error('manifest 的 workspaceKey 非法');
+    }
+    if (manifest.tailOpen !== undefined && typeof manifest.tailOpen !== 'boolean') throw new Error('manifest 的 tailOpen 非法');
+}
+function canonical(value) {
+    if (Array.isArray(value)) return value.map((entry)=>canonical(entry));
+    if (value !== null && typeof value === 'object') {
+        const sorted = {};
+        for (const key of Object.keys(value).sort())sorted[key] = canonical(value[key]);
+        return sorted;
+    }
+    return value;
+}
+export function stableStringify(value) {
+    return JSON.stringify(canonical(value));
+}
+export function manifestDigest(manifest) {
+    return sha256(stableStringify({
+        sessionId: manifest.sessionId,
+        formatVersion: manifest.formatVersion,
+        createdAt: manifest.createdAt,
+        lastSeq: manifest.lastSeq,
+        workspaceKey: manifest.workspaceKey ?? null,
+        tailOpen: manifest.tailOpen ?? null,
+        safeThroughSeq: manifest.safeThroughSeq ?? manifest.lastSeq,
+        frames: manifest.frames.map((frame)=>({
+                index: frame.index,
+                chainHash: frame.chainHash,
+                blobSha256: frame.blobSha256,
+                bytes: frame.bytes,
+                sealedVersion: frame.sealedVersion,
+                keyId: frame.keyId,
+                seqFrom: frame.seqFrom,
+                seqTo: frame.seqTo
+            })),
+        deletedAt: manifest.deletedAt ?? null
+    }));
+}
+
+
+//# sourceURL=chain.ts

package/dist/shared/crypto.js

@@ -0,0 +1,70 @@
+import { createCipheriv, createDecipheriv, createHash, hkdfSync, randomBytes, scrypt, scryptSync } from 'node:crypto';
+export const KEY_BYTES = 32;
+export const NONCE_BYTES = 12;
+export const TAG_BYTES = 16;
+export const SALT_BYTES = 16;
+export const SCRYPT = {
+    N: 1 << 15,
+    r: 8,
+    p: 1
+};
+export function newSalt() {
+    return randomBytes(SALT_BYTES);
+}
+export function deriveMasterKey(passphrase, salt) {
+    return scryptSync(passphrase, salt, KEY_BYTES, {
+        ...SCRYPT,
+        maxmem: 128 * 1024 * 1024
+    });
+}
+export async function deriveMasterKeyAsync(passphrase, salt) {
+    return await new Promise((resolve, reject)=>{
+        scrypt(passphrase, salt, KEY_BYTES, {
+            ...SCRYPT,
+            maxmem: 128 * 1024 * 1024
+        }, (error, key)=>{
+            if (error !== null) reject(error);
+            else resolve(Buffer.from(key));
+        });
+    });
+}
+export function deriveSubkey(master, info) {
+    return Buffer.from(hkdfSync('sha256', master, Buffer.alloc(0), Buffer.from(info, 'utf8'), KEY_BYTES));
+}
+export function seal(key, plaintext, aad) {
+    const nonce = randomBytes(NONCE_BYTES);
+    const cipher = createCipheriv('aes-256-gcm', key, nonce);
+    cipher.setAAD(aad);
+    const body = Buffer.concat([
+        cipher.update(plaintext),
+        cipher.final()
+    ]);
+    return {
+        nonce,
+        ciphertext: Buffer.concat([
+            body,
+            cipher.getAuthTag()
+        ])
+    };
+}
+export function open(key, sealed, aad) {
+    if (sealed.ciphertext.length < TAG_BYTES) throw new Error('封装载荷比认证标签还短');
+    const body = sealed.ciphertext.subarray(0, sealed.ciphertext.length - TAG_BYTES);
+    const tag = sealed.ciphertext.subarray(sealed.ciphertext.length - TAG_BYTES);
+    const decipher = createDecipheriv('aes-256-gcm', key, sealed.nonce);
+    decipher.setAAD(aad);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([
+        decipher.update(body),
+        decipher.final()
+    ]);
+}
+export function sha256(data) {
+    return createHash('sha256').update(data).digest('hex');
+}
+export function randomId(bytes = 16) {
+    return randomBytes(bytes).toString('hex');
+}
+
+
+//# sourceURL=crypto.ts

package/dist/shared/frames.js

@@ -0,0 +1,102 @@
+import { createHash } from 'node:crypto';
+import { zstdCompressSync, zstdDecompressSync } from 'node:zlib';
+export const ZSTD_MAGIC = Buffer.from([
+    0x28,
+    0xb5,
+    0x2f,
+    0xfd
+]);
+export function isZstd(buffer) {
+    return buffer.length >= 4 && buffer.subarray(0, 4).equals(ZSTD_MAGIC);
+}
+export function zstdFrameEnd(buffer, offset) {
+    if (offset + 5 > buffer.length || !buffer.subarray(offset, offset + 4).equals(ZSTD_MAGIC)) {
+        throw new Error(`offset ${offset} 处不是 zstd 帧`);
+    }
+    const descriptor = buffer[offset + 4];
+    if ((descriptor & 8) !== 0) throw new Error('zstd 帧声明了保留位');
+    const singleSegment = (descriptor & 32) !== 0;
+    const contentSizeBytes = [
+        singleSegment ? 1 : 0,
+        2,
+        4,
+        8
+    ][descriptor >>> 6];
+    let cursor = offset + 5 + (singleSegment ? 0 : 1) + [
+        0,
+        1,
+        2,
+        4
+    ][descriptor & 3] + contentSizeBytes;
+    let last = false;
+    while(!last){
+        if (cursor + 3 > buffer.length) throw new Error('zstd 块头被截断');
+        const header = buffer.readUIntLE(cursor, 3);
+        const type = header >>> 1 & 3;
+        if (type === 3) throw new Error('zstd 块声明了保留类型');
+        last = (header & 1) !== 0;
+        cursor += 3 + (type === 1 ? 1 : header >>> 3);
+        if (cursor > buffer.length) throw new Error('zstd 块被截断');
+    }
+    if ((descriptor & 4) !== 0) cursor += 4;
+    if (cursor > buffer.length) throw new Error('zstd 校验和被截断');
+    return cursor;
+}
+export function splitFrames(buffer) {
+    const frames = [];
+    let offset = 0;
+    while(offset < buffer.length){
+        const end = zstdFrameEnd(buffer, offset);
+        frames.push(buffer.subarray(offset, end));
+        offset = end;
+    }
+    return frames;
+}
+export function decodeFrames(frames) {
+    return frames.map((frame)=>zstdDecompressSync(frame));
+}
+export function decodeLog(buffer) {
+    if (!isZstd(buffer)) return buffer.toString('utf8');
+    return Buffer.concat(decodeFrames(splitFrames(buffer))).toString('utf8');
+}
+export function splitRows(text) {
+    return text.split('\n').map((row)=>row.endsWith('\r') ? row.slice(0, -1) : row).filter((row)=>row.trim() !== '');
+}
+export function encodeLog(text, options = {}) {
+    const headerLines = options.headerLines ?? 1;
+    const rowsPerFrame = options.rowsPerFrame ?? 1;
+    const rows = splitRows(text);
+    if (rows.length === 0) return [];
+    const head = rows.slice(0, headerLines);
+    const frames = [
+        zstdCompressSync(Buffer.from(`${head.join('\n')}\n`, 'utf8'))
+    ];
+    let index = headerLines;
+    while(index < rows.length){
+        const chunk = rows.slice(index, index + rowsPerFrame);
+        frames.push(zstdCompressSync(Buffer.from(`${chunk.join('\n')}\n`, 'utf8')));
+        index += rowsPerFrame;
+    }
+    return frames;
+}
+export function joinFrames(frames) {
+    return Buffer.concat(frames);
+}
+export function hashFrame(frame) {
+    return createHash('sha256').update(frame).digest('hex');
+}
+export function readHeader(buffer) {
+    const text = isZstd(buffer) ? Buffer.concat(decodeFrames([
+        splitFrames(buffer)[0]
+    ])).toString('utf8') : buffer.toString('utf8');
+    const first = splitRows(text)[0];
+    if (first === undefined) throw new Error('会话日志为空');
+    const parsed = JSON.parse(first);
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('会话日志 header 不是 JSON 对象');
+    }
+    return parsed;
+}
+
+
+//# sourceURL=frames.ts

package/dist/shared/index.js

@@ -0,0 +1,11 @@
+export * from './batches.js';
+export * from './chain.js';
+export * from './crypto.js';
+export * from './frames.js';
+export * from './protocol.js';
+export * from './sealed-frame.js';
+export * from './vault.js';
+export * from './wire.js';
+
+
+//# sourceURL=index.ts

package/dist/shared/protocol.js

@@ -0,0 +1,14 @@
+export const API_PREFIX = '/v1';
+export const PROTOCOL_VERSION = 2;
+export function errorBody(code, message) {
+    return {
+        ok: false,
+        error: {
+            code,
+            message
+        }
+    };
+}
+
+
+//# sourceURL=protocol.ts

package/dist/shared/sealed-frame.js

@@ -0,0 +1,118 @@
+import { createCipheriv, createDecipheriv } from 'node:crypto';
+import { deriveSubkey, sha256, TAG_BYTES, KEY_BYTES, NONCE_BYTES } from './crypto.js';
+export const SEALED_MAGIC = Buffer.from('DSHF', 'ascii');
+export const SEALED_VERSION = 1;
+export const KEY_ID_BYTES = 8;
+export const SEALED_HEADER_BYTES = 4 + 1 + 1 + KEY_ID_BYTES + NONCE_BYTES;
+const FIXED_NONCE = Buffer.alloc(NONCE_BYTES);
+export function sessionKeyOf(master, sessionId) {
+    return deriveSubkey(master, `v1|session:${sessionId}`);
+}
+export function frameKeyOf(sessionKey, chainHash) {
+    return deriveSubkey(sessionKey, `v1|frame:${chainHash}`);
+}
+export function keyIdOf(sessionKey) {
+    return deriveSubkey(sessionKey, 'v1|key-id').subarray(0, KEY_ID_BYTES);
+}
+const SEQ_HEADER = 0xffffffff;
+function buildAad(header, position) {
+    const session = Buffer.from(position.sessionId, 'utf8');
+    if (session.length > 0xffff) throw new Error('会话 id 过长，AAD 无法编码');
+    const tail = Buffer.alloc(2 + session.length + 8 + 4 + 4 + 32);
+    tail.writeUInt16BE(session.length, 0);
+    session.copy(tail, 2);
+    let offset = 2 + session.length;
+    tail.writeBigUInt64BE(BigInt(position.index), offset);
+    offset += 8;
+    tail.writeUInt32BE(position.seqFrom < 0 ? SEQ_HEADER : position.seqFrom, offset);
+    offset += 4;
+    tail.writeUInt32BE(position.seqTo < 0 ? SEQ_HEADER : position.seqTo, offset);
+    offset += 4;
+    Buffer.from(position.chainHash, 'hex').copy(tail, offset);
+    return Buffer.concat([
+        header,
+        tail
+    ]);
+}
+export function sealFrame(plain, position, sessionKey) {
+    if (sessionKey.length !== KEY_BYTES) throw new Error(`会话密钥必须是 ${KEY_BYTES} 字节`);
+    if (!Number.isSafeInteger(position.index) || position.index < 0) throw new Error('帧下标必须是非负整数');
+    const chainHash = sha256(plain);
+    const frameKey = frameKeyOf(sessionKey, chainHash);
+    const keyId = keyIdOf(sessionKey);
+    const header = Buffer.alloc(SEALED_HEADER_BYTES);
+    SEALED_MAGIC.copy(header, 0);
+    header.writeUInt8(SEALED_VERSION, 4);
+    header.writeUInt8(0, 5);
+    keyId.copy(header, 6);
+    FIXED_NONCE.copy(header, 14);
+    const aad = buildAad(header, {
+        ...position,
+        chainHash
+    });
+    const cipher = createCipheriv('aes-256-gcm', frameKey, FIXED_NONCE);
+    cipher.setAAD(aad);
+    const body = Buffer.concat([
+        cipher.update(plain),
+        cipher.final()
+    ]);
+    const bytes = Buffer.concat([
+        header,
+        body,
+        cipher.getAuthTag()
+    ]);
+    return {
+        bytes,
+        ref: {
+            index: position.index,
+            chainHash,
+            blobSha256: sha256(bytes),
+            bytes: bytes.length,
+            sealedVersion: SEALED_VERSION,
+            keyId: keyId.toString('hex'),
+            seqFrom: position.seqFrom,
+            seqTo: position.seqTo
+        }
+    };
+}
+export function parseSealedHeader(sealed) {
+    if (sealed.length < SEALED_HEADER_BYTES + TAG_BYTES) throw new Error('封帧字节被截断');
+    if (!sealed.subarray(0, 4).equals(SEALED_MAGIC)) throw new Error('不是 DSHF 封帧');
+    const version = sealed.readUInt8(4);
+    if (version !== SEALED_VERSION) throw new Error(`不支持的封帧版本：${version}`);
+    return {
+        version,
+        flags: sealed.readUInt8(5),
+        keyId: sealed.subarray(6, 6 + KEY_ID_BYTES),
+        nonce: sealed.subarray(14, 14 + NONCE_BYTES)
+    };
+}
+export function openSealedFrame(sealed, position, sessionKey) {
+    const header = parseSealedHeader(sealed);
+    const expectedKeyId = keyIdOf(sessionKey);
+    if (!header.keyId.equals(expectedKeyId)) {
+        throw new Error('封帧的 keyId 与当前密钥不符（请确认各设备同步口令、服务端地址与 salt 一致）');
+    }
+    const headerBytes = sealed.subarray(0, SEALED_HEADER_BYTES);
+    const aad = buildAad(headerBytes, position);
+    const body = sealed.subarray(SEALED_HEADER_BYTES, sealed.length - TAG_BYTES);
+    const tag = sealed.subarray(sealed.length - TAG_BYTES);
+    const frameKey = frameKeyOf(sessionKey, position.chainHash);
+    const decipher = createDecipheriv('aes-256-gcm', frameKey, header.nonce);
+    decipher.setAAD(aad);
+    decipher.setAuthTag(tag);
+    let plain;
+    try {
+        plain = Buffer.concat([
+            decipher.update(body),
+            decipher.final()
+        ]);
+    } catch  {
+        throw new Error('封帧认证失败（密文、AAD 或密钥不匹配）');
+    }
+    if (sha256(plain) !== position.chainHash) throw new Error('明文哈希与清单不符');
+    return plain;
+}
+
+
+//# sourceURL=sealed-frame.ts

package/dist/shared/vault.js

@@ -0,0 +1,210 @@
+import { createCipheriv, createDecipheriv, createHmac } from 'node:crypto';
+import { stableStringify } from './chain.js';
+import { deriveSubkey, KEY_BYTES, NONCE_BYTES, sha256, TAG_BYTES } from './crypto.js';
+export const VAULT_SCHEMA = 'dsh-session-cloudsync/vault/1';
+export const VAULT_FORMAT_VERSION = 1;
+export const VAULT_KEY_ID_BYTES = 8;
+export const WORKSPACE_KEY_CHARS = 24;
+export const VAULT_GENESIS_HASH = null;
+const FIXED_NONCE = Buffer.alloc(NONCE_BYTES);
+const HASH_PATTERN = /^[0-9a-f]{64}$/u;
+const KEY_ID_PATTERN = /^[0-9a-f]{16}$/u;
+const KIND_PATTERN = /^[a-z][a-z0-9-]*\/[a-z][a-z0-9-]*$/u;
+export function vaultKeyOf(master) {
+    assertKey(master, 'masterKey');
+    return deriveSubkey(master, 'dsh-sync/vault/v1');
+}
+export function vaultKeyIdOf(vaultKey) {
+    assertKey(vaultKey, 'vaultKey');
+    return deriveSubkey(vaultKey, 'v1|key-id').subarray(0, VAULT_KEY_ID_BYTES).toString('hex');
+}
+export function workspaceKeyOf(vaultKey, canonicalPath) {
+    assertKey(vaultKey, 'vaultKey');
+    if (canonicalPath.trim() === '') throw new Error('canonical workspace path 不能为空');
+    return createHmac('sha256', vaultKey).update(`workspace|${canonicalPath}`, 'utf8').digest('base64url').slice(0, WORKSPACE_KEY_CHARS);
+}
+export function sealVaultRecord(input) {
+    assertKey(input.vaultKey, 'vaultKey');
+    assertWriter(input.writer);
+    assertSeq(input.seq);
+    assertPrevHash(input.seq, input.prevHash);
+    assertTimestamp(input.createdAt, 'createdAt');
+    assertKind(input.kind);
+    assertEntity(input.entity);
+    assertTimestamp(input.at, 'at');
+    if (input.data === undefined) throw new Error('Vault data 不能是 undefined');
+    const payload = {
+        schema: VAULT_SCHEMA,
+        kind: input.kind,
+        entity: input.entity,
+        at: input.at,
+        data: input.data
+    };
+    const plain = Buffer.from(stableStringify(payload), 'utf8');
+    const keyId = vaultKeyIdOf(input.vaultKey);
+    const key = recordKeyOf(input.vaultKey, input.writer, input.seq);
+    const aad = aadOf(input.writer, input.seq, input.prevHash, VAULT_SCHEMA);
+    const cipher = createCipheriv('aes-256-gcm', key, FIXED_NONCE);
+    cipher.setAAD(aad);
+    const body = Buffer.concat([
+        cipher.update(plain),
+        cipher.final()
+    ]);
+    const bytes = Buffer.concat([
+        body,
+        cipher.getAuthTag()
+    ]);
+    const sealed = {
+        formatVersion: VAULT_FORMAT_VERSION,
+        keyId
+    };
+    const blobSha256 = sha256(bytes);
+    const ref = {
+        v: VAULT_FORMAT_VERSION,
+        writer: input.writer,
+        seq: input.seq,
+        prevHash: input.prevHash,
+        blobSha256,
+        bytes: bytes.length,
+        createdAt: input.createdAt,
+        sealed,
+        recordHash: vaultRecordHashOf({
+            v: VAULT_FORMAT_VERSION,
+            writer: input.writer,
+            seq: input.seq,
+            prevHash: input.prevHash,
+            blobSha256,
+            bytes: bytes.length,
+            createdAt: input.createdAt,
+            sealed
+        })
+    };
+    return {
+        ref,
+        bytes
+    };
+}
+export function openVaultRecord(record, vaultKey) {
+    assertKey(vaultKey, 'vaultKey');
+    assertVaultRecordRef(record.ref);
+    if (!Buffer.isBuffer(record.bytes)) throw new Error('Vault 密文必须是 Buffer');
+    if (record.bytes.length !== record.ref.bytes) throw new Error('Vault 密文字节数与索引不一致');
+    if (sha256(record.bytes) !== record.ref.blobSha256) throw new Error('Vault 密文哈希与索引不一致');
+    if (vaultKeyIdOf(vaultKey) !== record.ref.sealed.keyId) throw new Error('Vault keyId 不匹配');
+    const key = recordKeyOf(vaultKey, record.ref.writer, record.ref.seq);
+    if (record.bytes.length < TAG_BYTES) throw new Error('Vault 密文过短');
+    const body = record.bytes.subarray(0, record.bytes.length - TAG_BYTES);
+    const tag = record.bytes.subarray(record.bytes.length - TAG_BYTES);
+    const decipher = createDecipheriv('aes-256-gcm', key, FIXED_NONCE);
+    decipher.setAAD(aadOf(record.ref.writer, record.ref.seq, record.ref.prevHash, VAULT_SCHEMA));
+    decipher.setAuthTag(tag);
+    let parsed;
+    try {
+        const plain = Buffer.concat([
+            decipher.update(body),
+            decipher.final()
+        ]);
+        parsed = JSON.parse(plain.toString('utf8'));
+    } catch (error) {
+        throw new Error(`Vault 记录解密失败：${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('Vault 载荷不是对象');
+    const payload = parsed;
+    if (payload['schema'] !== VAULT_SCHEMA) throw new Error(`未知 Vault schema：${String(payload['schema'])}`);
+    if (typeof payload['kind'] !== 'string' || !KIND_PATTERN.test(payload['kind'])) throw new Error('Vault kind 非法');
+    if (typeof payload['entity'] !== 'string' || payload['entity'].trim() === '') throw new Error('Vault entity 非法');
+    if (!Number.isSafeInteger(payload['at'])) throw new Error('Vault at 非法');
+    if (payload['data'] === undefined) throw new Error('Vault data 缺失');
+    return {
+        schema: payload['schema'],
+        kind: payload['kind'],
+        entity: payload['entity'],
+        at: payload['at'],
+        data: payload['data']
+    };
+}
+export function assertVaultRecordRef(ref) {
+    if (ref.v !== VAULT_FORMAT_VERSION) throw new Error(`Vault 记录版本非法：${String(ref.v)}`);
+    assertWriter(ref.writer);
+    assertSeq(ref.seq);
+    assertPrevHash(ref.seq, ref.prevHash);
+    if (!HASH_PATTERN.test(ref.blobSha256)) throw new Error('Vault blobSha256 非法');
+    if (!Number.isSafeInteger(ref.bytes) || ref.bytes <= 0) throw new Error('Vault bytes 非法');
+    assertTimestamp(ref.createdAt, 'createdAt');
+    if (ref.sealed === null || typeof ref.sealed !== 'object') throw new Error('Vault sealed 非法');
+    if (ref.sealed.formatVersion !== VAULT_FORMAT_VERSION) throw new Error('Vault sealed.formatVersion 非法');
+    if (!KEY_ID_PATTERN.test(ref.sealed.keyId)) throw new Error('Vault sealed.keyId 非法');
+    if (!HASH_PATTERN.test(ref.recordHash)) throw new Error('Vault recordHash 非法');
+    const expected = vaultRecordHashOf(ref);
+    if (expected !== ref.recordHash) throw new Error('Vault recordHash 与索引内容不一致');
+}
+export function verifyVaultChain(records) {
+    let previous;
+    records.forEach((ref, index)=>{
+        const expectedSeq = index + 1;
+        if (ref.seq !== expectedSeq) throw new Error(`Vault seq 应为 ${expectedSeq}，实际是 ${ref.seq}`);
+        assertVaultRecordRef(ref);
+        if (previous === undefined) {
+            if (ref.prevHash !== VAULT_GENESIS_HASH) throw new Error('Vault 链首条记录的 prevHash 必须为 null');
+        } else {
+            if (ref.writer !== previous.writer) throw new Error('Vault 链混用了不同 writer');
+            if (ref.prevHash !== previous.recordHash) throw new Error(`Vault 第 ${ref.seq} 条的 prevHash 不匹配`);
+        }
+        previous = ref;
+    });
+}
+function recordKeyOf(vaultKey, writer, seq) {
+    return deriveSubkey(vaultKey, `v1|vault-record:${writer}:${seq}`);
+}
+function aadOf(writer, seq, prevHash, schema) {
+    return Buffer.from(stableStringify({
+        v: VAULT_FORMAT_VERSION,
+        writer,
+        seq,
+        prevHash,
+        schema
+    }), 'utf8');
+}
+export function vaultRecordHashOf(ref) {
+    return sha256(stableStringify({
+        v: ref.v,
+        writer: ref.writer,
+        seq: ref.seq,
+        prevHash: ref.prevHash,
+        blobSha256: ref.blobSha256,
+        bytes: ref.bytes,
+        createdAt: ref.createdAt,
+        sealed: ref.sealed
+    }));
+}
+function assertKey(key, name) {
+    if (!Buffer.isBuffer(key) || key.length !== KEY_BYTES) throw new Error(`${name} 必须是 ${KEY_BYTES} 字节`);
+}
+function assertWriter(writer) {
+    if (typeof writer !== 'string' || writer.length === 0 || writer.length > 128) throw new Error('Vault writer 非法');
+    for (const character of writer){
+        if (character.charCodeAt(0) < 0x21 || character.charCodeAt(0) > 0x7e) throw new Error('Vault writer 含非法字符');
+    }
+}
+function assertSeq(seq) {
+    if (!Number.isSafeInteger(seq) || seq < 1) throw new Error('Vault seq 必须是正整数');
+}
+function assertPrevHash(seq, prevHash) {
+    if (seq === 1) {
+        if (prevHash !== VAULT_GENESIS_HASH) throw new Error('Vault seq=1 的 prevHash 必须为 null');
+        return;
+    }
+    if (prevHash === null || !HASH_PATTERN.test(prevHash)) throw new Error('Vault prevHash 非法');
+}
+function assertTimestamp(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0) throw new Error(`Vault ${name} 非法`);
+}
+function assertKind(kind) {
+    if (typeof kind !== 'string' || !KIND_PATTERN.test(kind)) throw new Error('Vault kind 非法');
+}
+function assertEntity(entity) {
+    if (typeof entity !== 'string' || entity.trim() === '' || entity.length > 512) throw new Error('Vault entity 非法');
+}
+
+
+//# sourceURL=vault.ts

package/dist/shared/wire.js

@@ -0,0 +1,25 @@
+export const ERROR_STATUS = {
+    unauthorized: 401,
+    'bad-request': 400,
+    'not-found': 404,
+    conflict: 409,
+    diverged: 409,
+    'lease-held': 409,
+    gone: 410,
+    quota: 507,
+    'rate-limited': 429
+};
+export function statusOf(code) {
+    return ERROR_STATUS[code];
+}
+export class SyncError extends Error {
+    code;
+    constructor(code, message){
+        super(message);
+        this.name = 'SyncError';
+        this.code = code;
+    }
+}
+
+
+//# sourceURL=wire.ts