@jigs.design/runtime 0.0.0-stage → 0.1.1

package/dist/protocol.d.ts

@@ -0,0 +1,132 @@
+import { PickleErrorData, ProcedureEntry } from "./types.js";
+//#region src/protocol.d.ts
+/**
+ * Prop value on the wire. Functions never leave the worker; they travel as
+ * `{ fn }` ids. Lists of plain objects travel as `{ rows }`.
+ */
+export type WireValue = boolean | number | string | {
+  fn: string;
+} | {
+  rows: ReadonlyArray<Row>;
+};
+/** One row of a list prop: flat fields only. */
+export type Row = Readonly<Record<string, boolean | number | string | null>>;
+export type WireArg = boolean | number | string;
+/** The props of one node on the wire. */
+export type WireProps = Record<string, WireValue>;
+/** UI operations produced by the worker's reconciler. The root container has id 0. */
+export type Op = {
+  id: number;
+  op: "create";
+  props: WireProps;
+  type: string;
+} | {
+  id: number;
+  op: "createText";
+  text: string;
+} | {
+  id: number;
+  index: number;
+  op: "place";
+  parent: number;
+} | {
+  id: number;
+  op: "remove";
+} | {
+  id: number;
+  op: "set";
+  props: Record<string, WireValue | null>;
+} | {
+  id: number;
+  op: "text";
+  text: string;
+};
+export interface RuntimeError {
+  line: number | null;
+  message: string;
+}
+/** A query as the program sees it from `useQuery`. */
+export type QueryResult = {
+  data: null;
+  error: null;
+  status: "pending";
+} | {
+  data: unknown;
+  error: null;
+  status: "success";
+} | {
+  data: null;
+  error: PickleErrorData;
+  status: "error";
+};
+/** How a mutation settled. */
+export type MutationResult = {
+  data: unknown;
+  status: "success";
+} | {
+  error: PickleErrorData;
+  status: "error";
+};
+/** A query the program read during a render. `key` is stable for a name and input. */
+export interface QueryRead {
+  input: unknown;
+  key: string;
+  name: string;
+}
+/** A `mutate()` call made inside a handler. */
+export interface MutationCall {
+  id: number;
+  input: unknown;
+  name: string;
+}
+/** Page to worker. */
+export type HostMessage = {
+  args: ReadonlyArray<WireArg>;
+  fn: string;
+  seq: number;
+  type: "call";
+} | {
+  id: number;
+  result: MutationResult;
+  seq: number;
+  type: "mutation";
+} | {
+  key: string;
+  result: QueryResult;
+  seq: number;
+  type: "query";
+} | {
+  code: string;
+  /** Drop the state and mutation statuses of the program before. */
+  fresh: boolean;
+  procedures: Readonly<Record<string, ProcedureEntry>>;
+  prose: Readonly<Record<string, string>>;
+  seq: number;
+  type: "update";
+};
+/** Worker to page. */
+export type WorkerMessage = {
+  errors: Array<RuntimeError>;
+  mutations: Array<MutationCall>;
+  ops: Array<Op>;
+  queries: Array<QueryRead>;
+  seq: number;
+  type: "result";
+} | {
+  message: string;
+  seq: number;
+  type: "failed";
+};
+/** What the frame sends to the page. */
+export type FrameMessage = WorkerMessage | {
+  seq: number;
+  type: "quarantined";
+} | {
+  type: "ready";
+} |
+/** The frame's own security policy is not in force, so it will not run. */
+{
+  type: "unprotected";
+};
+export declare const ROOT_ID = 0;
+//#endregion

package/dist/protocol.js

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

package/dist/runtime-core.d.ts

@@ -0,0 +1,21 @@
+import { HostMessage, WorkerMessage } from "./protocol.js";
+//#region src/runtime-core.d.ts
+export interface Runtime {
+  handle: (message: HostMessage) => void;
+}
+/**
+ * The runtime that executes compiled programs inside the sandbox worker.
+ *
+ * It is shipped to the worker with `createRuntime.toString()`, so the body
+ * must not reference anything declared outside it (type imports are erased
+ * and fine). `FunctionCtor` is passed in because the worker removes dynamic
+ * code evaluation from its globals before any program runs.
+ *
+ * A small React-style reconciler: programs build a tree with `__pickle.jsx`,
+ * the runtime diffs it against the previous render by position and type, and
+ * posts the differences as `Op`s. Each render also reports the queries it read
+ * and the mutations its handlers called; the page runs those through the
+ * client and sends the results back.
+ */
+export declare function createRuntime(post: (message: WorkerMessage) => void, FunctionCtor: FunctionConstructor): Runtime;
+//#endregion