@markless/serializer 0.1.0

package/dist/protocol.d.ts

@@ -0,0 +1,251 @@
+//#region src/protocol.d.ts
+declare const ASYNC_PROTOCOL_VERSION = 1;
+type ProtocolSyncPolicyCondition = {
+  readonly type: 'and';
+  readonly conditions: ReadonlyArray<ProtocolSyncPolicyCondition>;
+} | {
+  readonly type: 'or';
+  readonly conditions: ReadonlyArray<ProtocolSyncPolicyCondition>;
+} | {
+  readonly type: 'not';
+  readonly condition: ProtocolSyncPolicyCondition;
+} | {
+  readonly type: 'graph-truthy';
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+} | {
+  readonly type: 'constant-truthy';
+  readonly value: unknown;
+} | {
+  readonly type: 'event-equals';
+  readonly field: string;
+  readonly value: unknown;
+};
+type ProtocolSyncPolicyBranch = {
+  readonly when: ProtocolSyncPolicyCondition;
+  readonly actions: ReadonlyArray<'preventDefault' | 'stopPropagation'>;
+};
+type ProtocolSyncPolicy = ProtocolSyncPolicyBranch | {
+  readonly branches: ReadonlyArray<ProtocolSyncPolicyBranch>;
+};
+type ProtocolStatePayload = {
+  readonly version: typeof ASYNC_PROTOCOL_VERSION;
+  readonly cells: ReadonlyArray<{
+    readonly graphNodeId: string;
+    readonly name: string;
+    readonly valueKind: 'scalar' | 'object' | 'array' | 'unknown';
+    readonly value?: unknown;
+    readonly directValue?: unknown;
+  }>;
+  readonly computed: ReadonlyArray<{
+    readonly graphNodeId: string;
+    readonly name: string;
+    readonly async: boolean;
+    readonly dependencies?: ReadonlyArray<{
+      readonly graphNodeId: string;
+      readonly path: ReadonlyArray<string>;
+    }>;
+    readonly snapshot?: {
+      readonly status: 'idle';
+      readonly version: 0;
+    } | {
+      readonly status: 'pending';
+      readonly version: number;
+      readonly key: unknown;
+    } | {
+      readonly status: 'fulfilled';
+      readonly version: number;
+      readonly key: unknown;
+      readonly value: unknown;
+    } | {
+      readonly status: 'rejected';
+      readonly version: number;
+      readonly key: unknown;
+      readonly error: unknown;
+    };
+  }>;
+  readonly sharedDefinitions?: ReadonlyArray<{
+    readonly id: string;
+    readonly name: string;
+    readonly exportedName: string;
+    readonly scope?: 'request' | 'container' | 'page';
+    readonly version: number;
+    readonly graphNodeIds: ReadonlyArray<string>;
+    readonly dependencies?: ReadonlyArray<{
+      readonly definitionId: string;
+      readonly definitionName: string;
+    }>;
+    readonly returnProperties?: ReadonlyArray<{
+      readonly kind: 'graph';
+      readonly name: string;
+      readonly graphNodeId: string;
+      readonly path: ReadonlyArray<string>;
+    } | {
+      readonly kind: 'method';
+      readonly name: string;
+    }>;
+  }>;
+};
+type ProtocolArmBranchRecord = {
+  readonly id: string;
+  readonly testReads: ReadonlyArray<{
+    readonly source: string;
+    readonly graphNodeId: string;
+    readonly path: ReadonlyArray<string>;
+  }>;
+  readonly symbolId?: string;
+  readonly armTests?: ReadonlyArray<unknown>;
+  readonly declaredEmptyArms?: ReadonlyArray<number>;
+  readonly startAnchor?: {
+    readonly strategy: 'arm-branch-comment';
+    readonly index: number;
+  };
+  readonly endAnchor?: {
+    readonly strategy: 'arm-branch-comment';
+    readonly index: number;
+  };
+  readonly armRecords?: NonNullable<ProtocolViewPayload['branches']>[number]['armRecords'];
+};
+type ProtocolArmRecordSet = {
+  readonly locators: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly strategy: 'arm-relative';
+    readonly index: number;
+    readonly tagName: string;
+  }>;
+  readonly events: ProtocolViewPayload['events'];
+  readonly behaviors: ProtocolViewPayload['behaviors'];
+  readonly elementHandles: ProtocolViewPayload['elementHandles'];
+  readonly branches?: ReadonlyArray<ProtocolArmBranchRecord>;
+};
+type ProtocolViewPayload = {
+  readonly version: typeof ASYNC_PROTOCOL_VERSION;
+  readonly locators: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly strategy: 'dom-order';
+    readonly index: number;
+    readonly tagName: string;
+  }>;
+  readonly events: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly eventName: string;
+    readonly syncPolicy?: ProtocolSyncPolicy;
+    readonly symbolIds: ReadonlyArray<string>;
+  }>;
+  readonly domUpdates: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly source: string;
+    readonly graphNodeId: string;
+    readonly path: ReadonlyArray<string>;
+    readonly target?: {
+      readonly kind: 'text';
+      readonly prefix?: string;
+      readonly suffix?: string;
+      readonly trueValue?: string;
+      readonly falseValue?: string;
+    } | {
+      readonly kind: 'attribute';
+      readonly name: string;
+    } | {
+      readonly kind: 'property';
+      readonly name: string;
+    } | {
+      readonly kind: 'class';
+      readonly trueValue?: string;
+      readonly falseValue?: string;
+    } | {
+      readonly kind: 'style';
+    };
+    readonly symbolId?: string;
+  }>;
+  readonly behaviors: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly source: string;
+    readonly functionSource: string;
+    readonly inputSources: ReadonlyArray<string>;
+    readonly inputValues?: ReadonlyArray<unknown>;
+    readonly inputGraphReads?: ReadonlyArray<{
+      readonly inputIndex: number;
+      readonly source: string;
+      readonly graphNodeId: string;
+      readonly path: ReadonlyArray<string>;
+    }>;
+    readonly symbolId?: string;
+  }>;
+  readonly elementHandles: ReadonlyArray<{
+    readonly hostNodeId: string;
+    readonly handleId: string;
+    readonly name: string;
+  }>;
+  readonly keyedRepeats?: ReadonlyArray<{
+    readonly id: string;
+    readonly parentHostNodeId: string;
+    readonly collectionGraphNodeId?: string;
+    readonly collectionPath: ReadonlyArray<string>;
+    readonly keyPath: ReadonlyArray<string>;
+    readonly itemName: string;
+    readonly rowElementCount: number;
+    readonly rowEvents: ReadonlyArray<{
+      readonly hostPath: ReadonlyArray<number>;
+      readonly eventName: string;
+      readonly symbolIds: ReadonlyArray<string>;
+      readonly syncPolicy?: ProtocolSyncPolicy;
+    }>;
+  }>;
+  readonly branches?: ReadonlyArray<{
+    readonly id: string;
+    readonly startAnchor: {
+      readonly strategy: 'dom-order-comment';
+      readonly index: number;
+    };
+    readonly endAnchor: {
+      readonly strategy: 'dom-order-comment';
+      readonly index: number;
+    };
+    readonly symbolId?: string;
+    readonly armTests?: ReadonlyArray<unknown>;
+    readonly armRecords?: ReadonlyArray<{
+      readonly events: ReadonlyArray<{
+        readonly hostPath: ReadonlyArray<number>;
+        readonly eventName: string;
+        readonly symbolIds: ReadonlyArray<string>;
+        readonly syncPolicy?: ProtocolSyncPolicy;
+      }>;
+      readonly domUpdates: ReadonlyArray<Record<string, unknown>>;
+      readonly behaviors: ReadonlyArray<Record<string, unknown>>;
+      readonly elementHandles: ReadonlyArray<Record<string, unknown>>;
+    }>;
+    readonly testReads?: ReadonlyArray<{
+      readonly source: string;
+      readonly graphNodeId: string;
+      readonly path: ReadonlyArray<string>;
+    }>;
+  }>;
+  readonly asyncBoundaries: ReadonlyArray<{
+    readonly id: string;
+    readonly updateSymbolId?: string;
+    readonly armRecords?: ProtocolArmRecordSet | ReadonlyArray<ProtocolArmRecordSet>;
+    readonly startAnchor: {
+      readonly strategy: 'dom-order-comment';
+      readonly index: number;
+    };
+    readonly endAnchor: {
+      readonly strategy: 'dom-order-comment';
+      readonly index: number;
+    };
+    readonly asyncReads: ReadonlyArray<{
+      readonly source: string;
+      readonly graphNodeId: string;
+      readonly path: ReadonlyArray<string>;
+      readonly runnerSymbolId?: string;
+    }>;
+  }>;
+};
+type ProtocolPayloadScripts = {
+  readonly state: ProtocolStatePayload;
+  readonly view: ProtocolViewPayload;
+  readonly stateScript: string;
+  readonly viewScript: string;
+};
+//#endregion
+export { ASYNC_PROTOCOL_VERSION, ProtocolArmBranchRecord, ProtocolArmRecordSet, ProtocolPayloadScripts, ProtocolStatePayload, ProtocolSyncPolicy, ProtocolSyncPolicyBranch, ProtocolSyncPolicyCondition, ProtocolViewPayload };

