@reactivescript/runtime 0.0.0-stage → 0.1.0

package/dist/web.js

@@ -0,0 +1,615 @@
+// ../ref/compile/rt-web.ts
+import { Portal as WebPortal } from "@solidjs/web";
+import { getObserver } from "solid-js";
+import {
+  createSignal,
+  createMemo,
+  createEffect,
+  createOptimistic,
+  createOptimisticStore,
+  createStore,
+  createProjection,
+  createDeferred,
+  createErrorBoundary,
+  createContext,
+  Errored,
+  createComponent,
+  flush,
+  untrack,
+  latest,
+  isPending,
+  action,
+  refresh,
+  affects,
+  until,
+  onSettled,
+  onFlush,
+  NotReadyError,
+  getOwner,
+  runWithOwner
+} from "solid-js";
+import { getContext, setContext, $TARGET } from "@solidjs/signals";
+import { hydrate, render } from "@solidjs/web";
+var readWhole = (v) => {
+  if (v !== null && typeof v === "object") Reflect.ownKeys(v);
+  return v;
+};
+var readCopy = (v) => v === null || typeof v !== "object" ? v : Array.isArray(v) ? v.map(readCopy) : Object.fromEntries(Object.keys(v).map((k) => [k, readCopy(v[k])]));
+var latestWhole = (v) => v !== null && typeof v === "object" && v[$TARGET] !== void 0 ? readCopy(v) : v;
+var sameInput = (a, b) => {
+  if (Object.is(a, b)) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+  const pa = Object.getPrototypeOf(a), plain = (p) => p === Object.prototype || p === null || p === Array.prototype;
+  if (pa !== Object.getPrototypeOf(b) || !plain(pa)) return false;
+  const ka = Object.keys(a), kb = Object.keys(b);
+  return ka.length === kb.length && ka.every((k) => Object.prototype.hasOwnProperty.call(b, k) && sameInput(a[k], b[k]));
+};
+var ERR = { toString: () => "#error" };
+var PENDING_MARK = { toString: () => "#pending" };
+var fmt = (v) => v === ERR ? "#error" : v === PENDING_MARK ? "#pending" : v === void 0 ? "undefined" : typeof v === "string" ? v : JSON.stringify(v);
+var raw = (x) => x && typeof x === "object" && x[$TARGET] ? x[$TARGET].v : x;
+var isNode = (v) => typeof v === "function" || typeof v === "object" && v !== null && "nodeType" in v;
+var isView = (v) => isNode(v) || Array.isArray(v) && (v.length === 0 || v.every((x) => x == null || typeof x === "string" || isView(x)) && v.some((x) => x != null && typeof x !== "string"));
+function errorClass(name, params, message, id) {
+  const C = class extends Error {
+    constructor(...args) {
+      super("");
+      this.name = name;
+      params.forEach((p, i) => {
+        this[p] = args[i];
+      });
+      this.message = String(untrack(() => message(...args)));
+      if (id) this.$class = id;
+    }
+  };
+  Object.defineProperty(C, "name", { value: name });
+  Object.defineProperty(C, "declared", { value: true });
+  const f = ((...args) => new C(...args));
+  f.cls = C;
+  f.errorClass = name;
+  f.$class = id;
+  return f;
+}
+var PANIC = { panic: true };
+var isA = (err, classes) => !classes || classes.includes(PANIC) || classes.some((c) => {
+  const k = c?.cls ?? c;
+  if (typeof k !== "function") return false;
+  if (err instanceof k) return true;
+  const id = c.$class;
+  if (id && err && typeof err === "object" && err.$class === id) {
+    Object.setPrototypeOf(err, k.prototype);
+    return true;
+  }
+  return false;
+});
+function catchAcc(f, match, alt) {
+  const acc = untrack(() => createErrorBoundary(() => readWhole(f()), (err) => new Fallback(() => {
+    const e0 = err();
+    return match(e0) ? alt(e0) : new Forward(e0);
+  })));
+  return () => unwrapFallback(acc());
+}
+function tryCatch(f, match, alt) {
+  try {
+    return f();
+  } catch (err) {
+    if (err instanceof NotReadyError || !match(err)) throw err;
+    return alt(err);
+  }
+}
+var Fallback = class {
+  get;
+  constructor(g) {
+    this.get = g;
+  }
+};
+function unwrapFallback(v0) {
+  let v = v0;
+  if (v instanceof Fallback) v = v.get();
+  if (v instanceof Forward) throw v.err;
+  return v;
+}
+var NO_PROVISION = {};
+var Forward = class {
+  err;
+  constructor(e) {
+    this.err = e;
+  }
+};
+function wireCopy(v, where, fail) {
+  if (v === null || v === void 0 || typeof v === "string" || typeof v === "number" || typeof v === "boolean") return v;
+  if (Array.isArray(v)) return v.map((x, i) => wireCopy(x, `${where}[${i}]`, fail));
+  if (typeof v === "object") {
+    const proto = Object.getPrototypeOf(v);
+    if (proto === Object.prototype || proto === null) {
+      const o = {};
+      for (const k of Object.keys(v)) o[k] = wireCopy(v[k], `${where}.${k}`, fail);
+      return o;
+    }
+  }
+  return fail(`${where} is ${typeof v === "function" ? "a function" : `an instance of ${v.constructor?.name ?? "a class"}`}, which the wire cannot carry: send data`);
+}
+var wireFailure = (err) => err instanceof Error && err.constructor.declared ? err : new Error("Internal Server Error");
+var Flight = class {
+  key;
+  first;
+  settleFirst;
+  rejectFirst;
+  queue = [];
+  waiters = [];
+  started = false;
+  constructor(key) {
+    this.key = key;
+    this.first = new Promise((r, j) => {
+      this.settleFirst = r;
+      this.rejectFirst = j;
+    });
+    this.first.catch(() => {
+    });
+  }
+  push(x) {
+    const w = this.waiters.shift();
+    if (w) w(x);
+    else this.queue.push(x);
+  }
+  resolve(v) {
+    if (!this.started) {
+      this.started = true;
+      this.settleFirst(v);
+    }
+    this.push({ v });
+  }
+  reject(e) {
+    if (!this.started) {
+      this.started = true;
+      this.rejectFirst(e);
+    }
+    this.push({ e });
+  }
+  [Symbol.asyncIterator]() {
+    const next = () => new Promise((res, rej) => {
+      const take = (x) => {
+        if ("e" in x) rej(x.e);
+        else res({ value: x.v, done: false });
+      };
+      const q = this.queue.shift();
+      if (q) take(q);
+      else this.waiters.push(take);
+    });
+    return { next, return: async () => ({ value: void 0, done: true }) };
+  }
+};
+function createApp(opts) {
+  const flights = /* @__PURE__ */ new Map();
+  const lastKey = /* @__PURE__ */ new Map();
+  const truthOf = /* @__PURE__ */ new Map();
+  const registry = /* @__PURE__ */ new Map();
+  const contexts = /* @__PURE__ */ new Map();
+  const storeAccs = /* @__PURE__ */ new WeakSet();
+  const modules = /* @__PURE__ */ new Map();
+  const hoistedBy = /* @__PURE__ */ new Map();
+  const hoistedOf = /* @__PURE__ */ new WeakMap();
+  const log = [];
+  let currentEq = null;
+  let serverSeq = 0;
+  let classSeq = 0;
+  const jsErrors = /* @__PURE__ */ new Map();
+  const tracing = () => {
+    let ran = false;
+    new Promise(() => {
+      ran = true;
+    });
+    return !ran;
+  };
+  const flight = (key) => {
+    if (tracing()) return new Flight(key);
+    let f = flights.get(key);
+    if (!f) {
+      f = new Flight(key);
+      flights.set(key, f);
+    }
+    if (currentEq) lastKey.set(currentEq, key);
+    return f;
+  };
+  const named = (name, fn) => name ? ((...a) => {
+    const was = currentEq;
+    currentEq = name;
+    try {
+      return fn(...a);
+    } finally {
+      currentEq = was;
+    }
+  }) : fn;
+  const app = {
+    root: opts.root,
+    log,
+    flights,
+    lastKey,
+    asyncError: null,
+    /** Mount `view` on the root: build it, or (SV-3) adopt the page the server streamed into it. */
+    mount(view, hydrating = false) {
+      return hydrating ? hydrate(view, app.root) : render(view, app.root);
+    },
+    // the prelude: what `import pure { … } from "./prelude"` and the built-in names refer to
+    B: {
+      len: (x) => Array.isArray(x) || typeof x === "string" ? x.length : typeof x === "object" && x ? Object.keys(x).length : 0,
+      str: (x) => fmt(x),
+      map: (xs, f) => xs.map(f),
+      filter: (xs, f) => xs.filter(f),
+      sum: (xs) => xs.reduce((a, b) => a + b, 0),
+      every: (xs, f) => xs.every(f),
+      indexOf: (xs, f) => xs.findIndex(f),
+      fail: (msg) => {
+        throw Object.assign(new Error(msg), { panic: true });
+      },
+      // R-f-3: a JS throw — a panic, not in the failure row
+      fetch: (key) => opts.api?.fetch ? opts.api.fetch(key) : flight(String(key)),
+      log: (...a) => {
+        log.push(`log(${a.map(fmt).join(", ")})`);
+      }
+    },
+    /** `import pure { f } from "./api"`: every function is a flight keyed by its name and formatted arguments. */
+    /** MO-8: a class `api.d.rx` declares as an error: the real module's, or (in the harness) a stand-in `C(message)`. */
+    jsError: (name) => jsErrors.get(name) ?? (jsErrors.set(name, opts.api?.[name] ?? errorClass(name, ["message"], (m) => m ?? name, `${name}#${classSeq++}`)), jsErrors.get(name)),
+    api: (name) => opts.api ? opts.api[name] ?? (() => {
+      throw new Error(`./api has no ${name}`);
+    }) : (...a) => flight(`${name}:${a.map(fmt).join(",")}`),
+    // ---- the scenario harness's view of names (handler rows reach any live binding by name) ----
+    reg(name, e) {
+      let l = registry.get(name);
+      if (!l) registry.set(name, l = []);
+      l.push(e);
+      const h = hoistedBy.get(name);
+      if (h && e.get) {
+        hoistedOf.set(e.get, h);
+        hoistedBy.delete(name);
+      }
+    },
+    lookup(name) {
+      const l = registry.get(name);
+      if (!l?.length) throw new Error(`unbound ${name}`);
+      for (let i = l.length - 1; i >= 0; i--) if (l[i].w) return l[i];
+      return l[l.length - 1];
+    },
+    dget(name, live = false) {
+      const e = app.lookup(name);
+      return e.get ? live ? e.get() : app.snapshot(e.get) : e.value;
+    },
+    // live: inside a probe (R-12), the read itself
+    dset(name, keys, v, guess = false) {
+      const w = app.lookup(name).w;
+      if (!w) throw new Error(`W-1: write to non-source ${name}`);
+      if (guess) w.guess(v, keys);
+      else if (keys.length) w.path(keys, v);
+      else w.set(v);
+    },
+    // ---- declarations ----
+    /** `source x := e`: atomic → a signal; structured → a store behind a signal slot, so the root can be replaced (ST-1, ST-2a). */
+    source(name, init) {
+      void name;
+      if (typeof init === "object" && init !== null) {
+        const [store, setStore] = createStore(init);
+        const [get2, set2] = createSignal(store);
+        const w = {
+          set: (v) => {
+            if (typeof v === "function") {
+              setStore(v);
+              set2(store);
+            } else if (typeof v === "object" && v !== null) {
+              setStore(() => v);
+              set2(store);
+            } else set2(v);
+          },
+          path: (keys, v) => setStore((d) => {
+            let o = d;
+            for (const k of keys.slice(0, -1)) o = o[k];
+            o[keys[keys.length - 1]] = v;
+          }),
+          guess: () => {
+            throw new Error("OPTIMISTIC_NO_QUESTION");
+          }
+        };
+        return [get2, w];
+      }
+      const [get, set] = createSignal(init);
+      return [get, { set, path: () => {
+        throw new Error("a path write to an atomic source");
+      }, guess: () => {
+        throw new Error("OPTIMISTIC_NO_QUESTION");
+      } }];
+    },
+    /** `source x = e` (ST-5): createSignal(fn); with a guess written to it, a createOptimistic layer over that truth (AC-3);
+     *  written or probed by path, createStore(fn, {}) whose derive writes its draft. */
+    question(name, compute, opts2, mode, key) {
+      const fn = named(name, compute);
+      if (mode.optimistic && mode.structured) {
+        const [store, setStore] = createOptimisticStore((draft) => {
+          const r = fn(draft);
+          if (r instanceof Flight || r instanceof Promise) return (async () => assignDraft(draft, r instanceof Flight ? await r.first : await r))();
+          assignDraft(draft, r);
+        }, key ? [] : {}, key ? { key } : void 0);
+        const get2 = () => store;
+        storeAccs.add(get2);
+        const plain = () => {
+          throw new Error("a plain write to an optimistic store is not lowered yet");
+        };
+        return [get2, { set: plain, path: plain, guess: (v, keys = []) => setStore((d) => {
+          if (keys.length === 0) {
+            assignDraft(d, typeof v === "function" ? v(d) : v);
+            return;
+          }
+          let o = d;
+          for (const k of keys.slice(0, -1)) o = o[k];
+          const last = keys[keys.length - 1];
+          o[last] = typeof v === "function" ? v(o[last]) : v;
+        }) }];
+      }
+      if (mode.optimistic) {
+        const [truth, setTruth] = createSignal(fn, opts2);
+        const [get2, setGuess] = createOptimistic(() => truth());
+        truthOf.set(get2, truth);
+        return [get2, { set: setTruth, path: () => {
+          throw new Error("optimistic path writes are not lowered yet");
+        }, guess: setGuess }];
+      }
+      if (mode.structured) {
+        const [store, setStore] = createStore(async (draft) => {
+          const r = fn(draft);
+          const v = r instanceof Flight ? await r.first : await r;
+          if (v && typeof v === "object") {
+            for (const k of Object.keys(draft)) if (!(k in v)) delete draft[k];
+            Object.assign(draft, v);
+          }
+        }, {});
+        const get2 = () => store;
+        storeAccs.add(get2);
+        return [get2, { set: () => {
+          throw new Error("a root write to a derived store is not lowered yet");
+        }, path: (keys, v) => setStore((d) => {
+          let o = d;
+          for (const k of keys.slice(0, -1)) o = o[k];
+          o[keys[keys.length - 1]] = v;
+        }), guess: () => {
+          throw new Error("optimistic over a structured question source is not lowered yet");
+        } }];
+      }
+      const [get, set] = createSignal(fn, opts2);
+      return [get, { set, path: () => {
+        throw new Error("a path write to an atomic source");
+      }, guess: () => {
+        throw new Error("OPTIMISTIC_NO_QUESTION");
+      } }];
+    },
+    memo: (name, fn, opts2) => createMemo(named(name, fn), opts2),
+    deferred: (name, fn, opts2) => createDeferred(named(name, fn), opts2),
+    /** `x key k = e` (ST-4): a keyed projection. */
+    keyed: (name, key, fn) => {
+      const src = createMemo(named(name, () => fn()));
+      const p = createProjection(() => src(), [], { key });
+      return () => p;
+    },
+    // the answer is a memo (sync, or the tail await's); the projection reconciles it by key
+    /** `x = draft(pre x -> seed) { … }` (ST-3). */
+    draft: (seed, body) => {
+      const p = createProjection(body, seed);
+      return () => p;
+    },
+    /** `pre y` of another node (C-2): a companion memo carrying (current, previous), owned where `y` is declared. */
+    pre: (get) => {
+      const m = createMemo((st) => ({ cur: get(), prev: st ? st.cur : void 0 }));
+      return () => m().prev;
+    },
+    firstPaint: (f) => ({ loadingValue: untrack(f) }),
+    /** `effect (…) { … }`: compute, then apply; an error is an answer the apply receives (E-12); fires on a differing value (EF-2); a store enters whole, as a snapshot. */
+    effect(n, inputs, apply) {
+      const run = (vals) => {
+        const r = apply(vals);
+        return typeof r === "function" ? r : void 0;
+      };
+      let last = null;
+      createEffect((() => inputs().map(latestWhole)), { effect: (vals) => {
+        if (last && last.length === vals.length && vals.every((v, i) => sameInput(v, last[i]))) return;
+        last = vals;
+        return run(vals);
+      }, error: () => {
+        last = null;
+        return run(Array.from({ length: n }, () => ERR));
+      } });
+    },
+    /** `action f(…) { … }` (AC-1): a generator; a statement-level `await` is a hold-safe yield. */
+    action(gen) {
+      const run = action(gen);
+      return (...a) => {
+        const p = run(...a);
+        p.catch((e) => {
+          app.asyncError = e;
+        });
+        return p;
+      };
+    },
+    awaited: (v) => v instanceof Flight ? v.first : v,
+    /** RG-8: Solid's Portal — client-only: the server renders nothing for it, the browser renders it once it has the page. */
+    Portal: WebPortal,
+    /** CSS-2: a dynamic class with the view's scope class after it. */
+    scopedClass: (v, hash) => v == null || v === false || v === "" ? hash : `${v} ${hash}`,
+    /** SV-7b: a client question — not asked on the server; the browser asks it once hydrated (Solid's \`ssrSource: "client"\`). */
+    clientQuestion: (o) => ({ ...o ?? {}, ssrSource: "client" }),
+    /** 12 SF-2: a server fn as the client calls it — every call a flight. Asked in reactive scope it is a question, one
+     *  flight per arguments, as a JS import's; in imperative scope each call is a new request. \`fn\` is the module-level
+     *  \`"use server"\` function (SF-7a): the body in place, or — once Solid's \`transformDirectives\` has made it a reference
+     *  — a request to the server. */
+    serverRef(name, fn) {
+      return (...args) => {
+        const key = `${name}:${args.map(fmt).join(",")}`;
+        const question = !!getObserver();
+        if (question && flights.has(key)) return flights.get(key);
+        const fl = question ? flight(key) : new Flight(`${key}#${serverSeq++}`);
+        globalThis.__rx_app = app;
+        let p;
+        try {
+          p = Promise.resolve(fn(...args));
+        } catch (e) {
+          p = Promise.reject(e);
+        }
+        p.then((v) => fl.resolve(v), (e) => fl.reject(e));
+        return fl;
+      };
+    },
+    /** SF-6: a server fn's body (a generator, as an action's), driven by promises — not by an action: it is no change of
+     *  the client's — behind a wire that copies arguments and result and lets only declared failures through. */
+    serverCall(name, gen, args) {
+      return new Promise((resolve, reject) => {
+        const fail = (msg) => {
+          throw new Error(`WIRE_VALUE: ${name}: ${msg}`);
+        };
+        let g;
+        try {
+          g = gen(...args.map((a, i) => wireCopy(a, `argument ${i + 1}`, fail)));
+        } catch (e) {
+          reject(e);
+          return;
+        }
+        const step = (input, thrown) => {
+          const was = currentEq;
+          currentEq = null;
+          let r;
+          try {
+            r = untrack(() => thrown ? g.throw(input) : g.next(input));
+          } catch (e) {
+            reject(wireFailure(e));
+            return;
+          } finally {
+            currentEq = was;
+          }
+          if (r.done) {
+            try {
+              resolve(wireCopy(r.value, "its result", fail));
+            } catch (e) {
+              reject(e);
+            }
+            return;
+          }
+          Promise.resolve(r.value).then((v) => step(v, false), (e) => step(e, true));
+        };
+        step(void 0, false);
+      });
+    },
+    hoisted(name, get) {
+      let l = hoistedBy.get(name);
+      if (!l) hoistedBy.set(name, l = []);
+      l.push(get);
+    },
+    until: (p) => until(p),
+    // AC-6
+    onSettled: (f) => onSettled(f),
+    // EF-7
+    onFlush: (f) => onFlush(f),
+    // EF-8
+    refresh(name, get) {
+      const key = lastKey.get(name);
+      if (key) flights.delete(key);
+      for (const h of hoistedOf.get(get) ?? []) refresh(h);
+      const t = truthOf.get(get) ?? get;
+      refresh(storeAccs.has(t) ? t() : t);
+    },
+    affects: (get) => affects(get),
+    preOr: (v, init) => v === void 0 ? init() : v,
+    // ---- modules (09 MO-1): a dependency's factory runs once per app; its exports are shared by every importer ----
+    module(key, factory) {
+      let m = modules.get(key);
+      if (!m) {
+        m = factory(app);
+        modules.set(key, m);
+      }
+      return m;
+    },
+    // ---- context (RG-7) ----
+    owner: () => getOwner(),
+    /** `context x: T = d` (RG-7): the declaration is the identity; `d`, if any, is evaluated once, owned where it is declared. */
+    /** `context x: T = d` (RG-7): the declaration is the identity (a sentinel default: absence is ours to decide); `d` is
+     *  evaluated once, owned where it is declared — created now, so it takes its id there on both sides (SV-3). */
+    context(name, dflt) {
+      return { name, ctx: createContext(NO_PROVISION, name), dflt, owner: getOwner(), dv: dflt ? { get: createMemo(dflt) } : null };
+    },
+    provide(c, e) {
+      setContext(c.ctx, e);
+    },
+    use(c, owner) {
+      const e = getContext(c.ctx, owner ?? void 0);
+      if (e && e !== NO_PROVISION) return e;
+      if (c.dv) return c.dv;
+      throw new Error(`RG-7b: no provision for ${c.name}`);
+    },
+    useGet(c, owner) {
+      const e = app.use(c, owner);
+      return e.get ? e.get() : e.value;
+    },
+    runWithOwner,
+    // ---- reads ----
+    /** An imperative read sees σ (H-10): a pending value is a value; a snapshot of an error throws it (R-f-7). */
+    snapshot(get) {
+      try {
+        return untrack(get);
+      } catch (e) {
+        if (e instanceof NotReadyError) return PENDING_MARK;
+        throw e;
+      }
+    },
+    // ---- failures (R-f) ----
+    errorClass: (name, params, message) => errorClass(name, params, message, `${name}#${classSeq++}`),
+    // a declaration's identity: the same on both sides (SV-5a)
+    isA,
+    PANIC,
+    catchMemo: catchAcc,
+    tryCatch,
+    catchRead: (f, match, alt) => catchAcc(f, match, alt)(),
+    throw: (e) => {
+      throw e;
+    },
+    eq: (a, b) => raw(a) === raw(b),
+    untrack,
+    latest: (f) => latest(() => latestWhole(f())),
+    isPending: (f) => isPending(() => readWhole(f())),
+    fmt,
+    // ---- views: compiled JSX (compile/jsx.ts, generate "dom") does the rest ----
+    show: (v) => isView(v) ? v : fmt(v),
+    /** `errored fallback(e: A | B)`: a failure of another class passes to the boundary above (R-f-4) — the fallback hands it out
+     *  and a memo throws it there (a rethrow from the fallback itself did not recover until solidjs/solid#4277: ref/oracle/repros/dv7-rethrow.mjs). */
+    TypedErrored(props) {
+      const classes = props.classes;
+      const out = createComponent(Errored, {
+        fallback: (err) => {
+          const owner = getOwner();
+          const ok = createMemo(() => isA(err(), classes));
+          let shown = null;
+          return new Fallback(() => ok() ? shown ??= runWithOwner(owner, () => props.fallback(err)) : new Forward(err()));
+        },
+        get children() {
+          return props.children;
+        }
+      });
+      return createMemo(() => unwrapFallback(typeof out === "function" ? out() : out));
+    }
+  };
+  return app;
+}
+function assignDraft(draft, v) {
+  if (!v || typeof v !== "object") return;
+  if (Array.isArray(draft) && Array.isArray(v)) {
+    draft.length = v.length;
+    v.forEach((x, i) => {
+      draft[i] = x;
+    });
+    return;
+  }
+  for (const k of Object.keys(draft)) if (!(k in v)) delete draft[k];
+  Object.assign(draft, v);
+}
+export {
+  ERR,
+  Flight,
+  PENDING_MARK,
+  createApp,
+  flush,
+  fmt
+};

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@reactivescript/runtime",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "ReactiveScript's runtime (spec/11 CP-4a): createApp and the __rt helpers compiled .rx calls, over Solid, for the browser and the server",
+  "version": "0.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/solidjs/reactivescript.git",
+    "directory": "runtime"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "worker": {
+        "types": "./dist/server.d.ts",
+        "default": "./dist/server.js"
+      },
+      "browser": {
+        "types": "./dist/web.d.ts",
+        "default": "./dist/web.js"
+      },
+      "deno": {
+        "types": "./dist/server.d.ts",
+        "default": "./dist/server.js"
+      },
+      "node": {
+        "types": "./dist/server.d.ts",
+        "default": "./dist/server.js"
+      },
+      "types": "./dist/web.d.ts",
+      "default": "./dist/web.js"
+    },
+    "./web": {
+      "types": "./dist/web.d.ts",
+      "default": "./dist/web.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node build.mjs",
+    "prepack": "node build.mjs",
+    "test": "node test.mjs"
+  },
+  "peerDependencies": {
+    "@solidjs/signals": "^2.0.0-rc.21",
+    "@solidjs/web": "^2.0.0-rc.21",
+    "solid-js": "^2.0.0-rc.21"
+  },
+  "devDependencies": {
+    "@solidjs/signals": "2.0.0-rc.21",
+    "@solidjs/web": "2.0.0-rc.21",
+    "esbuild": "^0.28.2",
+    "solid-js": "2.0.0-rc.21",
+    "typescript": "^6.0.3"
+  }
+}