@agent-glue/glue 0.1.1 → 0.1.3

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
 
-> @agent-glue/glue@0.1.0 build /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+> @agent-glue/glue@0.1.2 build /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
 > tsc
 

package/.turbo/turbo-clean$colon$build.log

@@ -1 +1,5 @@
 
+
+> @agent-glue/glue@0.1.2 clean:build /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+> rimraf ./dist
+

package/.turbo/turbo-lint.log

@@ -1,5 +1,5 @@
 
 
-> @agent-glue/glue@0.1.0 lint /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+> @agent-glue/glue@0.1.2 lint /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
 > eslint .
 

package/.turbo/turbo-typecheck.log

@@ -1,5 +1,5 @@
 
 
-> @agent-glue/glue@0.1.0 typecheck /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+> @agent-glue/glue@0.1.2 typecheck /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
 > tsc --noEmit
 

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-glue/glue
 
+## 0.1.3
+
+### Patch Changes
+
+- Build issues
+
+## 0.1.2
+
+### Patch Changes
+
+- dcfb969: Broken build
+
 ## 0.1.1
 
 ### Patch Changes

package/dist/actor.js

@@ -1,32 +1,32 @@
 import { Emitter } from "./emitter.js";
 export class Actor {
-  emitter = new Emitter();
-  emit(event) {
-    this.emitter.emit(event);
-  }
-  send(_command) {
-    return;
-  }
-  connect(handler) {
-    return this.emitter.connect(handler);
-  }
-  disconnect(handler) {
-    this.emitter.disconnect(handler);
-  }
+    emitter = new Emitter();
+    emit(event) {
+        this.emitter.emit(event);
+    }
+    send(_command) {
+        return;
+    }
+    connect(handler) {
+        return this.emitter.connect(handler);
+    }
+    disconnect(handler) {
+        this.emitter.disconnect(handler);
+    }
 }
 export class FunctionActor extends Actor {
-  constructor(fn) {
-    super();
-    this.send = fn(this.emit.bind(this));
-  }
+    constructor(fn) {
+        super();
+        this.send = fn(this.emit.bind(this));
+    }
 }
 export function actor(fn) {
-  return new FunctionActor(fn);
+    return new FunctionActor(fn);
 }
 export function actorClass(handler) {
-  return class extends FunctionActor {
-    constructor() {
-      super(handler);
-    }
-  };
+    return class extends FunctionActor {
+        constructor() {
+            super(handler);
+        }
+    };
 }

package/dist/effects.js

