dacument 1.0.0

package/dist/Dacument/clock.d.ts

@@ -0,0 +1,16 @@
+export type HLCStamp = {
+    /** Unix ms */
+    readonly wallTimeMs: number;
+    /** logical counter for same/older wallTimeMs */
+    readonly logical: number;
+    /** stable actor/node id for deterministic tie-break */
+    readonly clockId: string;
+};
+export declare function compareHLC(left: HLCStamp, right: HLCStamp): number;
+export declare class HLC {
+    private last;
+    constructor(clockId: string);
+    next(nowMs?: number): HLCStamp;
+    observe(stamp: HLCStamp): void;
+    get current(): HLCStamp;
+}

package/dist/Dacument/clock.js

@@ -0,0 +1,38 @@
+export function compareHLC(left, right) {
+    if (left.wallTimeMs !== right.wallTimeMs)
+        return left.wallTimeMs - right.wallTimeMs;
+    if (left.logical !== right.logical)
+        return left.logical - right.logical;
+    if (left.clockId === right.clockId)
+        return 0;
+    return left.clockId < right.clockId ? -1 : 1;
+}
+export class HLC {
+    last;
+    constructor(clockId) {
+        this.last = { wallTimeMs: 0, logical: 0, clockId };
+    }
+    next(nowMs = Date.now()) {
+        const wallTimeMs = Math.max(nowMs, this.last.wallTimeMs);
+        const logical = wallTimeMs === this.last.wallTimeMs ? this.last.logical + 1 : 0;
+        const next = { wallTimeMs, logical, clockId: this.last.clockId };
+        this.last = next;
+        return next;
+    }
+    observe(stamp) {
+        const mergedWall = Math.max(this.last.wallTimeMs, stamp.wallTimeMs, Date.now());
+        const mergedLogical = mergedWall === this.last.wallTimeMs
+            ? Math.max(this.last.logical, stamp.logical) + 1
+            : mergedWall === stamp.wallTimeMs
+                ? stamp.logical
+                : 0;
+        this.last = {
+            wallTimeMs: mergedWall,
+            logical: mergedLogical,
+            clockId: this.last.clockId,
+        };
+    }
+    get current() {
+        return this.last;
+    }
+}

package/dist/Dacument/crypto.d.ts

@@ -0,0 +1,26 @@
+type SignedHeader = {
+    alg: "ES256";
+    typ: string;
+    kid?: string;
+};
+type UnsignedHeader = {
+    alg: "none";
+    typ: string;
+    kid?: string;
+};
+type Header = SignedHeader | UnsignedHeader;
+type DecodedToken = {
+    header: Header;
+    payload: unknown;
+    signature: Uint8Array;
+    headerB64: string;
+    payloadB64: string;
+};
+export declare function signToken(privateJwk: JsonWebKey, header: SignedHeader, payload: unknown): Promise<string>;
+export declare function encodeToken(header: UnsignedHeader, payload: unknown): string;
+export declare function decodeToken(token: string): DecodedToken | null;
+export declare function verifyToken(publicJwk: JsonWebKey, token: string, expectedTyp: string): Promise<{
+    header: SignedHeader;
+    payload: unknown;
+} | false>;
+export {};

package/dist/Dacument/crypto.js

@@ -0,0 +1,64 @@
+import { Bytes } from "bytecodec";
+import { SigningAgent, VerificationAgent } from "zeyra";
+function stableStringify(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+    const entries = Object.entries(value).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    const body = entries
+        .map(([key, val]) => `${JSON.stringify(key)}:${stableStringify(val)}`)
+        .join(",");
+    return `{${body}}`;
+}
+function decodePart(part) {
+    const bytes = Bytes.fromBase64UrlString(part);
+    const json = Bytes.toString(bytes);
+    return JSON.parse(json);
+}
+export async function signToken(privateJwk, header, payload) {
+    const headerJson = stableStringify(header);
+    const payloadJson = stableStringify(payload);
+    const headerB64 = Bytes.toBase64UrlString(Bytes.fromString(headerJson));
+    const payloadB64 = Bytes.toBase64UrlString(Bytes.fromString(payloadJson));
+    const signingInput = `${headerB64}.${payloadB64}`;
+    const signer = new SigningAgent(privateJwk);
+    const signature = await signer.sign(Bytes.fromString(signingInput));
+    const signatureB64 = Bytes.toBase64UrlString(signature);
+    return `${signingInput}.${signatureB64}`;
+}
+export function encodeToken(header, payload) {
+    const headerJson = stableStringify(header);
+    const payloadJson = stableStringify(payload);
+    const headerB64 = Bytes.toBase64UrlString(Bytes.fromString(headerJson));
+    const payloadB64 = Bytes.toBase64UrlString(Bytes.fromString(payloadJson));
+    return `${headerB64}.${payloadB64}.`;
+}
+export function decodeToken(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3)
+        return null;
+    const [headerB64, payloadB64, signatureB64] = parts;
+    try {
+        const header = decodePart(headerB64);
+        const payload = decodePart(payloadB64);
+        const signature = Bytes.fromBase64UrlString(signatureB64);
+        return { header, payload, signature, headerB64, payloadB64 };
+    }
+    catch {
+        return null;
+    }
+}
+export async function verifyToken(publicJwk, token, expectedTyp) {
+    const decoded = decodeToken(token);
+    if (!decoded)
+        return false;
+    const { header, payload, signature, headerB64, payloadB64 } = decoded;
+    if (header.alg !== "ES256" || header.typ !== expectedTyp)
+        return false;
+    const verifier = new VerificationAgent(publicJwk);
+    const signingInput = Bytes.fromString(`${headerB64}.${payloadB64}`);
+    const signatureBytes = new Uint8Array(signature);
+    const ok = await verifier.verify(signingInput, signatureBytes.buffer);
+    return ok ? { header, payload } : false;
+}