package/dist/protocol.js

@@ -0,0 +1,4 @@
+//#region src/protocol.ts
+const ASYNC_PROTOCOL_VERSION = 1;
+//#endregion
+export { ASYNC_PROTOCOL_VERSION };

package/dist/value-CcROymhu.d.ts

@@ -0,0 +1,102 @@
+//#region src/value-decode.d.ts
+declare function deserializeGraphValue(payload: SerializedGraphPayload): unknown;
+//#endregion
+//#region src/value.d.ts
+type SerializedPrimitive = null | string | number | boolean | {
+  readonly $type: 'undefined';
+} | {
+  readonly $type: 'bigint';
+  readonly value: string;
+};
+type SerializedSlot = SerializedPrimitive | {
+  readonly $ref: number;
+} | {
+  readonly $type: 'date';
+  readonly value: string;
+} | {
+  readonly $type: 'regexp';
+  readonly source: string;
+  readonly flags: string;
+} | {
+  readonly $type: 'url';
+  readonly value: string;
+};
+type SerializedRecord = {
+  readonly id: number;
+  readonly type: 'object';
+  readonly fields: ReadonlyArray<readonly [string, SerializedSlot]>;
+} | {
+  readonly id: number;
+  readonly type: 'array';
+  readonly items: ReadonlyArray<SerializedSlot>;
+} | {
+  readonly id: number;
+  readonly type: 'map';
+  readonly entries: ReadonlyArray<readonly [SerializedSlot, SerializedSlot]>;
+} | {
+  readonly id: number;
+  readonly type: 'set';
+  readonly values: ReadonlyArray<SerializedSlot>;
+} | {
+  readonly id: number;
+  readonly type: 'date';
+  readonly value: string;
+} | {
+  readonly id: number;
+  readonly type: 'regexp';
+  readonly source: string;
+  readonly flags: string;
+} | {
+  readonly id: number;
+  readonly type: 'url';
+  readonly value: string;
+} | {
+  readonly id: number;
+  readonly type: 'array-buffer';
+  readonly bytes: ReadonlyArray<number>;
+} | {
+  readonly id: number;
+  readonly type: 'typed-array';
+  readonly arrayType: TypedArrayName;
+  readonly buffer: SerializedSlot;
+  readonly byteOffset: number;
+  readonly length: number;
+} | {
+  readonly id: number;
+  readonly type: 'data-view';
+  readonly buffer: SerializedSlot;
+  readonly byteOffset: number;
+  readonly byteLength: number;
+};
+type TypedArrayName = 'Int8Array' | 'Uint8Array' | 'Uint8ClampedArray' | 'Int16Array' | 'Uint16Array' | 'Int32Array' | 'Uint32Array' | 'Float32Array' | 'Float64Array' | 'BigInt64Array' | 'BigUint64Array';
+type SerializedGraphPayload = {
+  readonly version: 1;
+  readonly root: SerializedSlot;
+  readonly records: ReadonlyArray<SerializedRecord>;
+};
+type SerializationDiagnostic = {
+  readonly code: 'MARKLESS_SERIALIZE_UNSUPPORTED_VALUE';
+  readonly severity: 'error';
+  readonly phase: 'serialization';
+  readonly title: 'Cannot serialize graph state value';
+  readonly path: ReadonlyArray<string>;
+  readonly statePath: string;
+  readonly valueKind: string;
+  readonly message: string;
+  readonly why: string;
+  readonly suggestions: ReadonlyArray<{
+    readonly message: string;
+  }>;
+  readonly docsUrl: string;
+};
+type SerializationResult = {
+  readonly ok: true;
+  readonly payload: SerializedGraphPayload;
+  readonly diagnostics: readonly [];
+} | {
+  readonly ok: false;
+  readonly diagnostics: ReadonlyArray<SerializationDiagnostic>;
+};
+declare function serializeGraphValue(value: unknown): SerializationResult;
+//#endregion
+export { SerializedRecord as a, serializeGraphValue as c, SerializedPrimitive as i, deserializeGraphValue as l, SerializationResult as n, SerializedSlot as o, SerializedGraphPayload as r, TypedArrayName as s, SerializationDiagnostic as t };

