@noya-app/noya-multiplayer-react 0.1.61 → 0.1.63

package/src/inspector/zip/TinyZip.ts

@@ -0,0 +1,464 @@
+/* eslint-disable @shopify/prefer-early-return */
+
+// TinyZip.ts — ultra-lightweight ZIP writer (no deps)
+// - UTF-8 file names, Store only (no compression)
+// - Optional top-level root folder so unzip creates a single directory
+// - No Zip64 (files and total size must be < 4 GiB)
+
+import { crc32 } from "./crc32";
+import { defineSchema, defineSchemas, readStruct, writeStruct } from "./struct";
+
+export interface AddFileOptions {
+  date?: Date;
+}
+
+export interface TinyZipOptions {
+  /** Place all entries under this top-level folder; creates the dir entry automatically. */
+  root?: string;
+}
+
+interface CentralEntry {
+  nameBytes: Uint8Array;
+  crc: number;
+  compSize: number;
+  uncompSize: number;
+  method: number;
+  time: number;
+  dosDate: number;
+  localHeaderOffset: number;
+  externalAttrs: number; // DOS attrs low byte (0x10 = directory)
+}
+
+// -------------------------
+// Top-level helpers (no state)
+// -------------------------
+const te = new TextEncoder();
+
+function utf8(s: string): Uint8Array {
+  return te.encode(s);
+}
+
+function dosDateTime(d: Date = new Date()): {
+  time: number;
+  date: number;
+} {
+  const time =
+    (d.getHours() << 11) |
+    (d.getMinutes() << 5) |
+    Math.floor(d.getSeconds() / 2);
+  const date =
+    ((d.getFullYear() - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate();
+  return { time, date };
+}
+
+// ZIP constants
+const SIG = {
+  LocalFile: 0x04034b50,
+  CentralFile: 0x02014b50,
+  EOCD: 0x06054b50,
+} as const;
+
+const SCHEMA = defineSchemas({
+  LocalFile: defineSchema([
+    { name: "signature", type: "u32" },
+    { name: "versionNeeded", type: "u16" },
+    { name: "flags", type: "u16" },
+    { name: "method", type: "u16" },
+    { name: "time", type: "u16" },
+    { name: "date", type: "u16" },
+    { name: "crc32", type: "u32" },
+    { name: "compSize", type: "u32" },
+    { name: "uncompSize", type: "u32" },
+    { name: "nameLen", type: "u16" },
+    { name: "extraLen", type: "u16" },
+    { name: "name", type: "bytes", length: (c) => c.nameLen },
+    { name: "extra", type: "bytes", length: (c) => c.extraLen },
+  ]),
+  CentralFile: defineSchema([
+    { name: "signature", type: "u32" },
+    { name: "versionMadeBy", type: "u16" },
+    { name: "versionNeeded", type: "u16" },
+    { name: "flags", type: "u16" },
+    { name: "method", type: "u16" },
+    { name: "time", type: "u16" },
+    { name: "date", type: "u16" },
+    { name: "crc32", type: "u32" },
+    { name: "compSize", type: "u32" },
+    { name: "uncompSize", type: "u32" },
+    { name: "nameLen", type: "u16" },
+    { name: "extraLen", type: "u16" },
+    { name: "commentLen", type: "u16" },
+    { name: "diskStart", type: "u16" },
+    { name: "intAttrs", type: "u16" },
+    { name: "extAttrs", type: "u32" },
+    { name: "localHeaderOffset", type: "u32" },
+    { name: "name", type: "bytes", length: (c) => c.nameLen },
+    { name: "extra", type: "bytes", length: (c) => c.extraLen },
+    { name: "comment", type: "bytes", length: (c) => c.commentLen },
+  ]),
+  EOCD: defineSchema([
+    { name: "signature", type: "u32" },
+    { name: "diskNum", type: "u16" },
+    { name: "cdStartDisk", type: "u16" },
+    { name: "cdRecordsOnDisk", type: "u16" },
+    { name: "cdRecordsTotal", type: "u16" },
+    { name: "cdSize", type: "u32" },
+    { name: "cdOffset", type: "u32" },
+    { name: "commentLen", type: "u16" },
+    { name: "comment", type: "bytes", length: (c) => c.commentLen },
+  ]),
+});
+
+function ensureSig(v: number, expect: number, where: string) {
+  if (v !== expect)
+    throw new Error(`Invalid signature for ${where}: 0x${v.toString(16)}`);
+}
+
+// -------------------------
+// TinyZip (writer)
+// -------------------------
+export class TinyZip {
+  private _chunks: Uint8Array[] = [];
+  private _offset = 0;
+  private _files: CentralEntry[] = [];
+
+  private _rootPrefix = ""; // e.g. "my-archive/" or ""
+  private _rootDirAdded = false;
+
+  constructor(opts: TinyZipOptions = {}) {
+    if (opts.root) {
+      const r = opts.root.replace(/^\/+|\/+$/g, "");
+      if (r) this._rootPrefix = r + "/";
+    }
+  }
+
+  private _push(...arrs: Uint8Array[]) {
+    for (const a of arrs) {
+      this._chunks.push(a);
+      this._offset += a.length;
+    }
+  }
+  private _withRoot(name: string): string {
+    return this._rootPrefix && !name.startsWith(this._rootPrefix)
+      ? this._rootPrefix + name.replace(/^\/+/, "")
+      : name;
+  }
+
+  private _ensureRootDir(date: Date = new Date()) {
+    if (!this._rootPrefix || this._rootDirAdded) return;
+    this._rootDirAdded = true;
+
+    const dirName = this._rootPrefix; // already ends with '/'
+    const nameBytes = utf8(dirName);
+    const { time, date: dosDate } = dosDateTime(date);
+
+    const localHeader = writeStruct(SCHEMA.LocalFile, {
+      signature: SIG.LocalFile,
+      versionNeeded: 20,
+      flags: 0x0800,
+      method: 0,
+      time,
+      date: dosDate,
+      crc32: 0,
+      compSize: 0,
+      uncompSize: 0,
+      nameLen: nameBytes.length,
+      extraLen: 0,
+      name: nameBytes,
+      extra: new Uint8Array(0),
+    });
+
+    const localHeaderOffset = this._offset;
+    this._push(localHeader);
+    this._files.push({
+      nameBytes,
+      crc: 0,
+      compSize: 0,
+      uncompSize: 0,
+      method: 0,
+      time,
+      dosDate,
+      localHeaderOffset,
+      externalAttrs: 0x10,
+    });
+  }
+
+  /** Add a file to the zip. "name" uses forward slashes for paths (e.g., "dir/file.txt"). */
+  addFile(
+    name: string,
+    data: string | Uint8Array | ArrayBuffer,
+    opts: AddFileOptions = {}
+  ): void {
+    const { date = new Date() } = opts;
+    this._ensureRootDir(date);
+
+    const u8 = toU8(data);
+
+    const fullName = this._withRoot(name);
+    const nameBytes = utf8(fullName);
+    const { time, date: dosDate } = dosDateTime(date);
+    const crc = crc32(u8);
+
+    const compSize = u8.length >>> 0;
+    const uncompSize = u8.length >>> 0;
+    const localHeaderOffset = this._offset;
+
+    const localHeader = writeStruct(SCHEMA.LocalFile, {
+      signature: SIG.LocalFile,
+      versionNeeded: 20,
+      flags: 0x0800,
+      method: 0,
+      time,
+      date: dosDate,
+      crc32: crc,
+      compSize,
+      uncompSize,
+      nameLen: nameBytes.length,
+      extraLen: 0,
+      name: nameBytes,
+      extra: new Uint8Array(0),
+    });
+
+    this._push(localHeader, u8);
+
+    this._files.push({
+      nameBytes,
+      crc,
+      compSize,
+      uncompSize,
+      method: 0,
+      time,
+      dosDate,
+      localHeaderOffset,
+      externalAttrs: 0,
+    });
+  }
+
+  // Create an explicit directory entry (name should end with "/").
+  addDirectory(name: string, opts: { date?: Date } = {}): void {
+    const { date = new Date() } = opts;
+    this._ensureRootDir(date);
+
+    const dirNameRaw = name.endsWith("/") ? name : name + "/";
+    const fullName = this._withRoot(dirNameRaw);
+    const nameBytes = utf8(fullName);
+    const { time, date: dosDate } = dosDateTime(date);
+
+    const localHeader = writeStruct(SCHEMA.LocalFile, {
+      signature: SIG.LocalFile,
+      versionNeeded: 20,
+      flags: 0x0800,
+      method: 0,
+      time,
+      date: dosDate,
+      crc32: 0,
+      compSize: 0,
+      uncompSize: 0,
+      nameLen: nameBytes.length,
+      extraLen: 0,
+      name: nameBytes,
+      extra: new Uint8Array(0),
+    });
+
+    const localHeaderOffset = this._offset;
+    this._push(localHeader);
+
+    this._files.push({
+      nameBytes,
+      crc: 0,
+      compSize: 0,
+      uncompSize: 0,
+      method: 0,
+      time,
+      dosDate,
+      localHeaderOffset,
+      externalAttrs: 0x10,
+    });
+  }
+
+  finish(): Uint8Array {
+    const cdStart = this._offset;
+
+    for (const f of this._files) {
+      const central = writeStruct(SCHEMA.CentralFile, {
+        signature: SIG.CentralFile,
+        versionMadeBy: 20,
+        versionNeeded: 20,
+        flags: 0x0800,
+        method: f.method,
+        time: f.time,
+        date: f.dosDate,
+        crc32: f.crc,
+        compSize: f.compSize,
+        uncompSize: f.uncompSize,
+        nameLen: f.nameBytes.length,
+        extraLen: 0,
+        commentLen: 0,
+        diskStart: 0,
+        intAttrs: 0,
+        extAttrs: f.externalAttrs,
+        localHeaderOffset: f.localHeaderOffset,
+        name: f.nameBytes,
+        extra: new Uint8Array(0),
+        comment: new Uint8Array(0),
+      });
+      this._push(central);
+    }
+
+    const cdSize = this._offset - cdStart;
+
+    const eocd = writeStruct(SCHEMA.EOCD, {
+      signature: SIG.EOCD,
+      diskNum: 0,
+      cdStartDisk: 0,
+      cdRecordsOnDisk: this._files.length,
+      cdRecordsTotal: this._files.length,
+      cdSize,
+      cdOffset: cdStart,
+      commentLen: 0,
+      comment: new Uint8Array(0),
+    });
+
+    this._push(eocd);
+
+    const merged = new Uint8Array(this._offset);
+    let offset = 0;
+    for (const chunk of this._chunks) {
+      merged.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return merged;
+  }
+
+  static create(
+    files: Record<string, string | Uint8Array | ArrayBuffer>,
+    opts: TinyZipOptions = {}
+  ): Uint8Array {
+    const zip = new TinyZip(opts);
+    for (const [name, data] of Object.entries(files)) {
+      if (name.endsWith("/")) zip.addDirectory(name);
+      else zip.addFile(name, data);
+    }
+    return zip.finish();
+  }
+
+  static parse(input: ArrayBuffer | Uint8Array): ParsedEntry[] {
+    const u8 = toU8(input);
+    const view = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
+
+    // EOCD
+    const eocdOff = findEOCDOffset(u8);
+    const { value: eocd } = readStruct(view, eocdOff, SCHEMA.EOCD);
+    ensureSig(eocd.signature, SIG.EOCD, "EOCD");
+    if (eocd.commentLen !== 0) throw new Error("Unsupported: EOCD comment");
+    if (eocd.diskNum !== 0 || eocd.cdStartDisk !== 0)
+      throw new Error("Unsupported: multi-disk");
+
+    // Central directory walk
+    const entries: {
+      name: string;
+      isDirectory: boolean;
+      crc32: number;
+      size: number;
+      compSize: number;
+      time: number;
+      dosDate: number;
+      localHeaderOffset: number;
+    }[] = [];
+    let cdPtr = eocd.cdOffset;
+    for (let i = 0; i < eocd.cdRecordsTotal; i++) {
+      const { value: cdf, offset: next } = readStruct(
+        view,
+        cdPtr,
+        SCHEMA.CentralFile
+      );
+      ensureSig(cdf.signature, SIG.CentralFile, "Central Directory");
+      const name = new TextDecoder().decode(cdf.name);
+      const isDir = (cdf.extAttrs & 0x10) !== 0 || name.endsWith("/");
+      if (cdf.extraLen !== 0 || cdf.commentLen !== 0)
+        throw new Error("Unsupported: extra/comment in central dir");
+      entries.push({
+        name,
+        isDirectory: isDir,
+        crc32: cdf.crc32 >>> 0,
+        size: cdf.uncompSize >>> 0,
+        compSize: cdf.compSize >>> 0,
+        time: cdf.time >>> 0,
+        dosDate: cdf.date >>> 0,
+        localHeaderOffset: cdf.localHeaderOffset >>> 0,
+      });
+      cdPtr = next;
+    }
+
+    // Resolve data from local file headers
+    const results: ParsedEntry[] = [];
+    for (const e of entries) {
+      const { value: lfh, offset: afterHeader } = readStruct(
+        view,
+        e.localHeaderOffset,
+        SCHEMA.LocalFile
+      );
+      ensureSig(lfh.signature, SIG.LocalFile, "Local File");
+      if (lfh.flags !== 0x0800)
+        throw new Error("Unsupported: flags (expect UTF-8 only)");
+      if (lfh.method !== 0)
+        throw new Error("Unsupported: compression (expect store only)");
+      if (lfh.extraLen !== 0)
+        throw new Error("Unsupported: extra fields in local header");
+
+      const dataStart = afterHeader;
+      const dataEnd = dataStart + lfh.compSize;
+      const data = e.isDirectory
+        ? new Uint8Array(0)
+        : new Uint8Array(u8.subarray(dataStart, dataEnd));
+
+      results.push({ ...e, data });
+    }
+
+    return results;
+  }
+
+  // Quick utility: return a map of file data (directories omitted)
+  static extract(input: ArrayBuffer | Uint8Array): Record<string, Uint8Array> {
+    const entries = this.parse(input);
+    const out: Record<string, Uint8Array> = {};
+    for (const e of entries) if (!e.isDirectory) out[e.name] = e.data;
+    return out;
+  }
+}
+
+// -------------------------
+// Reader for TinyZip archives (our subset only)
+// -------------------------
+export interface ParsedEntry {
+  name: string;
+  isDirectory: boolean;
+  crc32: number;
+  size: number; // uncompressed
+  compSize: number; // same as size for store
+  time: number;
+  dosDate: number;
+  localHeaderOffset: number;
+  data: Uint8Array; // empty for directories
+}
+
+function toU8(input: string | ArrayBuffer | Uint8Array): Uint8Array {
+  if (typeof input === "string") return utf8(input);
+  if (input instanceof Uint8Array) return input;
+  return new Uint8Array(input);
+}
+
+function findEOCDOffset(u8: Uint8Array): number {
+  const view = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
+  const minSize = 22; // EOCD without comment
+  if (u8.length >= minSize) {
+    const at = u8.length - minSize;
+    if (view.getUint32(at, true) === SIG.EOCD) return at;
+  }
+  // Fallback: scan last 1 KiB for signature
+  const start = Math.max(0, u8.length - 1024);
+  for (let i = u8.length - 4; i >= start; i--) {
+    if (view.getUint32(i, true) === SIG.EOCD) return i;
+  }
+  throw new Error("EOCD not found");
+}

package/src/inspector/zip/crc32.ts

@@ -0,0 +1,16 @@
+const CRC_TABLE: Uint32Array = (() => {
+  const t = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    t[i] = c >>> 0;
+  }
+  return t;
+})();
+
+export function crc32(u8: Uint8Array): number {
+  let c = 0xffffffff;
+  for (let i = 0; i < u8.length; i++)
+    c = CRC_TABLE[(c ^ u8[i]) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}

package/src/inspector/zip/struct.ts

@@ -0,0 +1,117 @@
+// -------------------------
+// Declarative header schemas + (en|de)coders
+// -------------------------
+type ScalarType = "u8" | "u16" | "u32";
+
+type LenFn = (ctx: Record<string, any>) => number;
+
+// Typed schema helpers
+type NumberField<Name extends string, Kind extends ScalarType> = {
+  name: Name;
+  type: Kind;
+};
+
+type BytesField<Name extends string> = {
+  name: Name;
+  type: "bytes";
+  length: number | LenFn;
+};
+
+type SchemaFieldConst<Name extends string = string> =
+  | NumberField<Name, ScalarType>
+  | BytesField<Name>;
+
+type FieldValue<F> = F extends { type: "bytes" } ? Uint8Array : number;
+
+type StructFromSchema<S extends readonly SchemaFieldConst<string>[]> = {
+  [F in S[number] as F["name"] & string]: FieldValue<F>;
+};
+
+export const defineSchema = <
+  const S extends readonly SchemaFieldConst<string>[],
+>(
+  s: S
+) => s;
+export const defineSchemas = <
+  const M extends Record<string, readonly SchemaFieldConst<string>[]>,
+>(
+  m: M
+) => m;
+
+export type SchemaStructs<
+  M extends Record<string, readonly SchemaFieldConst<string>[]>,
+> = {
+  [K in keyof M]: StructFromSchema<M[K]>;
+};
+
+export function sizeofFieldSpec(
+  f: SchemaFieldConst<string>,
+  ctx: Record<string, any>
+): number {
+  if (f.type === "bytes")
+    return typeof f.length === "function" ? (f.length as LenFn)(ctx) : f.length;
+  return f.type === "u8" ? 1 : f.type === "u16" ? 2 : 4;
+}
+
+export function writeStruct<S extends readonly SchemaFieldConst<string>[]>(
+  schema: S,
+  values: StructFromSchema<S>
+): Uint8Array {
+  // compute total size (bytes fields may depend on previously set values)
+  let total = 0;
+  const ctx: Record<string, any> = { ...(values as any) };
+  for (const f of schema) total += sizeofFieldSpec(f, ctx);
+
+  const out = new Uint8Array(total);
+  const view = new DataView(out.buffer);
+  let o = 0;
+  const vals = values as unknown as Record<string, any>;
+  for (const f of schema) {
+    if (f.type === "bytes") {
+      const b: Uint8Array = vals[f.name];
+      out.set(b, o);
+      o += b.length;
+      continue;
+    }
+    const n = Number(vals[f.name]) >>> 0;
+    if (f.type === "u8") {
+      view.setUint8(o, n);
+      o += 1;
+    } else if (f.type === "u16") {
+      view.setUint16(o, n, true);
+      o += 2;
+    } else {
+      view.setUint32(o, n, true);
+      o += 4;
+    }
+  }
+  return out;
+}
+
+export function readStruct<S extends readonly SchemaFieldConst<string>[]>(
+  view: DataView,
+  offset: number,
+  schema: S
+): { value: StructFromSchema<S>; offset: number } {
+  const ctx: Record<string, any> = {};
+  let o = offset;
+  for (const f of schema) {
+    if (f.type === "bytes") {
+      const len =
+        typeof f.length === "function" ? (f.length as LenFn)(ctx) : f.length;
+      const u8 = new Uint8Array(view.buffer, view.byteOffset + o, len);
+      ctx[f.name] = new Uint8Array(u8); // copy for safety
+      o += len;
+    } else if (f.type === "u8") {
+      ctx[f.name] = view.getUint8(o);
+      o += 1;
+    } else if (f.type === "u16") {
+      ctx[f.name] = view.getUint16(o, true);
+      o += 2;
+    } else {
+      ctx[f.name] = view.getUint32(o, true);
+      o += 4;
+    }
+  }
+  return { value: ctx as StructFromSchema<S>, offset: o };
+}

package/src/noyaApp.ts

@@ -1,4 +1,5 @@
-/* eslint-disable no-restricted-globals */
+"use client";
+
 import { findAllDefs } from "@noya-app/noya-schemas";
 import {
   createOrCastValue,

package/src/useObservable.ts

@@ -1,3 +1,5 @@
+"use client";
+
 import {
   GetAtPath,
   Observable,