WIP

Author: cowboyd

deno.json

@@ -38,6 +38,7 @@
     "./worker",
     "./stream-helpers",
     "./signals",
-    "./process"
+    "./process",
+    "./inspector"
   ]
 }

inspector/context/implementation.ts

@@ -0,0 +1,81 @@
+import { type Scope, type Stream, useScope } from "effection";
+import { createImplementation } from "../lib/implementation.ts";
+import { type ContextNode, type ContextData, protocol } from "./protocol.ts";
+
+export const context = createImplementation(protocol, function* () {
+  let scope = yield* useScope();
+  return {
+    *readContextTree(): Stream<never, ContextNode> {
+      return {
+        *next() {
+          return {
+            done: true,
+            value: readTree(scope),
+          };
+        },
+      };
+    }
+  };
+});
+
+interface V3Frame {
+  context: Record<string, unknown>;
+  children: Set<V3Frame>;
+}
+
+interface V3Scope {
+  frame: V3Frame;
+}
+
+interface V4Scope {
+  contexts: Record<string, unknown>;
+  children: V4Scope[];
+}
+
+function readTree(scope: Scope): ContextNode {
+  if (isV3Scope(scope)) {
+    return readV3Tree(scope);
+  } else if (isV4Scope(scope)) {
+    return readV4Tree(scope);
+  } else {
+    throw new TypeError(`unrecognizable scope type`);
+  }
+}
+
+function isV3Scope(value: Scope): value is Scope & V3Scope {
+  let hypothetical = value as Scope & V3Scope;
+  return hypothetical.frame && typeof hypothetical.frame.context === "object";
+}
+
+function isV4Scope(value: Scope): value is Scope & V4Scope {
+  let hypothetical = value as Scope & V4Scope;
+  return typeof hypothetical.contexts === "object";
+}
+
+function readV3Tree(scope: V3Scope): ContextNode {
+  let children = [...scope.frame.children].map((frame) => ({ frame }));
+  return {
+    data: readContextData(scope.frame.context),
+    children: children.map(readV3Tree),
+  };
+}
+
+function readV4Tree(scope: V4Scope): ContextNode {
+  let children = scope.contexts["@effection/scope.children"] as Set<V4Scope>;
+  return {
+    data: readContextData(scope.contexts),
+    children: [...children].map(readV4Tree),
+  };
+}
+
+// make anything serializable.
+function readContextData(contexts: Record<string, unknown>): ContextData {
+  let entries = Object.entries(contexts).map(([key, value]) => {
+    try {
+      return [key, JSON.parse(JSON.stringify(value))];      
+    } catch (_error) {
+      return [key, "unserializable"];
+    }
+  });
+  return Object.fromEntries(entries);
+}

inspector/context/protocol.ts

@@ -0,0 +1,27 @@
+import { scope } from "arktype";
+import { createProtocol } from "../lib/mod.ts";
+
+const schema = scope({
+  ContextData: {
+    values: "object.json",
+  },
+  ContextNode: {
+    data: "ContextData",
+    children: "ContextNode[]",
+  },
+  None: "never[]",
+}).export();
+
+export type ContextData = typeof schema.ContextData.infer;
+
+export type ContextNode = typeof schema.ContextNode.infer;
+
+export const protocol = createProtocol({
+  readContextTree: {
+    args: schema.None,
+    progress: schema.None,
+    returns: schema.ContextNode,
+  }
+});
+
+

inspector/deno.json

@@ -0,0 +1,12 @@
+{
+  "name": "@effectionx/inspector",
+  "version": "0.0.1",
+  "exports": "./mod.ts",
+  "license": "MIT",
+  "imports": {
+    "@standard-schema/spec": "npm:@standard-schema/spec@^1.0.0",
+    "arktype": "npm:arktype@^2.1.27",
+    "effection": "npm:effection@^3.6.1",
+    "zod": "npm:zod@^4.1.13"
+  }
+}

inspector/implementation.ts

@@ -0,0 +1 @@
+export * from "./context/implementation.ts";

inspector/lib/combine.ts

