lowlander 0.4.0 → 0.6.0

package/dashboard/server.ts

@@ -0,0 +1,399 @@
+import * as E from 'edinburgh';
+import { timingSafeEqual } from 'crypto';
+import { ServerProxy, createStreamType, getStreamTypesForModel, warpsocket } from '../server/server.js';
+import { getMainApi, getPassword } from '../server/wshandler.js';
+
+// `modelRegistry` is a documented export of edinburgh's models module but is
+// not re-exported from the package entry. Reach it by URL relative to the
+// resolved package main — works in both Bun (.ts) and Node (built .js).
+const _modelsModule = await import(new URL('./models.js', import.meta.resolve('edinburgh')).href) as {
+    modelRegistry: Record<string, E.AnyModelClass>;
+};
+const modelRegistry = _modelsModule.modelRegistry;
+
+
+function passwordOk(provided: string): boolean {
+    const expected = getPassword();
+    if (typeof provided !== 'string' || provided.length !== expected.length) return false;
+    return timingSafeEqual(Buffer.from(provided), Buffer.from(expected));
+}
+
+/** Recursive type descriptor sent to the dashboard client for building CRUD editors. */
+export interface TypeInfo {
+    kind: string;
+    display: string;
+    /** For 'link' kind: the linked model's tableName. */
+    linkedModel?: string;
+    /** For 'array', 'set', and opt('or' with undef) kinds: the element/inner type. */
+    inner?: TypeInfo;
+    /** For 'record' kind: the value type. */
+    innerValue?: TypeInfo;
+    /** For 'or' kind: all union choices (includes the undef literal for opt). */
+    choices?: TypeInfo[];
+    /** True when this is opt(T) — an or(undef, T) with exactly one non-undefined branch. */
+    isOptional?: boolean;
+    /** For 'literal' kind: the JSON-serialized literal value. */
+    literalValue?: string;
+}
+
+function describeType(type: E.TypeWrapper<unknown>): TypeInfo {
+    const kind = (type as any).kind as string;
+    const linked = type.getLinkedModel();
+
+    const info: TypeInfo = {
+        kind,
+        display: type.toString(),
+        linkedModel: linked?.tableName,
+    };
+
+    if (kind === 'array' || kind === 'set') {
+        info.inner = describeType((type as any).inner);
+    } else if (kind === 'record') {
+        info.innerValue = describeType((type as any).inner);
+    } else if (kind === 'or') {
+        const choices = (type as any).choices as E.TypeWrapper<unknown>[];
+        info.choices = choices.map(describeType);
+        const isUndefLiteral = (t: TypeInfo) => t.kind === 'literal' && t.literalValue === 'undefined';
+        const nonUndef = info.choices.filter(c => !isUndefLiteral(c));
+        const hasUndef = info.choices.some(c => isUndefLiteral(c));
+        if (hasUndef && nonUndef.length === 1) {
+            info.isOptional = true;
+            info.inner = nonUndef[0];
+        }
+    } else if (kind === 'literal') {
+        const val = (type as any).value;
+        info.literalValue = val === undefined ? 'undefined' : JSON.stringify(val);
+    }
+
+    return info;
+}
+
+function parseValueFromJson(type: E.TypeWrapper<unknown>, json: any): any {
+    if (json === null || json === undefined) return undefined;
+    const kind = (type as any).kind as string;
+    switch (kind) {
+        case 'string':
+        case 'id':
+            return typeof json === 'string' ? json : String(json);
+        case 'number':
+            return typeof json === 'number' ? json : Number(json);
+        case 'boolean':
+            return json === true || json === 'true' || json === 1;
+        case 'dateTime':
+            return new Date(json);
+        case 'link': {
+            const Model = type.getLinkedModel()!;
+            const pk = json?.__ref ? json.pk : json;
+            const pkArgs = Array.isArray(pk) ? pk : [pk];
+            const instance = (Model as any).get(...pkArgs);
+            if (!instance) throw new Error(`Linked ${Model.tableName} record not found: ${JSON.stringify(pk)}`);
+            return instance;
+        }
+        case 'array': {
+            const inner = (type as any).inner as E.TypeWrapper<unknown>;
+            if (!Array.isArray(json)) return [];
+            return json.map((v: any) => parseValueFromJson(inner, v));
+        }
+        case 'set': {
+            const inner = (type as any).inner as E.TypeWrapper<unknown>;
+            if (!Array.isArray(json)) return new Set();
+            return new Set(json.map((v: any) => parseValueFromJson(inner, v)));
+        }
+        case 'record': {
+            const inner = (type as any).inner as E.TypeWrapper<unknown>;
+            if (!json || typeof json !== 'object' || Array.isArray(json)) return {};
+            const result: Record<string, any> = {};
+            for (const [k, v] of Object.entries(json)) result[k] = parseValueFromJson(inner, v);
+            return result;
+        }
+        case 'or': {
+            const choices = (type as any).choices as E.TypeWrapper<unknown>[];
+            const isUndefLiteral = (t: E.TypeWrapper<unknown>) =>
+                (t as any).kind === 'literal' && (t as any).value === undefined;
+            if (json === null || json === undefined) {
+                if (choices.some(isUndefLiteral)) return undefined;
+                return null;
+            }
+            const nonUndef = choices.filter(c => !isUndefLiteral(c));
+            if (nonUndef.length === 1) return parseValueFromJson(nonUndef[0]!, json);
+            return json;
+        }
+        case 'literal':
+            return (type as any).value;
+        default:
+            return json;
+    }
+}
+
+function describeIndex(index: any) {
+    const fields = Array.from(index._indexFields.keys()) as string[];
+    return {
+        fields,
+        fieldTypes: fields.map(f => describeType(index._indexFields.get(f))),
+        computed: !!index._computeFn,
+        kind: index._getTypeName() as 'primary' | 'unique' | 'secondary',
+    };
+}
+
+function describeModel(Model: E.AnyModelClass) {
+    const pkIdx = describeIndex(Model);
+    const pkFields = new Set(pkIdx.fields);
+    const fields: { name: string; type: TypeInfo; description?: string; hasDefault: boolean; isPk: boolean }[] = [];
+    for (const [name, cfg] of Object.entries(Model.fields) as [string, E.FieldConfig<unknown>][]) {
+        fields.push({
+            name,
+            type: describeType(cfg.type),
+            description: cfg.description,
+            hasDefault: cfg.default !== undefined,
+            isPk: pkFields.has(name),
+        });
+    }
+    const indexes: { name: string; info: ReturnType<typeof describeIndex> }[] = [{
+        name: '(primary)',
+        info: pkIdx,
+    }];
+    for (const [name, idx] of Object.entries((Model as any)._secondaries || {})) {
+        indexes.push({ name, info: describeIndex(idx) });
+    }
+    const streamTypes = getStreamTypesForModel(Model).map((ST: any) => ({
+        id: ST.id,
+        fields: ST.fields,
+        cache: ST.cache,
+    }));
+    return {
+        tableName: Model.tableName,
+        fields,
+        indexes,
+        streamTypes,
+    };
+}
+
+function serializeValue(v: any, depth = 0): any {
+    if (v === null || v === undefined) return v;
+    if (v instanceof E.Model) {
+        const cls: any = v.constructor;
+        const tn = cls.tableName || cls.name;
+        const pkBytes = (v as any).getPrimaryKey?.();
+        const pkArr = pkBytes && cls._pkToArray ? cls._pkToArray(pkBytes) : null;
+        const pk = pkArr ? (pkArr.length === 1 ? pkArr[0] : pkArr) : null;
+        return { __ref: tn, pk };
+    }
+    if (v instanceof Uint8Array) return Array.from(v.slice(0, 64)).map(b => b.toString(16).padStart(2, '0')).join('');
+    if (v instanceof Date) return v.toISOString();
+    if (v instanceof Set) return depth > 2 ? `Set(${v.size})` : Array.from(v).map(x => serializeValue(x, depth + 1));
+    if (Array.isArray(v)) return depth > 2 ? `Array(${v.length})` : v.map(x => serializeValue(x, depth + 1));
+    if (typeof v === 'object') {
+        if (depth > 2) return '...';
+        const out: Record<string, any> = {};
+        for (const k of Object.keys(v)) out[k] = serializeValue(v[k], depth + 1);
+        return out;
+    }
+    return v;
+}
+
+function instanceToPlain(instance: any): Record<string, any> {
+    const Model = instance.constructor as E.AnyModelClass;
+    const out: Record<string, any> = {};
+    for (const fieldName of Object.keys(Model.fields)) {
+        try {
+            out[fieldName] = serializeValue((instance as any)[fieldName]);
+        } catch (err: any) {
+            out[fieldName] = `<error: ${err?.message || err}>`;
+        }
+    }
+    return out;
+}
+
+function modelByName(name: string): E.AnyModelClass {
+    const Model = modelRegistry[name];
+    if (!Model) throw new Error(`Unknown model: ${name}`);
+    return Model;
+}
+
+function findIndex(Model: E.AnyModelClass, indexName: string): any {
+    if (indexName === '(primary)') return Model;
+    const idx = (Model as any)._secondaries?.[indexName];
+    if (!idx) throw new Error(`Unknown index ${indexName} on ${Model.tableName}`);
+    return idx;
+}
+
+// =====================================================================
+
+class DashboardAPI {
+    listModels() {
+        return Object.keys(modelRegistry).sort().map(name => ({
+            tableName: name,
+            indexCount: 1 + Object.keys((modelRegistry[name] as any)._secondaries || {}).length,
+            fieldCount: Object.keys(modelRegistry[name].fields).length,
+            streamTypeCount: getStreamTypesForModel(modelRegistry[name]).length,
+        }));
+    }
+
+    getModel(name: string) {
+        return describeModel(modelByName(name));
+    }
+
+    listApiMethods() {
+        const api = getMainApi();
+        if (!api) return [];
+        const out: { name: string; kind: 'function' | 'value' }[] = [];
+        for (const key of Object.keys(api).sort()) {
+            if (key === '_dashboard' || key.startsWith('_')) continue;
+            const v = (api as any)[key];
+            out.push({ name: key, kind: typeof v === 'function' ? 'function' : 'value' });
+        }
+        return out;
+    }
+
+    getApiMethodSource(name: string): string | undefined {
+        const api = getMainApi();
+        const fn = api && (api as any)[name];
+        if (typeof fn !== 'function') return undefined;
+        try {
+            // Bundlers usually preserve enough source for a useful preview
+            const s = String(fn);
+            return s.length > 4000 ? s.slice(0, 4000) + '\n/* … truncated */' : s;
+        } catch {
+            return undefined;
+        }
+    }
+
+    findRecords(modelName: string, indexName: string, opts: {
+        search?: any;
+        reverse?: boolean;
+        limit?: number;
+    } = {}) {
+        const Model = modelByName(modelName);
+        const idx = findIndex(Model, indexName);
+        const fieldNames = Array.from(idx._indexFields.keys()) as string[];
+
+        const findOpts: any = {};
+        if (opts.search !== undefined && opts.search !== '') {
+            findOpts.is = opts.search;
+        }
+        if (opts.reverse) findOpts.reverse = true;
+
+        const limit = Math.min(opts.limit ?? 10, 1000);
+        let iter: Iterable<any>;
+        try { iter = idx.find(findOpts); }
+        catch { return { rows: [], indexFields: fieldNames, scanned: 0 }; }
+        const results: { pk: any; values: Record<string, any> }[] = [];
+        let scanned = 0;
+        for (const row of iter) {
+            scanned++;
+            const plain = instanceToPlain(row);
+            const cls: any = (row as any).constructor;
+            const pkBytes = (row as any).getPrimaryKey ? (row as any).getPrimaryKey() : null;
+            const pkArr = pkBytes && cls._pkToArray ? cls._pkToArray(pkBytes) : null;
+            const pk = pkArr ? (pkArr.length === 1 ? pkArr[0] : pkArr) : null;
+            results.push({
+                pk: serializeValue(pk),
+                values: plain,
+            });
+            if (results.length >= limit) break;
+        }
+        return {
+            rows: results,
+            indexFields: fieldNames,
+            scanned,
+        };
+    }
+
+    getRecord(modelName: string, pk: any) {
+        const Model = modelByName(modelName);
+        const pkArgs = Array.isArray(pk) ? pk : [pk];
+        const instance = (Model as any).get(...pkArgs);
+        if (!instance) return undefined;
+        return instanceToPlain(instance);
+    }
+
+    streamRecord(modelName: string, streamTypeId: number, pk: any) {
+        const Model = modelByName(modelName);
+        const ST = getStreamTypesForModel(Model).find((s: any) => s.id === streamTypeId) as any;
+        if (!ST) throw new Error(`No stream type with id ${streamTypeId} for ${modelName}`);
+        const pkArgs = Array.isArray(pk) ? pk : [pk];
+        const instance = (Model as any).get(...pkArgs);
+        if (!instance) throw new Error('Record not found');
+        return new ST(instance);
+    }
+
+    async createRecord(modelName: string, values: Record<string, any>): Promise<any> {
+        const Model = modelByName(modelName);
+        const parsed: Record<string, any> = {};
+        for (const [fieldName, jsonValue] of Object.entries(values)) {
+            const fieldConfig = Model.fields[fieldName] as E.FieldConfig<unknown> | undefined;
+            if (!fieldConfig) continue;
+            if ((fieldConfig.type as any).kind === 'id') continue; // auto-generated
+            const v = parseValueFromJson(fieldConfig.type, jsonValue);
+            if (v !== undefined) parsed[fieldName] = v;
+        }
+        return await E.transact(() => {
+            const instance = new (Model as any)(parsed);
+            const cls: any = instance.constructor;
+            const pkBytes = instance.getPrimaryKey?.();
+            const pkArr = pkBytes && cls._pkToArray ? cls._pkToArray(pkBytes) : null;
+            const pk = pkArr ? (pkArr.length === 1 ? pkArr[0] : pkArr) : null;
+            return serializeValue(pk);
+        });
+    }
+
+    async updateRecord(modelName: string, pk: any, values: Record<string, any>): Promise<void> {
+        const Model = modelByName(modelName);
+        const pkArgs = Array.isArray(pk) ? pk : [pk];
+        const instance = (Model as any).get(...pkArgs);
+        if (!instance) throw new Error(`Record not found: ${JSON.stringify(pk)}`);
+        await E.transact(() => {
+            for (const [fieldName, jsonValue] of Object.entries(values)) {
+                const fieldConfig = Model.fields[fieldName] as E.FieldConfig<unknown> | undefined;
+                if (!fieldConfig) continue;
+                if ((fieldConfig.type as any).kind === 'id') continue; // immutable
+                (instance as any)[fieldName] = parseValueFromJson(fieldConfig.type, jsonValue);
+            }
+        });
+    }
+
+    async deleteRecord(modelName: string, pk: any): Promise<void> {
+        const Model = modelByName(modelName);
+        const pkArgs = Array.isArray(pk) ? pk : [pk];
+        const instance = (Model as any).get(...pkArgs);
+        if (!instance) throw new Error(`Record not found: ${JSON.stringify(pk)}`);
+        await E.transact(() => { instance.delete(); });
+    }
+
+    getDebugState(mode: 'channels' | 'sockets' | 'workers' | 'kv') {
+        return warpsocket.getDebugState(mode as any);
+    }
+}
+
+const DashboardProxyValue = 'authenticated';
+
+/**
+ * RPC entry point. Re-export this from your top-level api file:
+ *
+ * ```ts
+ * export { _dashboard } from 'lowlander/dashboard';
+ * ```
+ *
+ * On first call, a password is generated (or reused from the
+ * `LOWLANDER_DASHBOARD_PASSWORD` env var) and printed to the server console.
+ */
+export function _dashboard(password: string) {
+    if (!passwordOk(password)) {
+        throw new Error('Invalid dashboard password');
+    }
+    return new ServerProxy(new DashboardAPI(), DashboardProxyValue);
+}
+
+// Re-export so callers don't need a separate import
+export type { DashboardAPI };
+
+// Convenience stream type used internally so live record viewing works
+// for arbitrary models without the developer having to pre-create one.
+// (Built lazily per model+selection because createStreamType is keyed on the
+// shape of the selection.)
+const allFieldsStreams = new Map<string, ReturnType<typeof createStreamType>>();
+export function _dashboardAllFieldsStream(modelName: string) {
+    // Currently unused; kept for future "view live" feature.
+    void allFieldsStreams;
+    void modelName;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lowlander",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "TypeScript framework for data persistence, type-safe RPCs and real-time (partial) client synchronization.",
   "type": "module",
   "main": "./build/server/server.js",
@@ -21,34 +21,49 @@
       "bun": "./server/server.ts",
       "import": "./build/server/server.js",
       "types": "./build/server/server.d.ts"
+    },
+    "./dashboard": {
+      "bun": "./dashboard/index.ts",
+      "import": "./build/dashboard/index.js",
+      "types": "./build/dashboard/index.d.ts"
     }
   },
   "files": [
     "build/",
     "server/",
     "client/",
+    "dashboard/",
     "skill/"
   ],
   "scripts": {
-    "build": "tsc -b && cp -rf examples/helloworld/client/assets examples/helloworld/client/index.html build/examples/helloworld/client/ && npm run build:docs",
+    "build": "tsc -b && node --import=tsx/esm dashboard/build-bundle.ts && node --import=tsx/esm examples/helloworld/build-client.ts && npm run build:docs",
     "build:docs": "rm -rf skill ; mkdir skill ; cat skill-header.md README.md > skill/SKILL.md && readme-tsdoc --split --file skill/SKILL.md && readme-tsdoc --repo-url https://github.com/vanviegen/lowlander",
-    "typecheck": "bun x tsc -b",
+    "typecheck": "npx tsc -b",
     "clean": "rm -rf build dist skill",
-    "prepack": "bun install && bun run build",
-    "test": "bun test",
+    "prepack": "npm run build",
+    "test": "vitest run",
+    "test:e2e": "shotest test",
+    "test:e2e:review": "shotest review",
+    "example": "npm run build && (cd examples/helloworld && npm install) && node build/examples/helloworld/server/main.js",
     "postinstall": "[ -f .local-post-install.sh ] && sh .local-post-install.sh || true"
   },
   "dependencies": {
-    "warpsocket": "^0.8.3"
+    "warpsocket": "^0.9.1"
   },
   "peerDependencies": {
-    "aberdeen": "^1.10.1",
-    "edinburgh": "^0.6.1"
+    "aberdeen": "^1.17.1",
+    "edinburgh": "^0.6.4"
   },
   "devDependencies": {
-    "@types/bun": "^1.3.10",
-    "aberdeen": "^1.10.1",
-    "readme-tsdoc": "^1.1.6"
+    "@types/node": "^20.19.41",
+    "aberdeen": "^1.17.1",
+    "esbuild": "^0.28.0",
+    "readme-tsdoc": "^1.1.8",
+    "shotest": "^1.6.1",
+    "sirv": "^3.0.2",
+    "staffa": "0.3.1",
+    "tsx": "^4.0.0",
+    "vitest": "^4.1.7"
   },
   "workspaces": [
     "examples/*"

package/server/server.ts

@@ -1,6 +1,9 @@
 import * as E from "edinburgh";
 import DataPack from "edinburgh/datapack";
 import * as realWarpsocket from 'warpsocket';
+import { randomBytes } from 'crypto';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
 
 // Get log level from environment variable
 // 0: no logging (default)
@@ -22,6 +25,11 @@ const CHANNEL_TYPE_MODEL = 1;
 
 /** @internal Registry mapping model classes to their stream types */
 const streamTypesPerModel: Map<E.AnyModelClass, typeof StreamTypeBase<unknown>[]> = new Map();
+
+/** @internal Used by the dashboard module to inspect registered stream types. */
+export function getStreamTypesForModel(Model: E.AnyModelClass): readonly (typeof StreamTypeBase<unknown>)[] {
+    return streamTypesPerModel.get(Model) || [];
+}
  
 /**
  * Base class for stream types created by {@link createStreamType}.
@@ -29,8 +37,8 @@ const streamTypesPerModel: Map<E.AnyModelClass, typeof StreamTypeBase<unknown>[]
  * @internal
  */
 export abstract class StreamTypeBase<T> {
-    /** @internal */
-    static fields: { [key: string]: true|number };
+    /** @internal `true`=plain field, number=sub-stream id, `false`=virtual getter */
+    static fields: { [key: string]: boolean|number };
     /** @internal */
     static id: number;
     /** @internal */
@@ -128,7 +136,11 @@ function getIdForData(namespace: string, ...data: any): number {
 
     const countKey = new DataPack().write(namespace).toUint8Array();
     while(true) {
-        // Insert a new stream type
+        // Another worker may have won the race since we last checked
+        const existingPack = warpsocket.getKey(dataKey);
+        if (existingPack) {
+            return new DataPack(existingPack).readNumber();
+        }
         const countPack = warpsocket.getKey(countKey);
         const newCount = countPack ? new DataPack(countPack).readNumber() + 1 : 1;
         const newCountPack = new DataPack().write(newCount).toUint8Array();
@@ -182,25 +194,33 @@ export function createStreamType<T, S extends FieldSelection<T>>(
   Model: E.AnyModelClass & (new (...args: any[]) => T),
   selection: S & ValidateSelection<T, S>,
   options?: { cache?: number }
-): { new(instance: T): StreamTypeBase<Project<T, S>>; id: number; fields: Record<string, true|number>; cache?: number } {
+): { new(instance: T): StreamTypeBase<Project<T, S>>; id: number; fields: Record<string, boolean|number>; cache?: number } {
     let streamTypes = streamTypesPerModel.get(Model);
     if (!streamTypes) streamTypesPerModel.set(Model, streamTypes = []);
 
     const streamTypeId = getIdForData("streamType", Model.tableName, selection);
 
-    const fields: Record<string, true|number> = {};
+    const fields: Record<string, boolean|number> = {};
     for(const prop of Array.from(Object.keys(selection)).sort() as (string & keyof S)[]) {
+        const sel = (selection as any)[prop];
+
         if (!Model.fields.hasOwnProperty(prop)) {
+            // Allow selecting a getter on the model prototype as a virtual field
+            const desc = Object.getOwnPropertyDescriptor((Model as any).prototype, prop);
+            if (desc?.get && sel === true) {
+                fields[prop] = false;
+                continue;
+            }
             throw new Error(`Property ${prop} does not exist in model ${Model.name}`);
         }
         const LinkedModel = Model.fields[prop].type.getLinkedModel() as E.AnyModelClass | undefined;
 
-        if (selection[prop] === true) {
+        if (sel === true) {
             if (LinkedModel) throw new Error(`Property ${prop} is a link; must specify sub-selection`);
             fields[prop] = true; // Include field without tracking links
         } else {
             if (!LinkedModel) throw new Error(`Property ${prop} is not a link; cannot specify sub-selection`);
-            const SubStreamType = createStreamType(LinkedModel as any, selection[prop] as any)
+            const SubStreamType = createStreamType(LinkedModel as any, sel as any)
             fields[prop] = SubStreamType.id;
         }
     }
@@ -209,7 +229,9 @@ export function createStreamType<T, S extends FieldSelection<T>>(
         static id = streamTypeId;
         static cache = options?.cache;
     }
-    streamTypes.push(StreamType);
+    if (!streamTypes.some(st => (st as any).id === streamTypeId)) {
+        streamTypes.push(StreamType);
+    }
     return StreamType as any;
 }
 
@@ -251,6 +273,14 @@ function updateLinkDeltas(value: any, linkDeltas: Map<E.Model<unknown>, Map<numb
     }
 }
 
+/** Loose deep equality for getter result comparison (primitives via Object.is, objects via JSON). */
+function valuesEqual(a: any, b: any): boolean {
+    if (Object.is(a, b)) return true;
+    if (a == null || b == null) return false;
+    if (typeof a !== 'object' || typeof b !== 'object') return false;
+    try { return JSON.stringify(a) === JSON.stringify(b); } catch { return false; }
+}
+
 E.setOnSaveCallback((commitId: number, items: Map<E.Model<any>, E.Change>) => {
     if (logLevel >= 3) console.log('[lowlander] onSave', commitId);
     for(const [model, changed] of items.entries()) {
@@ -293,10 +323,24 @@ export function sendModel(target: Uint8Array | number | number[], model: E.Model
     else { // changed is an object or 'created'
         const linkDeltas = new Map<E.Model<unknown>, Map<number,number>>();
 
+        let oldClone: any;
+
         pack.writeCollection('object', (addRecord) => {
             for(const fieldName in StreamType.fields) {
+                const streamIndex = StreamType.fields[fieldName];
+
+                if (streamIndex === false) {
+                    const newVal = (model as any)[fieldName];
+                    if (typeof changed === 'object') {
+                        oldClone ??= Object.assign(Object.create(model), changed);
+                        if (valuesEqual(oldClone[fieldName], newVal)) continue;
+                    }
+                    addRecord(fieldName, newVal);
+                    mustSend = true;
+                    continue;
+                }
+
                 if (typeof changed === 'object' && !changed.hasOwnProperty(fieldName)) continue;
-                let streamIndex = StreamType.fields[fieldName];
 
                 let fieldValue = (model as any)[fieldName];
                 mustSend = true;
@@ -427,6 +471,7 @@ export class Socket<T> {
         return `{Socket id=${this.virtualSocketId}}`;
     }
 
+    /** @internal */
     [Symbol.for('nodejs.util.inspect.custom')]() {
         return this.toString();
     }
@@ -454,10 +499,16 @@ export async function start(mainApiFile: string, opts: {bind?: string, threads?:
     if (opts.injectWarpSocket) {
         warpsocket = opts.injectWarpSocket;
     }
+    const pwFile = join(process.cwd(), '.lowlander_dashboard_password');
+    if (!existsSync(pwFile)) try { writeFileSync(pwFile, randomBytes(24).toString('base64url'), { flag: 'wx' }); } catch {}
+    const password = process.env.LOWLANDER_DASHBOARD_PASSWORD ?? readFileSync(pwFile, 'utf8').trim();
+    if (!process.env.LOWLANDER_DASHBOARD_PASSWORD) {
+        console.log(`\n${'='.repeat(56)}\n  Lowlander dashboard password:  ${password}\n${'='.repeat(56)}\n`);
+    }
     await warpsocket.start({
         bind: opts.bind || '0.0.0.0:8080',
         threads: opts.threads,
         workerPath: WSHANDLER_FILE,
-        workerArg: mainApiFile,
+        workerArg: { apiFile: mainApiFile, password },
     });
 }