package/dist/Dacument/types.d.ts

@@ -0,0 +1,212 @@
+import type { HLCStamp } from "./clock.js";
+export type Role = "owner" | "manager" | "editor" | "viewer" | "revoked";
+export type CRType = "register" | "text" | "array" | "map" | "set" | "record";
+export type JsValue = string | number | boolean | null | JsValue[] | {
+    [key: string]: JsValue;
+};
+export type JsTypeName = "string" | "number" | "boolean" | "json" | "any";
+export type JsTypeMap = {
+    string: string;
+    number: number;
+    boolean: boolean;
+    json: JsValue;
+    any: unknown;
+};
+export type JsTypeValue<T extends JsTypeName> = JsTypeMap[T];
+export type RoleKeyPair = {
+    publicKey: JsonWebKey;
+    privateKey: JsonWebKey;
+};
+export type RoleKeys = {
+    owner: RoleKeyPair;
+    manager: RoleKeyPair;
+    editor: RoleKeyPair;
+};
+export type RolePublicKeys = {
+    owner: JsonWebKey;
+    manager: JsonWebKey;
+    editor: JsonWebKey;
+};
+export type RegisterSchema<T extends JsTypeName = JsTypeName> = {
+    crdt: "register";
+    jsType: T;
+    regex?: RegExp;
+    initial?: JsTypeValue<T>;
+};
+export type TextSchema = {
+    crdt: "text";
+    jsType: "string";
+    initial?: string;
+};
+export type ArraySchema<T extends JsTypeName = JsTypeName> = {
+    crdt: "array";
+    jsType: T;
+    initial?: JsTypeValue<T>[];
+    key?: (value: JsTypeValue<T>) => string;
+};
+export type SetSchema<T extends JsTypeName = JsTypeName> = {
+    crdt: "set";
+    jsType: T;
+    initial?: JsTypeValue<T>[];
+    key?: (value: JsTypeValue<T>) => string;
+};
+export type MapSchema<T extends JsTypeName = JsTypeName> = {
+    crdt: "map";
+    jsType: T;
+    initial?: Array<[unknown, JsTypeValue<T>]>;
+    key?: (value: unknown) => string;
+};
+export type RecordSchema<T extends JsTypeName = JsTypeName> = {
+    crdt: "record";
+    jsType: T;
+    initial?: Record<string, JsTypeValue<T>>;
+};
+export type FieldSchema = RegisterSchema | TextSchema | ArraySchema | SetSchema | MapSchema | RecordSchema;
+export type SchemaDefinition = Record<string, FieldSchema>;
+export type SchemaId = string;
+export type OpKind = "acl.set" | "register.set" | "text.patch" | "array.patch" | "map.patch" | "set.patch" | "record.patch" | "ack";
+export type OpPayload = {
+    iss: string;
+    sub: string;
+    iat: number;
+    stamp: HLCStamp;
+    kind: OpKind;
+    schema: SchemaId;
+    field?: string;
+    patch?: unknown;
+};
+export type SignedOp = {
+    token: string;
+};
+export type DacumentChangeEvent = {
+    type: "change";
+    ops: SignedOp[];
+};
+export type DacumentMergeEvent = {
+    type: "merge";
+    actor: string;
+    target: string;
+    method: string;
+    data: unknown;
+};
+export type DacumentErrorEvent = {
+    type: "error";
+    error: Error;
+};
+export type DacumentRevokedEvent = {
+    type: "revoked";
+    actorId: string;
+    previous: Role;
+    by: string;
+    stamp: HLCStamp;
+};
+export type DacumentEventMap = {
+    change: DacumentChangeEvent;
+    merge: DacumentMergeEvent;
+    error: DacumentErrorEvent;
+    revoked: DacumentRevokedEvent;
+};
+export type AclAssignment = {
+    id: string;
+    actorId: string;
+    role: Role;
+    stamp: HLCStamp;
+    by: string;
+};
+export type DocSnapshot = {
+    docId: string;
+    roleKeys: RolePublicKeys;
+    ops: SignedOp[];
+};
+export type TextView = {
+    length: number;
+    toString(): string;
+    at(index: number): string | undefined;
+    insertAt(index: number, value: string): unknown;
+    deleteAt(index: number): string | undefined;
+    [Symbol.iterator](): Iterator<string>;
+};
+export type ArrayView<T> = {
+    length: number;
+    at(index: number): T | undefined;
+    slice(start?: number, end?: number): T[];
+    push(...items: T[]): number;
+    unshift(...items: T[]): number;
+    pop(): T | undefined;
+    shift(): T | undefined;
+    setAt(index: number, value: T): unknown;
+    map<U>(callback: (value: T, index: number, array: T[]) => U, thisArg?: unknown): U[];
+    filter(callback: (value: T, index: number, array: T[]) => boolean, thisArg?: unknown): T[];
+    reduce<U>(reducer: (prev: U, curr: T, index: number, array: T[]) => U, initialValue: U): U;
+    forEach(callback: (value: T, index: number, array: T[]) => void, thisArg?: unknown): void;
+    includes(value: T): boolean;
+    indexOf(value: T): number;
+    [Symbol.iterator](): Iterator<T>;
+};
+export type SetView<T> = {
+    size: number;
+    add(value: T): unknown;
+    delete(value: T): boolean;
+    clear(): void;
+    has(value: T): boolean;
+    entries(): SetIterator<[T, T]>;
+    keys(): SetIterator<T>;
+    values(): SetIterator<T>;
+    forEach(callback: (value: T, value2: T, set: Set<T>) => void, thisArg?: unknown): void;
+    [Symbol.iterator](): SetIterator<T>;
+    [Symbol.toStringTag]: string;
+};
+export type MapView<V> = {
+    size: number;
+    get(key: unknown): V | undefined;
+    set(key: unknown, value: V): unknown;
+    has(key: unknown): boolean;
+    delete(key: unknown): boolean;
+    clear(): void;
+    entries(): MapIterator<[unknown, V]>;
+    keys(): MapIterator<unknown>;
+    values(): MapIterator<V>;
+    forEach(callback: (value: V, key: unknown, map: Map<unknown, V>) => void, thisArg?: unknown): void;
+    [Symbol.iterator](): MapIterator<[unknown, V]>;
+    [Symbol.toStringTag]: string;
+};
+export type RecordView<T> = Record<string, T> & {};
+export type FieldValue<F extends FieldSchema> = F["crdt"] extends "register" ? JsTypeValue<F["jsType"]> : F["crdt"] extends "text" ? TextView : F["crdt"] extends "array" ? ArrayView<JsTypeValue<F["jsType"]>> : F["crdt"] extends "set" ? SetView<JsTypeValue<F["jsType"]>> : F["crdt"] extends "map" ? MapView<JsTypeValue<F["jsType"]>> : F["crdt"] extends "record" ? RecordView<JsTypeValue<F["jsType"]>> : never;
+export type DocFieldAccess<S extends SchemaDefinition> = {
+    [K in keyof S]: FieldValue<S[K]>;
+};
+export declare function isJsValue(value: unknown): value is JsValue;
+export declare function isValueOfType(value: unknown, jsType: JsTypeName): boolean;
+export type SchemaIdInput = Record<string, {
+    crdt: CRType;
+    jsType: JsTypeName;
+    regex?: string;
+}>;
+export declare function schemaIdInput(schema: SchemaDefinition): SchemaIdInput;
+export declare function register<T extends JsTypeName = "any">(options?: {
+    jsType?: T;
+    regex?: RegExp;
+    initial?: JsTypeValue<T>;
+}): RegisterSchema<T>;
+export declare function text(options?: {
+    initial?: string;
+}): TextSchema;
+export declare function array<T extends JsTypeName>(options: {
+    jsType: T;
+    initial?: JsTypeValue<T>[];
+    key?: (value: JsTypeValue<T>) => string;
+}): ArraySchema<T>;
+export declare function set<T extends JsTypeName>(options: {
+    jsType: T;
+    initial?: JsTypeValue<T>[];
+    key?: (value: JsTypeValue<T>) => string;
+}): SetSchema<T>;
+export declare function map<T extends JsTypeName>(options: {
+    jsType: T;
+    initial?: Array<[unknown, JsTypeValue<T>]>;
+    key?: (value: unknown) => string;
+}): MapSchema<T>;
+export declare function record<T extends JsTypeName>(options: {
+    jsType: T;
+    initial?: Record<string, JsTypeValue<T>>;
+}): RecordSchema<T>;