package/dist/value-decode-extensions-BhNCyKre.js

@@ -0,0 +1,33 @@
+//#region src/value-decode-extensions.ts
+const valueDecodeExtensions = {
+	recordShell(record, shells) {
+		if (record.type === "regexp") return new RegExp(record.source, record.flags);
+		if (record.type === "url") return new URL(record.value);
+		if (record.type === "array-buffer") return new Uint8Array(record.bytes).buffer;
+		if (record.type === "typed-array") return createTypedArray(record, shells);
+		if (record.type === "data-view") return createDataView(record, shells);
+	},
+	slot(slot) {
+		if (typeof slot !== "object" || slot === null || !("$type" in slot)) return void 0;
+		if (slot.$type === "regexp") return new RegExp(slot.source, slot.flags);
+		if (slot.$type === "url") return new URL(slot.value);
+	}
+};
+function createTypedArray(record, shells) {
+	const buffer = decodeSlot(record.buffer, shells);
+	if (!(buffer instanceof ArrayBuffer)) return void 0;
+	const constructor = globalThis[record.arrayType];
+	return typeof constructor === "function" ? new constructor(buffer, record.byteOffset, record.length) : void 0;
+}
+function createDataView(record, shells) {
+	const buffer = decodeSlot(record.buffer, shells);
+	return buffer instanceof ArrayBuffer ? new DataView(buffer, record.byteOffset, record.byteLength) : void 0;
+}
+function decodeSlot(slot, shells) {
+	if (typeof slot !== "object" || slot === null) return slot;
+	if ("$ref" in slot) return shells.get(slot.$ref);
+	if (slot.$type === "regexp") return new RegExp(slot.source, slot.flags);
+	if (slot.$type === "url") return new URL(slot.value);
+}
+//#endregion
+export { valueDecodeExtensions };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@markless/serializer",
+  "version": "0.1.0",
+  "description": "Markless serialization tiers and resumability payload protocol.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/markless-dev/markless.git",
+    "directory": "packages/serializer"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./decode": {
+      "types": "./dist/decode.d.ts",
+      "default": "./dist/decode.js"
+    },
+    "./decode-client": {
+      "types": "./dist/decode-client.d.ts",
+      "default": "./dist/decode-client.js"
+    },
+    "./protocol": {
+      "types": "./dist/protocol.d.ts",
+      "default": "./dist/protocol.js"
+    },
+    "./protocol-validation": {
+      "types": "./dist/protocol-validation.d.ts",
+      "default": "./dist/protocol-validation.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {}
+}