@@ -0,0 +1,64 @@
+// deno-lint-ignore-file no-explicit-any
+import type { Operation } from "effection";
+import type { Handle, Inspector, Methods, Protocol } from "./types.ts";
+
+export interface Combine {
+  protocols<A extends Methods>(protocols: [Protocol<A>]): Protocol<A>;
+  protocols<A extends Methods, B extends Methods>(
+    protocols: [Protocol<A>, Protocol<B>],
+  ): Protocol<A & B>;
+  protocols<A extends Methods, B extends Methods, C extends Methods>(
+    protocols: [Protocol<A>, Protocol<B>, Protocol<C>],
+  ): Protocol<A & B & C>;
+  protocols<
+    A extends Methods,
+    B extends Methods,
+    C extends Methods,
+    D extends Methods,
+  >(
+    protocols: [Protocol<A>, Protocol<B>, Protocol<C>, Protocol<D>],
+  ): Protocol<A & B & C & D>;
+
+  inspectors<A extends Methods>(inspectors: [Inspector<A>]): Inspector<A>;
+  inspectors<A extends Methods, B extends Methods>(
+    inspectors: [Inspector<A>, Inspector<B>],
+  ): Inspector<A & B>;
+  inspectors<A extends Methods, B extends Methods, C extends Methods>(
+    inspectors: [Inspector<A>, Inspector<B>, Inspector<C>],
+  ): Inspector<A & B & C>;
+  inspectors<
+    A extends Methods,
+    B extends Methods,
+    C extends Methods,
+    D extends Methods,
+  >(
+    inspectors: [Inspector<A>, Inspector<B>, Inspector<C>, Inspector<D>],
+  ): Inspector<A & B & C & D>;
+}
+
+export const combine: Combine = {
+  protocols: (...protocols: any[]) => {
+    return protocols.reduce((acc, protocol) => {
+      Object.assign(acc.methods, protocol.methods);
+      return acc;
+    }, { methods: {} }) as Protocol<Methods>;
+  },
+  inspectors: (...inspectors: any[]) => {
+    return inspectors.reduce(
+      (acc: Inspector<Methods>, inspector: Inspector<Methods>) => {
+        let protocol = combine.protocols([acc.protocol, inspector.protocol]);
+        let attach = function* (): Operation<Handle<Methods>> {
+          let a = yield* acc.attach();
+          let b = yield* inspector.attach();
+          let methods = Object.assign(a.methods, b.methods);
+          return {
+            protocol,
+            methods,
+            invoke: ({ name, args }) => methods[name](...args),
+          };
+        };
+        return { protocol, attach };
+      },
+    );
+  },
+};

inspector/lib/impl.ts

@@ -0,0 +1,24 @@
+import { lift, type Operation, type Stream } from "effection";
+
+export function fn<TArgs extends unknown[], TReturn>(
+  fn: (...args: TArgs) => TReturn,
+): (...args: TArgs) => Stream<never, TReturn> {
+  return lift((...args) => ({
+    *next() {
+      return { done: true, value: fn(...args) };
+    },
+  }));
+}
+
+export function op<TArgs extends unknown[], TReturn>(
+  fn: (...args: TArgs) => Operation<TReturn>,
+): (...args: TArgs) => Stream<never, TReturn> {
+  return lift((...args) => ({
+    *next() {
+      return {
+        done: true,
+        value: yield* fn(...args),
+      };
+    },
+  }));
+}

inspector/lib/implementation.ts

@@ -0,0 +1,23 @@
+import type {
+  Implementation,
+  Inspector,
+  Methods,
+  Protocol,
+} from "./types.ts";
+
+export function createImplementation<M extends Methods>(
+  protocol: Protocol<M>,
+  create: Implementation<M>,
+): Inspector<M> {
+  return {
+    protocol,
+    *attach() {
+      let methods = yield* create();
+      return {
+        protocol,
+        methods,
+        invoke: ({ name, args }) => methods[name](...args),
+      };
+    },
+  };
+}

inspector/lib/inspector.ts

@@ -0,0 +1 @@
+

inspector/lib/mod.ts

@@ -0,0 +1,2 @@
+export * from "./types.ts";
+export * from "./protocol.ts";