alchemy 2.0.0-beta.43 → 2.0.0-beta.44

package/src/Local/RpcServerNode.ts

@@ -0,0 +1,58 @@
+import * as Effect from "effect/Effect";
+import { WebSocketServer, type Server } from "ws";
+import * as RpcServer from "./RpcServer.ts";
+
+export const RpcServerNode = RpcServer.layerServer(
+  Effect.fnUntraced(function* ({
+    parentConnected,
+    parentDisconnected,
+    createRpcSession,
+  }) {
+    const server = new WebSocketServer({ host: "127.0.0.1", port: 0 });
+    const url = yield* Effect.callback<string>((resume) => {
+      server.on("connection", (ws, req) => {
+        if (req.url?.startsWith("/parent")) {
+          parentConnected();
+          ws.on("close", () => {
+            parentDisconnected();
+          });
+          return;
+        }
+        const session = createRpcSession(ws);
+        ws.on("message", (data) => {
+          session.dispatch.message(data.toString());
+        });
+        ws.on("close", (code, reason) => {
+          session.dispatch.close(code, reason.toString());
+        });
+      });
+      server.on("error", (error) => {
+        resume(Effect.die(error));
+      });
+      server.on("listening", () => {
+        resume(getServerAddress(server));
+      });
+    });
+    yield* Effect.addFinalizer(() => Effect.sync(() => server.close()));
+    return { url };
+  }),
+);
+
+function getServerAddress(server: Server): Effect.Effect<string> {
+  const address = server.address();
+  if (
+    typeof address === "object" &&
+    address !== null &&
+    "address" in address &&
+    "port" in address
+  ) {
+    return Effect.succeed(
+      `ws://${address.address === "::" ? "localhost" : address.address}:${address.port}`,
+    );
+  }
+  return Effect.die(
+    new Error(
+      `Server address is not an object with address and port properties: ${JSON.stringify(address)}`,
+    ),
+  );
+}

package/src/Local/RpcServerSession.ts

@@ -0,0 +1,87 @@
+import { RpcSession, type RpcCompatible, type RpcTransport } from "capnweb";
+
+/**
+ * A platform-agnostic interface for a server-side WebSocket.
+ */
+export interface ServerWebSocketLike {
+  send: (message: string) => any | Promise<any>;
+  close: (code?: number, reason?: string) => void;
+}
+
+/**
+ * Represents a websocket RPC session with capnweb.
+ * Use the `dispatch` object to handle messages that are received from the client.
+ */
+export type ServerRpcSession<T extends RpcCompatible<T>> = ReturnType<
+  typeof makeServerRpcSession<T>
+>;
+
+/**
+ * Constructs a ServerRpcSession using capnweb.
+ * @param ws - The WebSocket to use for the session.
+ * @param main - The main object to use for the session.
+ * @returns A ServerRpcSession.
+ */
+export function makeServerRpcSession<T extends RpcCompatible<T>>(
+  ws: ServerWebSocketLike,
+  main: T,
+) {
+  const { transport, dispatch } = makeWebSocketRpcTransport(ws);
+  const session = new RpcSession(transport, main);
+  return { session, dispatch };
+}
+
+function makeWebSocketRpcTransport(ws: ServerWebSocketLike) {
+  let receiveQueue: Array<string> = [];
+  let receiveResolver: ((value: string) => void) | undefined;
+  let receiveRejecter: ((reason: unknown) => void) | undefined;
+  let error: unknown | undefined;
+  return {
+    transport: {
+      send: async (message: string) => await ws.send(message),
+      receive: async () => {
+        const next = receiveQueue.shift();
+        if (next) {
+          return next;
+        } else if (error) {
+          throw error;
+        }
+        return new Promise<string>((resolve, reject) => {
+          receiveResolver = resolve;
+          receiveRejecter = reject;
+        });
+      },
+      abort: (reason: unknown) => {
+        const message =
+          reason instanceof Error ? reason.message : String(reason);
+        ws.close(3000, message);
+        error ??= reason;
+      },
+    } satisfies RpcTransport,
+    dispatch: {
+      message: (data: string | Buffer<ArrayBuffer>) => {
+        if (error) {
+          return;
+        }
+        data = typeof data === "string" ? data : data.toString("utf-8");
+        if (receiveResolver) {
+          receiveResolver(data);
+          receiveResolver = undefined;
+          receiveRejecter = undefined;
+        } else {
+          receiveQueue.push(data);
+        }
+      },
+      close: (code: number, reason: string) => {
+        if (!error) {
+          error = new Error(`WebSocket closed with code ${code}: ${reason}`);
+          if (receiveRejecter) {
+            receiveRejecter(error);
+            receiveRejecter = undefined;
+            receiveResolver = undefined;
+          }
+        }
+      },
+    },
+  };
+}