@@ -1,67 +1,66 @@
 function defaultDiscriminator(m) {
-  return m === m;
+    return m === m;
 }
 export function take(actor, discriminator = defaultDiscriminator) {
-  return new Promise((resolve) => {
-    const handler = (message) => {
-      if (discriminator(message)) {
-        actor.disconnect(handler);
-        resolve(message);
-      }
-    };
-    actor.connect(handler);
-  });
+    return new Promise((resolve) => {
+        const handler = (message) => {
+            if (discriminator(message)) {
+                actor.disconnect(handler);
+                resolve(message);
+            }
+        };
+        actor.connect(handler);
+    });
 }
 export async function* takeEvery(actor) {
-  const eventQueue = [];
-  let resolve = null;
-  const disconnect = actor.connect((message) => {
-    if (resolve) {
-      resolve(message);
-      resolve = null;
-    } else {
-      eventQueue.push(message);
+    const eventQueue = [];
+    let resolve = null;
+    const disconnect = actor.connect((message) => {
+        if (resolve) {
+            resolve(message);
+            resolve = null;
+        }
+        else {
+            eventQueue.push(message);
+        }
+    });
+    try {
+        while (true) {
+            if (eventQueue.length > 0) {
+                yield eventQueue.shift();
+            }
+            else {
+                yield new Promise((res) => {
+                    resolve = res;
+                });
+            }
+        }
     }
-  });
-  try {
-    while (true) {
-      if (eventQueue.length > 0) {
-        yield eventQueue.shift();
-      } else {
-        yield new Promise((res) => {
-          resolve = res;
-        });
-      }
+    finally {
+        disconnect();
     }
-  } finally {
-    disconnect();
-  }
 }
 export async function* takeIf(actor, discriminator) {
-  for await (const event of takeEvery(actor)) {
-    if (discriminator(event)) {
-      yield event;
+    for await (const event of takeEvery(actor)) {
+        if (discriminator(event)) {
+            yield event;
+        }
     }
-  }
 }
-export async function* takeUntil(
-  actor,
-  discriminator,
-  endCondition = () => true
-) {
-  for await (const event of takeEvery(actor)) {
-    if (endCondition(event)) {
-      break;
+export async function* takeUntil(actor, discriminator, endCondition = () => true) {
+    for await (const event of takeEvery(actor)) {
+        if (endCondition(event)) {
+            break;
+        }
+        if (discriminator(event)) {
+            yield event;
+        }
     }
-    if (discriminator(event)) {
-      yield event;
-    }
-  }
 }
 export function on(actor, discriminator, handler) {
-  return actor.connect((message) => {
-    if (discriminator(message)) {
-      handler(message);
-    }
-  });
+    return actor.connect((message) => {
+        if (discriminator(message)) {
+            handler(message);
+        }
+    });
 }

package/dist/emitter.js

@@ -1,18 +1,19 @@
 import { TypedEmitter } from "./utils/TypedEmitter.js";
 export class Emitter {
-  emitter = new TypedEmitter();
-  emit(event) {
-    process.nextTick(() => this.emitter.emit("event", event));
-  }
-  connect(handler) {
-    this.emitter.on("event", handler);
-    return () => this.emitter.off("event", handler);
-  }
-  disconnect(handler) {
-    if (!handler) {
-      this.emitter.removeAllListeners();
-    } else {
-      this.emitter.off("event", handler);
+    emitter = new TypedEmitter();
+    emit(event) {
+        process.nextTick(() => this.emitter.emit("event", event));
+    }
+    connect(handler) {
+        this.emitter.on("event", handler);
+        return () => this.emitter.off("event", handler);
+    }
+    disconnect(handler) {
+        if (!handler) {
+            this.emitter.removeAllListeners();
+        }
+        else {
+            this.emitter.off("event", handler);
+        }
     }
-  }
 }

package/dist/message.js

@@ -1,18 +1,18 @@
 import { v7 as uuid } from "uuid";
 export function isMessageType(type) {
-  return (message) => message.type === type;
+    return (message) => message.type === type;
 }
 export function message(type) {
-  return (message) => {
-    return { ...message, type, id: uuid() };
-  };
+    return (message) => {
+        return { ...message, type, id: uuid() };
+    };
 }
 export function defineMessage(type) {
-  const factory = message(type);
-  const isMessage = isMessageType(type);
-  factory.is = isMessage;
-  factory.isMessage = isMessage;
-  factory.type = type;
-  factory.message = factory;
-  return factory;
+    const factory = message(type);
+    const isMessage = isMessageType(type);
+    factory.is = isMessage;
+    factory.isMessage = isMessage;
+    factory.type = type;
+    factory.message = factory;
+    return factory;
 }

package/dist/message.test.js

@@ -1,36 +1,37 @@
 import { describe, expect, expectTypeOf, it } from "vitest";
 import { defineMessage } from "./message.js";
 describe("defineMessage", () => {
-  it("should create a message definition and type guard", () => {
-    const TestMessage = defineMessage("test.type");
-    const msg = TestMessage({ data: "test" });
-    expect(msg.type).toBe("test.type");
-    expect(TestMessage.type).toBe("test.type");
-    expect(TestMessage.is(msg)).toBe(true);
-  });
-  describe("is", () => {
-    it("should allow checking if a message is of the defined type", () => {
-      const TestMessage = defineMessage("test.type");
-      const OtherMessage = defineMessage("other.type");
-      const msg = TestMessage({ data: "test" });
-      expect(TestMessage.is(msg)).toBe(true);
-      expect(OtherMessage.is(msg)).toBe(false);
-      const unknownMsg = msg;
-      if (TestMessage.is(unknownMsg)) {
-        expectTypeOf(unknownMsg).toEqualTypeOf();
-      } else {
-        expectTypeOf(unknownMsg).toEqualTypeOf();
-      }
+    it("should create a message definition and type guard", () => {
+        const TestMessage = defineMessage("test.type");
+        const msg = TestMessage({ data: "test" });
+        expect(msg.type).toBe("test.type");
+        expect(TestMessage.type).toBe("test.type");
+        expect(TestMessage.is(msg)).toBe(true);
     });
-  });
-  describe("message", () => {
-    it("should provide a message builder function", () => {
-      const TestMessage = defineMessage("test.type");
-      const msg = TestMessage.message({ data: "test" });
-      expectTypeOf(msg).toEqualTypeOf();
-      expect(msg.type).toBe("test.type");
-      expect(msg.data).toBe("test");
-      expect(TestMessage.is(msg)).toBe(true);
+    describe("is", () => {
+        it("should allow checking if a message is of the defined type", () => {
+            const TestMessage = defineMessage("test.type");
+            const OtherMessage = defineMessage("other.type");
+            const msg = TestMessage({ data: "test" });
+            expect(TestMessage.is(msg)).toBe(true);
+            expect(OtherMessage.is(msg)).toBe(false);
+            const unknownMsg = msg;
+            if (TestMessage.is(unknownMsg)) {
+                expectTypeOf(unknownMsg).toEqualTypeOf();
+            }
+            else {
+                expectTypeOf(unknownMsg).toEqualTypeOf();
+            }
+        });
+    });
+    describe("message", () => {
+        it("should provide a message builder function", () => {
+            const TestMessage = defineMessage("test.type");
+            const msg = TestMessage.message({ data: "test" });
+            expectTypeOf(msg).toEqualTypeOf();
+            expect(msg.type).toBe("test.type");
+            expect(msg.data).toBe("test");
+            expect(TestMessage.is(msg)).toBe(true);
+        });
     });
-  });
 });

package/dist/server/memory.js

@@ -1,54 +1,46 @@
 import { Actor } from "../actor.js";
 import { defineMessage } from "../message.js";
 import { event, isConnect, isSend } from "./protocol.js";
-export const {
-  message: localConnect,
-  isMessage: isLocalConnect,
-  type: LocalConnectType
-} = defineMessage("local-connect");
-export const {
-  message: localRegister,
-  isMessage: isLocalRegister,
-  type: LocalRegisterType
-} = defineMessage("local-register");
+export const { message: localConnect, isMessage: isLocalConnect, type: LocalConnectType } = defineMessage("local-connect");
+export const { message: localRegister, isMessage: isLocalRegister, type: LocalRegisterType } = defineMessage("local-register");
 export class LocalServer extends Actor {
-  store = new Map();
-  send(command) {
-    if (isSend(command)) {
-      const { destination, message } = command;
-      const actor = this.store.get(destination);
-      if (actor) {
-        actor.send(message);
-      }
-    } else if (isLocalConnect(command)) {
-      const { destination, callback } = command;
-      const actor = this.store.get(destination);
-      if (actor) {
-        actor.connect(callback);
-      }
-    } else if (isLocalRegister(command)) {
-      const { name, actor } = command;
-      this.store.set(name, actor);
+    store = new Map();
+    send(command) {
+        if (isSend(command)) {
+            const { destination, message } = command;
+            const actor = this.store.get(destination);
+            if (actor) {
+                actor.send(message);
+            }
+        }
+        else if (isLocalConnect(command)) {
+            const { destination, callback } = command;
+            const actor = this.store.get(destination);
+            if (actor) {
+                actor.connect(callback);
+            }
+        }
+        else if (isLocalRegister(command)) {
+            const { name, actor } = command;
+            this.store.set(name, actor);
+        }
     }
-  }
 }
 export class MemoryClient extends Actor {
-  server;
-  constructor(server) {
-    super();
-    this.server = server;
-  }
-  send(command) {
-    if (isSend(command)) {
-      this.server.send(command);
-    } else if (isConnect(command)) {
-      this.server.send(
-        localConnect({
-          destination: command.destination,
-          callback: (msg) =>
-            this.emit(event({ origin: command.destination, message: msg }))
-        })
-      );
+    server;
+    constructor(server) {
+        super();
+        this.server = server;
+    }
+    send(command) {
+        if (isSend(command)) {
+            this.server.send(command);
+        }
+        else if (isConnect(command)) {
+            this.server.send(localConnect({
+                destination: command.destination,
+                callback: (msg) => this.emit(event({ origin: command.destination, message: msg }))
+            }));
+        }
     }
-  }
 }

package/dist/server/protocol.js

@@ -1,16 +1,4 @@
 import { defineMessage } from "../message.js";
-export const {
-  message: send,
-  isMessage: isSend,
-  type: SendType
-} = defineMessage("send");
-export const {
-  message: connect,
-  isMessage: isConnect,
-  type: ConnectType
-} = defineMessage("connect");
-export const {
-  message: event,
-  isMessage: isEvent,
-  type: EventType
-} = defineMessage("event");
+export const { message: send, isMessage: isSend, type: SendType } = defineMessage("send");
+export const { message: connect, isMessage: isConnect, type: ConnectType } = defineMessage("connect");
+export const { message: event, isMessage: isEvent, type: EventType } = defineMessage("event");

package/dist/server/websocket.js

@@ -1,96 +1,72 @@
 import { Actor } from "../actor.js";
 import { defineMessage } from "../message.js";
-export const {
-  message: sendCommand,
-  isMessage: isSendCommand,
-  type: SendCommandType
-} = defineMessage("send-command");
-export const {
-  message: openEvent,
-  isMessage: isOpenEvent,
-  type: OpenEventType
-} = defineMessage("open-event");
-export const {
-  message: closeEvent,
-  isMessage: isCloseEvent,
-  type: CloseEventType
-} = defineMessage("close-event");
-export const {
-  message: errorEvent,
-  isMessage: isErrorEvent,
-  type: ErrorEventType
-} = defineMessage("error-event");
-export const {
-  message: messageEvent,
-  isMessage: isMessageEvent,
-  type: MessageEventType
-} = defineMessage("message-event");
+export const { message: sendCommand, isMessage: isSendCommand, type: SendCommandType } = defineMessage("send-command");
+export const { message: openEvent, isMessage: isOpenEvent, type: OpenEventType } = defineMessage("open-event");
+export const { message: closeEvent, isMessage: isCloseEvent, type: CloseEventType } = defineMessage("close-event");
+export const { message: errorEvent, isMessage: isErrorEvent, type: ErrorEventType } = defineMessage("error-event");
+export const { message: messageEvent, isMessage: isMessageEvent, type: MessageEventType } = defineMessage("message-event");
 export class WebsocketClient extends Actor {
-  ws;
-  constructor(ws) {
-    super();
-    this.ws = ws;
-    ws.addEventListener("open", () => {
-      this.emit(openEvent({}));
-    });
-    ws.addEventListener("message", (event) => {
-      this.emit(messageEvent({ message: event.data }));
-    });
-    ws.addEventListener("close", () => {
-      this.emit(closeEvent({}));
-    });
-    ws.addEventListener("error", (event) => {
-      this.emit(errorEvent({ error: event }));
-    });
-  }
-  send(command) {
-    if (isSendCommand(command)) {
-      this.ws.send(command.message);
+    ws;
+    constructor(ws) {
+        super();
+        this.ws = ws;
+        ws.addEventListener("open", () => {
+            this.emit(openEvent({}));
+        });
+        ws.addEventListener("message", (event) => {
+            this.emit(messageEvent({ message: event.data }));
+        });
+        ws.addEventListener("close", () => {
+            this.emit(closeEvent({}));
+        });
+        ws.addEventListener("error", (event) => {
+            this.emit(errorEvent({ error: event }));
+        });
+    }
+    send(command) {
+        if (isSendCommand(command)) {
+            this.ws.send(command.message);
+        }
     }
-  }
 }
 export class WebsocketClientWrapper extends Actor {
-  ws;
-  client;
-  constructor(ws) {
-    super();
-    this.ws = ws;
-    this.client = new WebsocketClient(ws);
-    this.client.connect((event) => {
-      if (isMessageEvent(event)) {
-        const message = JSON.parse(event.message);
-        this.emit(message);
-      }
-    });
-  }
-  send(command) {
-    this.client.send(sendCommand({ message: JSON.stringify(command) }));
-  }
+    ws;
+    client;
+    constructor(ws) {
+        super();
+        this.ws = ws;
+        this.client = new WebsocketClient(ws);
+        this.client.connect((event) => {
+            if (isMessageEvent(event)) {
+                const message = JSON.parse(event.message);
+                this.emit(message);
+            }
+        });
+    }
+    send(command) {
+        this.client.send(sendCommand({ message: JSON.stringify(command) }));
+    }
 }
-export const {
-  message: connectionEvent,
-  isMessage: isConnectionEvent,
-  type: ConnectionEventType
-} = defineMessage("connection-event");
+export const { message: connectionEvent, isMessage: isConnectionEvent, type: ConnectionEventType } = defineMessage("connection-event");
 export class WebsocketServer extends Actor {
-  wss;
-  constructor(wss) {
-    super();
-    this.wss = wss;
-    this.wss.on("connection", (ws) => {
-      this.emit(connectionEvent({ ws }));
-    });
-  }
+    wss;
+    constructor(wss) {
+        super();
+        this.wss = wss;
+        this.wss.on("connection", (ws) => {
+            this.emit(connectionEvent({ ws }));
+        });
+    }
 }
 export class WebsocketServerWrapper {
-  constructor(ws, actor) {
-    //const client = new WebsocketClient(ws);
-    const wrapper = new WebsocketClientWrapper(ws);
-    wrapper.connect((command) => {
-      actor.send(command);
-    });
-    actor.connect((event) => {
-      wrapper.send(event);
-    });
-  }
+    constructor(ws, actor) {
+        //const client = new WebsocketClient(ws);
+        const wrapper = new WebsocketClientWrapper(ws);
+        wrapper.connect((command) => {
+            actor.send(command);
+        });
+        actor.connect((event) => {
+            wrapper.send(event);
+        });
+    }
 }

package/dist/transformers.js

@@ -1,19 +1,17 @@
 import { actor } from "./actor.js";
 export function commandTransformer(fn) {
-  return (wrapped) =>
-    actor((emit) => {
-      wrapped.connect(emit);
-      return (command) => {
-        wrapped.send(fn(command));
-      };
+    return (wrapped) => actor((emit) => {
+        wrapped.connect(emit);
+        return (command) => {
+            wrapped.send(fn(command));
+        };
     });
 }
 export function eventTransformer(fn) {
-  return (wrapped) =>
-    actor((emit) => {
-      wrapped.connect((msg) => {
-        emit(fn(msg));
-      });
-      return (command) => wrapped.send(command);
+    return (wrapped) => actor((emit) => {
+        wrapped.connect((msg) => {
+            emit(fn(msg));
+        });
+        return (command) => wrapped.send(command);
     });
 }