package/dist/Dacument/types.js

@@ -0,0 +1,79 @@
+export function isJsValue(value) {
+    if (value === null)
+        return true;
+    const valueType = typeof value;
+    if (valueType === "string" || valueType === "number" || valueType === "boolean")
+        return true;
+    if (Array.isArray(value))
+        return value.every(isJsValue);
+    if (valueType === "object") {
+        for (const entry of Object.values(value)) {
+            if (!isJsValue(entry))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+export function isValueOfType(value, jsType) {
+    if (jsType === "any")
+        return true;
+    if (jsType === "json")
+        return isJsValue(value);
+    return typeof value === jsType;
+}
+export function schemaIdInput(schema) {
+    const normalized = {};
+    for (const [key, field] of Object.entries(schema)) {
+        normalized[key] = {
+            crdt: field.crdt,
+            jsType: field.jsType,
+            regex: field.crdt === "register" && field.regex
+                ? field.regex.source + "/" + field.regex.flags
+                : undefined,
+        };
+    }
+    return normalized;
+}
+export function register(options = {}) {
+    return {
+        crdt: "register",
+        jsType: options.jsType ?? "any",
+        regex: options.regex,
+        initial: options.initial,
+    };
+}
+export function text(options = {}) {
+    return { crdt: "text", jsType: "string", initial: options.initial ?? "" };
+}
+export function array(options) {
+    return {
+        crdt: "array",
+        jsType: options.jsType,
+        initial: options.initial ?? [],
+        key: options.key,
+    };
+}
+export function set(options) {
+    return {
+        crdt: "set",
+        jsType: options.jsType,
+        initial: options.initial ?? [],
+        key: options.key,
+    };
+}
+export function map(options) {
+    return {
+        crdt: "map",
+        jsType: options.jsType,
+        initial: options.initial ?? [],
+        key: options.key,
+    };
+}
+export function record(options) {
+    return {
+        crdt: "record",
+        jsType: options.jsType,
+        initial: options.initial ?? {},
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { CRArray } from "./CRArray/class.js";
+import { CRMap } from "./CRMap/class.js";
+import { CRRecord } from "./CRRecord/class.js";
+import { CRRegister } from "./CRRegister/class.js";
+import { CRSet } from "./CRSet/class.js";
+import { CRText } from "./CRText/class.js";
+import { Dacument } from "./Dacument/class.js";
+export { CRArray, CRMap, CRRecord, CRRegister, CRSet, CRText, Dacument };
+export * from "./Dacument/types.js";
+export type { DacumentDoc } from "./Dacument/class.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+import { CRArray } from "./CRArray/class.js";
+import { CRMap } from "./CRMap/class.js";
+import { CRRecord } from "./CRRecord/class.js";
+import { CRRegister } from "./CRRegister/class.js";
+import { CRSet } from "./CRSet/class.js";
+import { CRText } from "./CRText/class.js";
+import { Dacument } from "./Dacument/class.js";
+export { CRArray, CRMap, CRRecord, CRRegister, CRSet, CRText, Dacument };
+export * from "./Dacument/types.js";

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "dacument",
+  "version": "1.0.0",
+  "description": "Schema-driven CRDT document with signed ops and role-based ACLs.",
+  "keywords": [
+    "crdt",
+    "document",
+    "collaboration",
+    "replication",
+    "sync",
+    "acl",
+    "signature",
+    "crypto",
+    "eventual-consistency",
+    "offline"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test test/*.test.js",
+    "bench": "npm run build && node bench/index.js",
+    "sim": "npm run build && node bench/dacument.sim.js",
+    "verify": "npm run test && npm run bench && npm run sim"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jortsupetterson/dacument.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jortsupetterson/dacument/issues"
+  },
+  "homepage": "https://github.com/jortsupetterson/dacument#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "bytecodec": "^2.1.0",
+    "uuid": "^13.0.0",
+    "zeyra": "^2.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "typescript": "^5.9.3"
+  }
+}