package/src/Local/RpcSpawner.ts

@@ -0,0 +1,196 @@
+import { exitHook } from "@alchemy.run/node-utils/exit-hook";
+import * as Cache from "effect/Cache";
+import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { PlatformError } from "effect/PlatformError";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import * as HttpServer from "effect/unstable/http/HttpServer";
+import { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
+import * as NodeChildProcess from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { httpServer } from "../Util/PlatformServices.ts";
+import {
+  RPC_SERVER_ENVIRONMENT_KEY,
+  type RpcServerEnvironment,
+} from "./RpcServerEnvironment.ts";
+
+export class RpcSpawner extends Context.Service<
+  RpcSpawner,
+  {
+    readonly url: string;
+  }
+>()("alchemy/Local/RpcSpawner") {}
+
+export interface RpcSpawnPayload extends Pick<
+  RpcServerEnvironment,
+  "alchemyContext" | "stack"
+> {
+  serverEntryUrl: string;
+}
+
+export const make = Effect.fnUntraced(function* ({
+  profile,
+  envFile,
+}: Pick<RpcServerEnvironment, "profile" | "envFile">) {
+  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+  const scope = yield* Effect.scope;
+  const cache = yield* Cache.make({
+    lookup: (payload: RpcSpawnPayload) =>
+      spawn(payload).pipe(Scope.provide(scope)),
+    capacity: Infinity,
+  });
+
+  const spawn = Effect.fnUntraced(function* ({
+    serverEntryUrl,
+    alchemyContext,
+    stack,
+  }: RpcSpawnPayload) {
+    const bin = typeof globalThis.Bun !== "undefined" ? "bun" : "node";
+    const main = fileURLToPath(serverEntryUrl);
+    const environment: RpcServerEnvironment = {
+      profile,
+      envFile,
+      alchemyContext,
+      stack,
+    };
+    const command = ChildProcess.make(
+      bin,
+      {
+        bun: ["run", main],
+        // Under Node, transparently strip TypeScript types so that `.ts`
+        // entry points work the same way they do under Bun. Mirrors what
+        // `dev.ts` already does for the outer process, so the dev experience
+        // is symmetric on both runtimes whether the entry came from `src/`
+        // (dev/tests) or `lib/` (published packages).
+        node: main.endsWith(".ts")
+          ? [
+              "--experimental-transform-types",
+              "--no-warnings=ExperimentalWarning",
+              main,
+            ]
+          : [main],
+      }[bin],
+      {
+        stdout: "pipe",
+        stderr: "inherit",
+        detached: false,
+        env: {
+          [RPC_SERVER_ENVIRONMENT_KEY]: JSON.stringify(environment),
+        },
+        extendEnv: true,
+      },
+    );
+    const handle = yield* spawner.spawn(command);
+    const unregister = exitHook(() => {
+      killProcessGroup(handle.pid, "SIGKILL");
+    });
+    const kill = handle
+      .kill({ forceKillAfter: "500 millis" })
+      .pipe(Effect.tap(() => Effect.sync(unregister)));
+    yield* Effect.addFinalizer(() => kill.pipe(Effect.ignore));
+    const url = yield* getRpcAddress(handle.stdout);
+    const ws = yield* Effect.acquireRelease(
+      Effect.sync(() => new WebSocket(new URL("/parent", url))),
+      (ws) => Effect.sync(() => ws.close()),
+    );
+    return {
+      url,
+      isRunning: Effect.zipWith(
+        handle.isRunning,
+        Effect.sync(
+          () =>
+            ws.readyState === WebSocket.CONNECTING ||
+            ws.readyState === WebSocket.OPEN,
+        ),
+        (a, b) => a && b,
+        { concurrent: true },
+      ),
+      kill,
+    };
+  });
+
+  const register = Effect.fnUntraced(function* (
+    payload: RpcSpawnPayload,
+    attempt = 0,
+  ): Effect.fn.Return<string, PlatformError> {
+    const child = yield* Cache.get(cache, payload);
+    if (yield* child.isRunning) {
+      return child.url;
+    }
+    if (attempt > 3) {
+      return yield* Effect.die(
+        new Error(
+          `Failed to spawn RPC server for "${payload.serverEntryUrl}" after ${attempt} attempts.`,
+        ),
+      );
+    }
+    yield* child.kill;
+    yield* Cache.invalidate(cache, payload);
+    return yield* register(payload, attempt + 1);
+  });
+
+  const server = yield* HttpServer.HttpServer;
+
+  yield* server.serve(
+    Effect.gen(function* () {
+      const request = yield* HttpServerRequest;
+      const payload = (yield* request.json) as unknown as RpcSpawnPayload;
+      const url = yield* register(payload);
+      return HttpServerResponse.text(url);
+    }),
+  );
+
+  return RpcSpawner.of({
+    url: HttpServer.formatAddress(server.address),
+  });
+});
+
+export const layerServer = (
+  environment: Pick<RpcServerEnvironment, "profile" | "envFile">,
+) =>
+  Layer.effect(RpcSpawner, make(environment)).pipe(Layer.provide(httpServer()));
+
+const RPC_ADDRESS_REGEX =
+  /(<ALCHEMY_RPC_ADDRESS>)(.+)(<\/ALCHEMY_RPC_ADDRESS>)/;
+
+const getRpcAddress = (stdout: Stream.Stream<Uint8Array, PlatformError>) =>
+  Effect.gen(function* () {
+    const address = yield* Deferred.make<string>();
+    let done = false;
+    yield* stdout.pipe(
+      Stream.decodeText,
+      Stream.splitLines,
+      Stream.runForEach((line) => {
+        if (done) {
+          console.log(line);
+        } else {
+          const match = line.match(RPC_ADDRESS_REGEX);
+          if (match) {
+            done = true;
+            return Deferred.succeed(address, match[2]);
+          }
+        }
+        return Effect.void;
+      }),
+      Effect.forkScoped,
+    );
+    return yield* Deferred.await(address);
+  });
+
+const killProcessGroup = (pid: number, signal: NodeJS.Signals) => {
+  try {
+    if (process.platform === "win32") {
+      NodeChildProcess.execSync(`taskkill /pid ${pid} /T /F`);
+    } else {
+      process.kill(-pid, signal);
+    }
+  } catch {
+    // ignore errors during best-effort cleanup
+  }
+};

package/src/Util/PlatformServices.ts

@@ -12,6 +12,23 @@ import type { WebSocketConstructor } from "effect/unstable/socket/Socket";
 
 const isBun = typeof Bun !== "undefined";
 
+/**
+ * Constructs a layer with different implementations for Bun and Node.
+ */
+export const platformLayer = <A, E, R>(constructors: {
+  bun: () => Promise<Layer.Layer<A, E, R>>;
+  node: () => Promise<Layer.Layer<A, E, R>>;
+}) =>
+  Layer.unwrap(
+    Effect.promise(async () => {
+      if (isBun) {
+        return await constructors.bun();
+      } else {
+        return await constructors.node();
+      }
+    }),
+  );
+
 export type PlatformServices =
   | ChildProcessSpawner
   | FileSystem
@@ -21,29 +38,25 @@ export type PlatformServices =
   // WebSocketConstructor is not included in NodeServices/BunServices, but required for Workers tail
   | WebSocketConstructor;
 
-export const PlatformServices: Layer.Layer<PlatformServices> = Effect.promise(
-  async () => {
-    if (isBun) {
-      const [BunServices, BunSocket] = await Promise.all([
-        import("@effect/platform-bun/BunServices"),
-        import("@effect/platform-bun/BunSocket"),
-      ]);
-      return Layer.merge(
-        BunServices.layer,
-        BunSocket.layerWebSocketConstructor,
-      );
-    } else {
-      const [NodeServices, NodeSocket] = await Promise.all([
-        import("@effect/platform-node/NodeServices"),
-        import("@effect/platform-node/NodeSocket"),
-      ]);
-      return Layer.merge(
-        NodeServices.layer,
-        NodeSocket.layerWebSocketConstructor,
-      );
-    }
+export const PlatformServices: Layer.Layer<PlatformServices> = platformLayer({
+  bun: async () => {
+    const [BunServices, BunSocket] = await Promise.all([
+      import("@effect/platform-bun/BunServices"),
+      import("@effect/platform-bun/BunSocket"),
+    ]);
+    return Layer.merge(BunServices.layer, BunSocket.layerWebSocketConstructor);
+  },
+  node: async () => {
+    const [NodeServices, NodeSocket] = await Promise.all([
+      import("@effect/platform-node/NodeServices"),
+      import("@effect/platform-node/NodeSocket"),
+    ]);
+    return Layer.merge(
+      NodeServices.layer,
+      NodeSocket.layerWebSocketConstructor,
+    );
   },
-).pipe(Layer.unwrap);
+});
 
 export const runMain = <E, A>(
   effect: Effect.Effect<A, E>,
@@ -67,15 +80,16 @@ export const httpServer = (
   port: number = 0,
   host: string = "127.0.0.1",
 ): Layer.Layer<HttpServer, ServeError> =>
-  Effect.promise(async () => {
-    if (isBun) {
+  platformLayer({
+    bun: async () => {
       const BunHttpServer = await import("@effect/platform-bun/BunHttpServer");
       return BunHttpServer.layer({ hostname: host, port });
-    } else {
+    },
+    node: async () => {
       const [NodeHttpServer, Http] = await Promise.all([
         import("@effect/platform-node/NodeHttpServer"),
         import("node:http"),
       ]);
       return NodeHttpServer.layerServer(Http.createServer, { host, port });
-    }
-  }).pipe(Layer.unwrap);
+    },
+  });

package/src/Util/camel.ts

@@ -1,3 +1,5 @@
+import { isPlainObject } from "./data.ts";
+
 export const camelCaseKey = (key: string) =>
   key
     .replace(/^_+/, "")
@@ -7,11 +9,7 @@ export const toCamelCase = <T>(value: unknown): T => {
   if (Array.isArray(value)) {
     return value.map((item) => toCamelCase(item)) as T;
   }
-  if (
-    value &&
-    typeof value === "object" &&
-    Object.getPrototypeOf(value) === Object.prototype
-  ) {
+  if (isPlainObject(value)) {
     return Object.fromEntries(
       Object.entries(value).map(([key, nested]) => [
         camelCaseKey(key),

package/src/Util/data.ts

@@ -1,3 +1,7 @@
+import * as Predicate from "effect/Predicate";
+import * as EffectRecord from "effect/Record";
+import * as Redacted from "effect/Redacted";
+
 export type Primitive =
   | never
   | undefined
@@ -16,3 +20,37 @@ export const isPrimitive = (value: any): value is Primitive =>
   typeof value === "string" ||
   typeof value === "symbol" ||
   typeof value === "bigint";
+
+export const isPlainObject = (
+  value: unknown,
+): value is Record<string, unknown> => {
+  if (!Predicate.isObject(value)) return false;
+  return Object.getPrototypeOf(value) === Object.prototype;
+};
+
+export const stripFields = <T>(value: T, empty: null | undefined): T => {
+  if (Array.isArray(value)) {
+    return value.map((item) => stripFields(item, empty)) as T;
+  }
+  if (!isPlainObject(value)) return value;
+  return EffectRecord.map(
+    EffectRecord.filter(value, (entry) => entry !== empty),
+    (entry) => stripFields(entry, empty),
+  ) as T;
+};
+
+export const stripNullFields = <T>(value: T): T => stripFields(value, null);
+
+export const stripUndefinedFields = <T>(value: T): T =>
+  stripFields(value, undefined);
+
+export const unwrapRedacted = <T>(value: T): T => {
+  if (Redacted.isRedacted(value)) {
+    return Redacted.value(value) as T;
+  }
+  if (Array.isArray(value)) {
+    return value.map(unwrapRedacted) as T;
+  }
+  if (!isPlainObject(value)) return value;
+  return EffectRecord.map(value, unwrapRedacted) as T;
+};

package/src/Util/stable.ts

@@ -1,3 +1,5 @@
+import { isPlainObject } from "./data.ts";
+
 export const normalizeNulls = <T>(value: T): T => {
   if (value === null) {
     return undefined as T;
@@ -5,11 +7,7 @@ export const normalizeNulls = <T>(value: T): T => {
   if (Array.isArray(value)) {
     return value.map((item) => normalizeNulls(item)) as T;
   }
-  if (
-    value &&
-    typeof value === "object" &&
-    Object.getPrototypeOf(value) === Object.prototype
-  ) {
+  if (isPlainObject(value)) {
     return Object.fromEntries(
       Object.entries(value)
         .map(([key, nested]) => [key, normalizeNulls(nested)])
@@ -23,11 +21,7 @@ export const stableValue = (value: unknown): unknown => {
   if (Array.isArray(value)) {
     return value.map(stableValue);
   }
-  if (
-    value &&
-    typeof value === "object" &&
-    Object.getPrototypeOf(value) === Object.prototype
-  ) {
+  if (isPlainObject(value)) {
     return Object.fromEntries(
       Object.entries(value)
         .sort(([a], [b]) => a.localeCompare(b))

package/lib/Cloudflare/Local/Sidecar.d.ts

@@ -1,63 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { BundleError } from "../../Bundle/Bundle.ts";
-import type { ResourceBinding } from "../../Resource.ts";
-import type { Worker, WorkerProps } from "../Workers/Worker.ts";
-export interface ReconcileOptions {
-    id: string;
-    props: WorkerProps;
-    bindings: ResourceBinding<Worker["Binding"]>[];
-    stack: {
-        name: string;
-        stage: string;
-    };
-    instanceId: string;
-}
-declare const ValidationError_base: Schema.Class<ValidationError, Schema.TaggedStruct<"ValidationError", {
-    readonly message: Schema.String;
-    readonly hint: Schema.optional<Schema.String>;
-    readonly value: Schema.Unknown;
-}>, import("effect/Cause").YieldableError>;
-export declare class ValidationError extends ValidationError_base {
-}
-export declare const ServeResult: Schema.Struct<{
-    readonly workerId: Schema.String;
-    readonly workerName: Schema.String;
-    readonly logpush: Schema.UndefinedOr<Schema.Boolean>;
-    readonly url: Schema.String;
-    readonly tags: Schema.mutable<Schema.$Array<Schema.String>>;
-    readonly durableObjectNamespaces: Schema.$Record<Schema.String, Schema.String>;
-    readonly domains: Schema.mutable<Schema.$Array<Schema.Struct<{
-        readonly hostname: Schema.String;
-        readonly id: Schema.String;
-        readonly zoneId: Schema.String;
-    }>>>;
-    readonly crons: Schema.mutable<Schema.$Array<Schema.String>>;
-    readonly accountId: Schema.String;
-}>;
-export type ServeResult = typeof ServeResult.Type;
-export declare const ServeError: Schema.Union<readonly [Schema.Union<readonly [typeof import("@distilled.cloud/cloudflare-runtime").ConfigError, typeof import("@distilled.cloud/cloudflare-runtime").SystemError, typeof import("@distilled.cloud/cloudflare-runtime").ApiError]>, typeof BundleError, typeof ValidationError]>;
-export type ServeError = typeof ServeError.Type;
-export declare const DiffResult: Schema.Struct<{
-    readonly action: Schema.Literals<readonly ["update", "noop"]>;
-}>;
-export type DiffResult = typeof DiffResult.Type;
-export declare const SidecarSchema: import("../../Sidecar/RpcHandler.ts").RpcHandlerEncoders<{
-    readonly diff: (options: ReconcileOptions) => Effect.Effect<DiffResult>;
-    readonly reconcile: (options: ReconcileOptions) => Effect.Effect<ServeResult, ServeError>;
-    readonly delete: (id: string) => Effect.Effect<void>;
-}> & import("../../Sidecar/RpcHandler.ts").RpcHandlerDecoders<{
-    readonly diff: (options: ReconcileOptions) => Effect.Effect<DiffResult>;
-    readonly reconcile: (options: ReconcileOptions) => Effect.Effect<ServeResult, ServeError>;
-    readonly delete: (id: string) => Effect.Effect<void>;
-}>;
-declare const Sidecar_base: import("effect/Context").ServiceClass<Sidecar, "Sidecar", {
-    readonly diff: (options: ReconcileOptions) => Effect.Effect<DiffResult>;
-    readonly reconcile: (options: ReconcileOptions) => Effect.Effect<ServeResult, ServeError>;
-    readonly delete: (id: string) => Effect.Effect<void>;
-}>;
-export declare class Sidecar extends Sidecar_base {
-}
-export declare const SidecarLive: import("effect/Layer").Layer<Sidecar, never, import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("../../AlchemyContext.ts").AlchemyContext>;
-export {};
-//# sourceMappingURL=Sidecar.d.ts.map

package/lib/Cloudflare/Local/Sidecar.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Sidecar.d.ts","sourceRoot":"","sources":["../../../src/Cloudflare/Local/Sidecar.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGzD,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEhE,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,eAAe,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC;IAC/C,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACvC,UAAU,EAAE,MAAM,CAAC;CACpB;;;;;;AAED,qBAAa,eAAgB,SAAQ,oBAOpC;CAAG;AAEJ,eAAO,MAAM,WAAW;;;;;;;;;;;;;;EAgBtB,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAC;AAElD,eAAO,MAAM,UAAU,iSAIrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAC;AAEhD,eAAO,MAAM,UAAU;;EAErB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAC;AAEhD,eAAO,MAAM,aAAa;mBAYP,CAAC,OAAO,EAAE,gBAAgB,KAAK,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;wBACnD,CAClB,OAAO,EAAE,gBAAgB,KACtB,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,UAAU,CAAC;qBAC1B,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;;mBAJrC,CAAC,OAAO,EAAE,gBAAgB,KAAK,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;wBACnD,CAClB,OAAO,EAAE,gBAAgB,KACtB,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,UAAU,CAAC;qBAC1B,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;EATtD,CAAC;;mBAKgB,CAAC,OAAO,EAAE,gBAAgB,KAAK,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;wBACnD,CAClB,OAAO,EAAE,gBAAgB,KACtB,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,UAAU,CAAC;qBAC1B,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;;AAPxD,qBAAa,OAAQ,SAAQ,YASf;CAAG;AAEjB,eAAO,MAAM,WAAW,kPAGtB,CAAC"}

package/lib/Cloudflare/Local/Sidecar.js

@@ -1,50 +0,0 @@
-import { RuntimeError } from "@distilled.cloud/cloudflare-runtime/RuntimeError";
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { BundleError } from "../../Bundle/Bundle.js";
-import * as RpcClient from "../../Sidecar/RpcClient.js";
-import { defineSchema } from "../../Sidecar/RpcHandler.js";
-export class ValidationError extends Schema.TaggedErrorClass()("ValidationError", {
-    message: Schema.String,
-    hint: Schema.optional(Schema.String),
-    value: Schema.Unknown,
-}) {
-}
-export const ServeResult = Schema.Struct({
-    workerId: Schema.String,
-    workerName: Schema.String,
-    logpush: Schema.UndefinedOr(Schema.Boolean),
-    url: Schema.String,
-    tags: Schema.Array(Schema.String).pipe(Schema.mutable),
-    durableObjectNamespaces: Schema.Record(Schema.String, Schema.String),
-    domains: Schema.Array(Schema.Struct({
-        hostname: Schema.String,
-        id: Schema.String,
-        zoneId: Schema.String,
-    })).pipe(Schema.mutable),
-    crons: Schema.Array(Schema.String).pipe(Schema.mutable),
-    accountId: Schema.String,
-});
-export const ServeError = Schema.Union([
-    RuntimeError,
-    BundleError,
-    ValidationError,
-]);
-export const DiffResult = Schema.Struct({
-    action: Schema.Literals(["update", "noop"]),
-});
-export const SidecarSchema = defineSchema({
-    diff: { success: DiffResult, error: Schema.Never },
-    reconcile: {
-        success: ServeResult,
-        error: ServeError,
-    },
-    delete: { success: Schema.Void, error: Schema.Never },
-});
-export class Sidecar extends RpcClient.RpcClientService()("Sidecar") {
-}
-export const SidecarLive = RpcClient.layer(Sidecar, {
-    main: import.meta.resolve("./SidecarServer.ts", import.meta.url),
-    schema: SidecarSchema,
-});
-//# sourceMappingURL=Sidecar.js.map

package/lib/Cloudflare/Local/Sidecar.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Sidecar.js","sourceRoot":"","sources":["../../../src/Cloudflare/Local/Sidecar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,kDAAkD,CAAC;AAChF,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,OAAO,KAAK,SAAS,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAW3D,MAAM,OAAO,eAAgB,SAAQ,MAAM,CAAC,gBAAgB,EAAmB,CAC7E,iBAAiB,EACjB;IACE,OAAO,EAAE,MAAM,CAAC,MAAM;IACtB,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC,OAAO;CACtB,CACF;CAAG;AAEJ,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC;IACvC,QAAQ,EAAE,MAAM,CAAC,MAAM;IACvB,UAAU,EAAE,MAAM,CAAC,MAAM;IACzB,OAAO,EAAE,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC;IAC3C,GAAG,EAAE,MAAM,CAAC,MAAM;IAClB,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;IACtD,uBAAuB,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC;IACpE,OAAO,EAAE,MAAM,CAAC,KAAK,CACnB,MAAM,CAAC,MAAM,CAAC;QACZ,QAAQ,EAAE,MAAM,CAAC,MAAM;QACvB,EAAE,EAAE,MAAM,CAAC,MAAM;QACjB,MAAM,EAAE,MAAM,CAAC,MAAM;KACtB,CAAC,CACH,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;IACvD,SAAS,EAAE,MAAM,CAAC,MAAM;CACzB,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC;IACrC,YAAY;IACZ,WAAW;IACX,eAAe;CAChB,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;CAC5C,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,aAAa,GAAG,YAAY,CAAqB;IAC5D,IAAI,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE;IAClD,SAAS,EAAE;QACT,OAAO,EAAE,WAAW;QACpB,KAAK,EAAE,UAAU;KAClB;IACD,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE;CACtD,CAAC,CAAC;AAEH,MAAM,OAAO,OAAQ,SAAQ,SAAS,CAAC,gBAAgB,EASpD,CAAC,SAAS,CAAC;CAAG;AAEjB,MAAM,CAAC,MAAM,WAAW,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE;IAClD,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC;IAChE,MAAM,EAAE,aAAa;CACtB,CAAC,CAAC"}

package/lib/Cloudflare/Local/SidecarHandlers.d.ts

@@ -1,8 +0,0 @@
-import { type RuntimeServices } from "@distilled.cloud/cloudflare-runtime";
-import * as LocalProxy from "@distilled.cloud/cloudflare-runtime/proxy/LocalProxy";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
-import { Sidecar } from "./Sidecar.ts";
-export declare const SidecarHandlers: Layer.Layer<Sidecar, never, import("effect/FileSystem").FileSystem | Path.Path | CloudflareEnvironment | LocalProxy.LocalProxy | RuntimeServices>;
-//# sourceMappingURL=SidecarHandlers.d.ts.map

package/lib/Cloudflare/Local/SidecarHandlers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SidecarHandlers.d.ts","sourceRoot":"","sources":["../../../src/Cloudflare/Local/SidecarHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,eAAe,EACrB,MAAM,qCAAqC,CAAC;AAmB7C,OAAO,KAAK,UAAU,MAAM,sDAAsD,CAAC;AAMnF,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AASpC,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAWpE,OAAO,EAGL,OAAO,EAGR,MAAM,cAAc,CAAC;AAEtB,eAAO,MAAM,eAAe,mJAwS3B,CAAC"}