devsess 0.0.0 → 0.1.0

package/README.md

@@ -0,0 +1,109 @@
+# devsess
+
+Scaffold dev scripts with reusable **dev sessions** and a per-session **PGlite + Drizzle** adapter — built on [Effect](https://effect.website).
+
+`devsess` gives your local `scripts/dev.ts` two things:
+
+- **Dev sessions** — each run reuses (or creates) a named, slug-based working directory under `.data/sessions`. Sticky dev-server ports, managed subprocesses that die with your script, and cross-service "running" signal files come built in.
+- **A PGlite adapter** (`devsess/pglite`) — prepare a local Postgres-compatible database from your Drizzle migrations, scoped to the current dev session. Perfect for a `--lite` offline dev mode.
+
+It targets **Node** (`@effect/platform-node`). The examples below use the [Effect](https://effect.website) API (`devsess`); if you'd rather not deal with Effect directly, `devsess/async` exposes the same dev-session scaffolding as a plain, Promise-based API — see [API](#api).
+
+## Install
+
+```bash
+bun add devsess effect @effect/platform-node
+```
+
+For the PGlite adapter (`devsess/pglite`), also add:
+
+```bash
+bun add @electric-sql/pglite drizzle-orm
+```
+
+## Quickstart
+
+```ts
+// scripts/dev.ts
+import { join } from 'node:path';
+import { cli, defineDevCli } from 'devsess';
+import { Effect } from 'effect';
+
+const main = defineDevCli({
+	name: 'web',
+	dir: join(import.meta.dirname, '..'),
+	options: {
+		lite: cli.Flag.boolean('lite').pipe(
+			cli.Flag.withDescription('Use a per-session PGlite database'),
+		),
+	},
+	run: (ctx, opts) =>
+		Effect.gen(function* () {
+			const session = yield* ctx.session;
+			yield* Effect.logInfo(`[dev] session: ${session.name}`);
+
+			const port = yield* ctx.getStickyPort();
+			const env: Record<string, string> = { PORT: String(port) };
+
+			if (opts.lite) {
+				const litePath = yield* session.path('pglite');
+				env.DATABASE_LITE = 'true';
+				env.DATABASE_LITE_PATH = litePath;
+			}
+
+			yield* ctx.runManagedSubprocess('bunx', ['vite'], { env });
+		}),
+});
+
+main(process.argv);
+```
+
+```bash
+bun scripts/dev.ts --lite
+```
+
+## Per-session PGlite
+
+`prepareSessionPglite` builds a migration dump (if missing), hydrates a PGlite
+client, validates and applies migrations — all scoped to the active dev session:
+
+```ts
+import { prepareSessionPglite } from 'devsess/pglite';
+
+// inside run():
+const session = yield* ctx.session;
+const db = yield* prepareSessionPglite(session, {
+	migrationsFolder: join(import.meta.dirname, '../drizzle'),
+});
+// db.client — a ready PGlite client
+// db.dataDir — its on-disk path (e.g. pass as DATABASE_LITE_PATH)
+```
+
+## API
+
+From `devsess` (the Effect API):
+
+- `defineDevCli({ name, dir, options?, run })` → `(argv) => void`
+- `cli` — re-export of `effect/unstable/cli`
+- `DevSessions`, `makeDevSessionsLayer(rootDir)`, `DevSession`
+- `SessionState.slot(schema)` — typed per-session JSON state
+
+From `devsess/pglite`:
+
+- `prepareSessionPglite(session, { migrationsFolder })`
+- `openLitePglite({ dataDir, dumpPath, migrationsFolder })`
+- `buildPgliteDump`, `ensurePgliteDump`, `migratePglite`,
+  `dumpPgliteToFile`, `createPgliteFromDump`, `getDbMigrationCount`,
+  `getExpectedMigrationCount`, and the `PgliteError` tagged error.
+
+From `devsess/async` (a plain, Promise-based mirror of the Effect API — no `effect` imports required):
+
+- `defineDevCli({ name, dir, options?, run })` — `run` is `async (ctx, opts) => void`, and `ctx`'s helpers return Promises instead of Effects
+- `createDevSessions(rootDir)` — async session manager (`getSessions`, `createSession`, `getLatestOrCreate`)
+- `SessionState`, `DevSession`, plus `cli` and `Schema` re-exports
+
+See the [full documentation](https://github.com/fdarian/devsess/tree/main/apps/docs) for details.
+
+## License
+
+Apache-2.0

package/dist/async/define-cli.d.ts

@@ -0,0 +1,20 @@
+import { Effect } from 'effect';
+import { type CommandConfig } from '../dev/run-dev-cli';
+import { runManagedSubprocess } from '../dev/subprocess';
+import { type DevSession } from './session';
+/** Promise-returning mirror of the Effect core's `RunContext` (see `src/dev/define-cli.ts`). */
+type AsyncRunContext = {
+    session: () => Promise<DevSession>;
+    getStickyPort: () => Promise<number>;
+    runManagedSubprocess: (...args: Parameters<typeof runManagedSubprocess>) => Promise<Effect.Success<ReturnType<typeof runManagedSubprocess>>>;
+    publishRunning: (data: unknown) => Promise<void>;
+    awaitRunning: <T>(pkg: string) => Promise<T>;
+};
+export declare const defineDevCli: (config: {
+    name: string;
+    dir: string;
+    options?: CommandConfig;
+    run: (ctx: AsyncRunContext, opts: Record<string, unknown>) => Promise<void> | void;
+}) => ((argv: string[]) => void);
+export {};
+//# sourceMappingURL=define-cli.d.ts.map

package/dist/async/define-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-cli.d.ts","sourceRoot":"","sources":["../../src/async/define-cli.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAc,MAAM,QAAQ,CAAC;AAI5C,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,oBAAoB,CAAC;AAQnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,KAAK,UAAU,EAAkB,MAAM,WAAW,CAAC;AAE5D,gGAAgG;AAChG,KAAK,eAAe,GAAG;IACtB,OAAO,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC;IACnC,aAAa,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACrC,oBAAoB,EAAE,CACrB,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,KAC5C,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC;IACtE,cAAc,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,YAAY,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;CAC7C,CAAC;AAEF,eAAO,MAAM,YAAY,WAAY;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,GAAG,EAAE,CACJ,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACzB,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC1B,KAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,IAAI,CA4C1B,CAAC"}

package/dist/async/dev-sessions.d.ts

@@ -0,0 +1,16 @@
+import { type DevSession } from './session';
+export type DevSessionManager = {
+    readonly dir: string;
+    getSessions(): Promise<Array<DevSession>>;
+    createSession(): Promise<DevSession>;
+    getLatestOrCreate(): Promise<DevSession>;
+};
+/**
+ * Creates a manager for slug-named dev session directories under `rootDir`.
+ *
+ * `makeDevSessionsLayer` only wires lazy service methods when built (no directory
+ * IO happens at build time — see `src/dev-sessions.ts`), so it's cheap to re-provide
+ * the same `layer` value on every call rather than resolving a shared runtime once.
+ */
+export declare const createDevSessions: (rootDir: string) => DevSessionManager;
+//# sourceMappingURL=dev-sessions.d.ts.map

package/dist/async/dev-sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-sessions.d.ts","sourceRoot":"","sources":["../../src/async/dev-sessions.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,UAAU,EAAkB,MAAM,WAAW,CAAC;AAE5D,MAAM,MAAM,iBAAiB,GAAG;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,WAAW,IAAI,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;IAC1C,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IACrC,iBAAiB,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;CACzC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,YAAa,MAAM,KAAG,iBAwBnD,CAAC"}

package/dist/async/index.d.ts

@@ -0,0 +1,8 @@
+export { Schema } from 'effect';
+export * as cli from 'effect/unstable/cli';
+export { SessionStateError } from '../dev/session-state';
+export { defineDevCli } from './define-cli';
+export { createDevSessions, type DevSessionManager } from './dev-sessions';
+export type { DevSession } from './session';
+export { SessionState } from './session-state';
+//# sourceMappingURL=index.d.ts.map

package/dist/async/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/async/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,GAAG,MAAM,qBAAqB,CAAC;AAE3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC3E,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/async/index.js

@@ -0,0 +1,127 @@
+import {
+  DevSessions,
+  SessionState,
+  SessionStateError,
+  awaitRunningSignal,
+  getStickyPort,
+  makeDevSessionsLayer,
+  publishRunningSignal,
+  resolveSiblingDir,
+  runDevCli,
+  runManagedSubprocess,
+  runningSignalPath
+} from "../chunk-IEQZ3AJH.js";
+
+// src/async/index.ts
+import { Schema } from "effect";
+import * as cli from "effect/unstable/cli";
+
+// src/async/define-cli.ts
+import { Effect as Effect2 } from "effect";
+
+// src/async/session.ts
+import { Effect } from "effect";
+var EFFECT_SESSION = /* @__PURE__ */ Symbol("devsess/async/DevSession#effectSession");
+var toAsyncSession = (session) => {
+  const asyncSession = {
+    name: session.name,
+    lastModifiedAt: session.lastModifiedAt,
+    // Safe to run synchronously: the core `path` is `Effect.succeed(pathJoin(rel))`, pure.
+    path: (relativePath) => Effect.runSync(session.path(relativePath)),
+    toString: () => session.toString()
+  };
+  Object.defineProperty(asyncSession, EFFECT_SESSION, {
+    value: session,
+    enumerable: false
+  });
+  return asyncSession;
+};
+var unwrapSession = (session) => {
+  const effectSession = session[EFFECT_SESSION];
+  if (effectSession === void 0) {
+    throw new Error(
+      "devsess/async: expected a DevSession created by this package, but the internal Effect session handle is missing"
+    );
+  }
+  return effectSession;
+};
+
+// src/async/define-cli.ts
+var defineDevCli = (config) => runDevCli({
+  name: config.name,
+  dir: config.dir,
+  options: config.options,
+  makeHandler: (opts) => Effect2.gen(function* () {
+    const sessions = yield* DevSessions;
+    const session = yield* Effect2.cached(sessions.getLatestOrCreate);
+    const services = yield* Effect2.context();
+    const ctx = {
+      session: () => Effect2.runPromiseWith(services)(session).then(toAsyncSession),
+      getStickyPort: () => Effect2.runPromiseWith(services)(
+        Effect2.flatMap(session, getStickyPort)
+      ),
+      runManagedSubprocess: (...args) => Effect2.runPromiseWith(services)(runManagedSubprocess(...args)),
+      publishRunning: (data) => Effect2.runPromiseWith(services)(
+        publishRunningSignal(runningSignalPath(config.dir), data)
+      ),
+      awaitRunning: (pkg) => Effect2.runPromiseWith(services)(
+        awaitRunningSignal(
+          runningSignalPath(resolveSiblingDir(pkg, config.dir)),
+          { parse: (raw) => JSON.parse(raw) }
+        )
+      )
+    };
+    yield* Effect2.promise(() => Promise.resolve(config.run(ctx, opts)));
+  })
+});
+
+// src/async/dev-sessions.ts
+import { NodeServices } from "@effect/platform-node";
+import { Effect as Effect3, Layer } from "effect";
+var createDevSessions = (rootDir) => {
+  const layer = makeDevSessionsLayer(rootDir).pipe(
+    Layer.provide(NodeServices.layer)
+  );
+  const run = (effect) => Effect3.runPromise(Effect3.provide(effect, layer));
+  return {
+    // Matches the service's own `dir`, which is `rootDir` verbatim — safe to read synchronously.
+    dir: rootDir,
+    getSessions: () => run(DevSessions.use((sessions) => sessions.getSessions)).then(
+      (sessions) => sessions.map(toAsyncSession)
+    ),
+    createSession: () => run(DevSessions.use((sessions) => sessions.createSession)).then(
+      toAsyncSession
+    ),
+    getLatestOrCreate: () => run(DevSessions.use((sessions) => sessions.getLatestOrCreate)).then(
+      toAsyncSession
+    )
+  };
+};
+
+// src/async/run.ts
+import { NodeServices as NodeServices2 } from "@effect/platform-node";
+import { Effect as Effect4 } from "effect";
+var nodeLayer = NodeServices2.layer;
+var runNode = (effect) => Effect4.runPromise(Effect4.scoped(Effect4.provide(effect, nodeLayer)));
+
+// src/async/session-state.ts
+var SessionState2;
+((SessionState3) => {
+  function slot(schema) {
+    const effectSlot = SessionState.slot(schema);
+    return {
+      read: (session) => runNode(effectSlot.read(unwrapSession(session))),
+      write: (session, data) => runNode(effectSlot.write(unwrapSession(session), data))
+    };
+  }
+  SessionState3.slot = slot;
+})(SessionState2 || (SessionState2 = {}));
+export {
+  Schema,
+  SessionState2 as SessionState,
+  SessionStateError,
+  cli,
+  createDevSessions,
+  defineDevCli
+};
+//# sourceMappingURL=index.js.map

package/dist/async/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/async/index.ts","../../src/async/define-cli.ts","../../src/async/session.ts","../../src/async/dev-sessions.ts","../../src/async/run.ts","../../src/async/session-state.ts"],"sourcesContent":["// Re-exported so consumers can declare CLI flags/arguments without a direct\n// dependency on `effect/unstable/cli`, e.g. `cli.Flag.string('local')`.\n\nexport { Schema } from 'effect';\nexport * as cli from 'effect/unstable/cli';\n\nexport { SessionStateError } from '../dev/session-state';\nexport { defineDevCli } from './define-cli';\nexport { createDevSessions, type DevSessionManager } from './dev-sessions';\nexport type { DevSession } from './session';\nexport { SessionState } from './session-state';\n","import { Effect, type Scope } from 'effect';\nimport type { FileSystem } from 'effect/FileSystem';\nimport type { Path } from 'effect/Path';\nimport type { ChildProcessSpawner } from 'effect/unstable/process/ChildProcessSpawner';\nimport { type CommandConfig, runDevCli } from '../dev/run-dev-cli';\nimport {\n\tawaitRunningSignal,\n\tpublishRunningSignal,\n\tresolveSiblingDir,\n\trunningSignalPath,\n} from '../dev/running-signal';\nimport { getStickyPort } from '../dev/sticky-port';\nimport { runManagedSubprocess } from '../dev/subprocess';\nimport { DevSessions } from '../dev-sessions';\nimport { type DevSession, toAsyncSession } from './session';\n\n/** Promise-returning mirror of the Effect core's `RunContext` (see `src/dev/define-cli.ts`). */\ntype AsyncRunContext = {\n\tsession: () => Promise<DevSession>;\n\tgetStickyPort: () => Promise<number>;\n\trunManagedSubprocess: (\n\t\t...args: Parameters<typeof runManagedSubprocess>\n\t) => Promise<Effect.Success<ReturnType<typeof runManagedSubprocess>>>;\n\tpublishRunning: (data: unknown) => Promise<void>;\n\tawaitRunning: <T>(pkg: string) => Promise<T>;\n};\n\nexport const defineDevCli = (config: {\n\tname: string;\n\tdir: string;\n\toptions?: CommandConfig;\n\trun: (\n\t\tctx: AsyncRunContext,\n\t\topts: Record<string, unknown>,\n\t) => Promise<void> | void;\n}): ((argv: string[]) => void) =>\n\trunDevCli({\n\t\tname: config.name,\n\t\tdir: config.dir,\n\t\toptions: config.options,\n\t\tmakeHandler: (opts) =>\n\t\t\tEffect.gen(function* () {\n\t\t\t\tconst sessions = yield* DevSessions;\n\t\t\t\tconst session = yield* Effect.cached(sessions.getLatestOrCreate);\n\n\t\t\t\t// Capture the process-lifetime context (the Scope opened by `runDevCli`'s\n\t\t\t\t// outer `Effect.scoped`, plus DevSessions | FileSystem | Path | ChildProcessSpawner).\n\t\t\t\t// Running each ctx helper with this captured context — instead of a fresh,\n\t\t\t\t// transient `Effect.runPromise` per call — attaches its scoped resources\n\t\t\t\t// (managed subprocess, running-signal file) to that process-lifetime scope,\n\t\t\t\t// so they only release when the CLI process ends, not right after the Promise settles.\n\t\t\t\tconst services = yield* Effect.context<\n\t\t\t\t\tDevSessions | FileSystem | Path | ChildProcessSpawner | Scope.Scope\n\t\t\t\t>();\n\n\t\t\t\tconst ctx: AsyncRunContext = {\n\t\t\t\t\tsession: () =>\n\t\t\t\t\t\tEffect.runPromiseWith(services)(session).then(toAsyncSession),\n\t\t\t\t\tgetStickyPort: () =>\n\t\t\t\t\t\tEffect.runPromiseWith(services)(\n\t\t\t\t\t\t\tEffect.flatMap(session, getStickyPort),\n\t\t\t\t\t\t),\n\t\t\t\t\trunManagedSubprocess: (...args) =>\n\t\t\t\t\t\tEffect.runPromiseWith(services)(runManagedSubprocess(...args)),\n\t\t\t\t\tpublishRunning: (data) =>\n\t\t\t\t\t\tEffect.runPromiseWith(services)(\n\t\t\t\t\t\t\tpublishRunningSignal(runningSignalPath(config.dir), data),\n\t\t\t\t\t\t),\n\t\t\t\t\tawaitRunning: <T>(pkg: string) =>\n\t\t\t\t\t\tEffect.runPromiseWith(services)(\n\t\t\t\t\t\t\tawaitRunningSignal<T>(\n\t\t\t\t\t\t\t\trunningSignalPath(resolveSiblingDir(pkg, config.dir)),\n\t\t\t\t\t\t\t\t{ parse: (raw) => JSON.parse(raw) as T },\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t),\n\t\t\t\t};\n\n\t\t\t\tyield* Effect.promise(() => Promise.resolve(config.run(ctx, opts)));\n\t\t\t}),\n\t});\n","import { Effect } from 'effect';\nimport type { DevSession as EffectDevSession } from '../dev-sessions';\n\n/** Non-enumerable, module-private key used to stash the Effect session on its async wrapper. */\nconst EFFECT_SESSION = Symbol('devsess/async/DevSession#effectSession');\n\nexport type DevSession = {\n\treadonly name: string;\n\treadonly lastModifiedAt: Date | null;\n\tpath(relativePath: string): string;\n\ttoString(): string;\n};\n\n/**\n * Wraps an Effect `DevSession` as a plain-async `DevSession`. The original Effect\n * session is stashed under `EFFECT_SESSION` so other async ops (e.g. `SessionState`)\n * can reuse the Effect core via `unwrapSession`.\n */\nexport const toAsyncSession = (session: EffectDevSession): DevSession => {\n\tconst asyncSession: DevSession = {\n\t\tname: session.name,\n\t\tlastModifiedAt: session.lastModifiedAt,\n\t\t// Safe to run synchronously: the core `path` is `Effect.succeed(pathJoin(rel))`, pure.\n\t\tpath: (relativePath) => Effect.runSync(session.path(relativePath)),\n\t\ttoString: () => session.toString(),\n\t};\n\n\tObject.defineProperty(asyncSession, EFFECT_SESSION, {\n\t\tvalue: session,\n\t\tenumerable: false,\n\t});\n\n\treturn asyncSession;\n};\n\n/** Recovers the Effect `DevSession` stashed by `toAsyncSession`. */\nexport const unwrapSession = (session: DevSession): EffectDevSession => {\n\tconst effectSession = (\n\t\tsession as unknown as Record<\n\t\t\ttypeof EFFECT_SESSION,\n\t\t\tEffectDevSession | undefined\n\t\t>\n\t)[EFFECT_SESSION];\n\tif (effectSession === undefined) {\n\t\tthrow new Error(\n\t\t\t'devsess/async: expected a DevSession created by this package, but the internal Effect session handle is missing',\n\t\t);\n\t}\n\treturn effectSession;\n};\n","import { NodeServices } from '@effect/platform-node';\nimport { Effect, Layer } from 'effect';\nimport { DevSessions, makeDevSessionsLayer } from '../dev-sessions';\nimport { type DevSession, toAsyncSession } from './session';\n\nexport type DevSessionManager = {\n\treadonly dir: string;\n\tgetSessions(): Promise<Array<DevSession>>;\n\tcreateSession(): Promise<DevSession>;\n\tgetLatestOrCreate(): Promise<DevSession>;\n};\n\n/**\n * Creates a manager for slug-named dev session directories under `rootDir`.\n *\n * `makeDevSessionsLayer` only wires lazy service methods when built (no directory\n * IO happens at build time — see `src/dev-sessions.ts`), so it's cheap to re-provide\n * the same `layer` value on every call rather than resolving a shared runtime once.\n */\nexport const createDevSessions = (rootDir: string): DevSessionManager => {\n\tconst layer = makeDevSessionsLayer(rootDir).pipe(\n\t\tLayer.provide(NodeServices.layer),\n\t);\n\n\tconst run = <A, E>(effect: Effect.Effect<A, E, DevSessions>): Promise<A> =>\n\t\tEffect.runPromise(Effect.provide(effect, layer));\n\n\treturn {\n\t\t// Matches the service's own `dir`, which is `rootDir` verbatim — safe to read synchronously.\n\t\tdir: rootDir,\n\t\tgetSessions: () =>\n\t\t\trun(DevSessions.use((sessions) => sessions.getSessions)).then(\n\t\t\t\t(sessions) => sessions.map(toAsyncSession),\n\t\t\t),\n\t\tcreateSession: () =>\n\t\t\trun(DevSessions.use((sessions) => sessions.createSession)).then(\n\t\t\t\ttoAsyncSession,\n\t\t\t),\n\t\tgetLatestOrCreate: () =>\n\t\t\trun(DevSessions.use((sessions) => sessions.getLatestOrCreate)).then(\n\t\t\t\ttoAsyncSession,\n\t\t\t),\n\t};\n};\n","import { NodeServices } from '@effect/platform-node';\nimport { Effect, type Scope } from 'effect';\n\nconst nodeLayer = NodeServices.layer;\n\n/** Runs an Effect that only needs the shared Node platform services (+ an optional Scope) as a Promise. */\nexport const runNode = <A, E>(\n\teffect: Effect.Effect<A, E, NodeServices.NodeServices | Scope.Scope>,\n): Promise<A> =>\n\tEffect.runPromise(Effect.scoped(Effect.provide(effect, nodeLayer)));\n","import type * as S from 'effect/Schema';\nimport { SessionState as EffectSessionState } from '../dev/session-state';\nimport { runNode } from './run';\nimport { type DevSession, unwrapSession } from './session';\n\nexport namespace SessionState {\n\t// Decoding must run without extra context (only `NodeServices | Scope` are\n\t// available via `runNode`), so schemas cannot require decoding services.\n\ttype Shape = S.Codec<unknown, unknown, never>;\n\n\texport function slot<T extends Shape>(schema: T) {\n\t\tconst effectSlot = EffectSessionState.slot(schema);\n\t\treturn {\n\t\t\tread: (session: DevSession): Promise<T['Type'] | null> =>\n\t\t\t\trunNode(effectSlot.read(unwrapSession(session))),\n\t\t\twrite: (session: DevSession, data: T['Type']): Promise<void> =>\n\t\t\t\trunNode(effectSlot.write(unwrapSession(session), data)),\n\t\t};\n\t}\n}\n"],"mappings":"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","names":["Effect","Effect","Effect","Effect","NodeServices","Effect","SessionState"]}

package/dist/async/run.d.ts

@@ -0,0 +1,5 @@
+import { NodeServices } from '@effect/platform-node';
+import { Effect, type Scope } from 'effect';
+/** Runs an Effect that only needs the shared Node platform services (+ an optional Scope) as a Promise. */
+export declare const runNode: <A, E>(effect: Effect.Effect<A, E, NodeServices.NodeServices | Scope.Scope>) => Promise<A>;
+//# sourceMappingURL=run.d.ts.map

package/dist/async/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/async/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,MAAM,EAAE,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAC;AAI5C,2GAA2G;AAC3G,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,UACnB,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,YAAY,CAAC,YAAY,GAAG,KAAK,CAAC,KAAK,CAAC,KAClE,OAAO,CAAC,CAAC,CACwD,CAAC"}

package/dist/async/session-state.d.ts

@@ -0,0 +1,11 @@
+import type * as S from 'effect/Schema';
+import { type DevSession } from './session';
+export declare namespace SessionState {
+    type Shape = S.Codec<unknown, unknown, never>;
+    export function slot<T extends Shape>(schema: T): {
+        read: (session: DevSession) => Promise<T['Type'] | null>;
+        write: (session: DevSession, data: T['Type']) => Promise<void>;
+    };
+    export {};
+}
+//# sourceMappingURL=session-state.d.ts.map

package/dist/async/session-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-state.d.ts","sourceRoot":"","sources":["../../src/async/session-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,eAAe,CAAC;AAGxC,OAAO,EAAE,KAAK,UAAU,EAAiB,MAAM,WAAW,CAAC;AAE3D,yBAAiB,YAAY,CAAC;IAG7B,KAAK,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IAE9C,MAAM,UAAU,IAAI,CAAC,CAAC,SAAS,KAAK,EAAE,MAAM,EAAE,CAAC;QAG7C,IAAI,YAAY,UAAU,KAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;QAEtD,KAAK,YAAY,UAAU,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAG,OAAO,CAAC,IAAI,CAAC;MAG7D;;CACD"}

package/dist/async/session.d.ts

@@ -0,0 +1,16 @@
+import type { DevSession as EffectDevSession } from '../dev-sessions';
+export type DevSession = {
+    readonly name: string;
+    readonly lastModifiedAt: Date | null;
+    path(relativePath: string): string;
+    toString(): string;
+};
+/**
+ * Wraps an Effect `DevSession` as a plain-async `DevSession`. The original Effect
+ * session is stashed under `EFFECT_SESSION` so other async ops (e.g. `SessionState`)
+ * can reuse the Effect core via `unwrapSession`.
+ */
+export declare const toAsyncSession: (session: EffectDevSession) => DevSession;
+/** Recovers the Effect `DevSession` stashed by `toAsyncSession`. */
+export declare const unwrapSession: (session: DevSession) => EffectDevSession;
+//# sourceMappingURL=session.d.ts.map

package/dist/async/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/async/session.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,IAAI,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAKtE,MAAM,MAAM,UAAU,GAAG;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE,IAAI,GAAG,IAAI,CAAC;IACrC,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IACnC,QAAQ,IAAI,MAAM,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,cAAc,YAAa,gBAAgB,KAAG,UAe1D,CAAC;AAEF,oEAAoE;AACpE,eAAO,MAAM,aAAa,YAAa,UAAU,KAAG,gBAanD,CAAC"}

package/dist/chunk-IEQZ3AJH.js

@@ -0,0 +1,282 @@
+// src/dev-sessions.ts
+import { Array as A, Context, Effect, Layer, Option } from "effect";
+import { FileSystem } from "effect/FileSystem";
+import { Path } from "effect/Path";
+import { generateSlug } from "random-word-slugs";
+var DevSession;
+((DevSession2) => {
+  function make(input) {
+    return {
+      name: input.name,
+      lastModifiedAt: input.lastModifiedAt,
+      path: (relativePath) => Effect.succeed(input.pathJoin(relativePath)),
+      toString: () => input.name
+    };
+  }
+  DevSession2.make = make;
+})(DevSession || (DevSession = {}));
+var DevSessions = class extends Context.Service()("devsess/DevSessions") {
+};
+var makeDevSessionsLayer = (rootDir) => Layer.effect(
+  DevSessions,
+  Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    const path = yield* Path;
+    yield* Effect.logDebug(`DevSessions dir: ${rootDir}`);
+    const getPath2 = (relativePath) => path.join(rootDir, relativePath);
+    const getSessions = Effect.gen(function* () {
+      const entries = yield* fs.readDirectory(rootDir).pipe(Effect.catch(() => Effect.succeed([])));
+      const possibleSessions = yield* Effect.all(
+        entries.map(
+          (entry) => Effect.gen(function* () {
+            const stat = yield* fs.stat(getPath2(entry));
+            if (stat.type !== "Directory") return Option.none();
+            return Option.some(
+              DevSession.make({
+                name: entry,
+                lastModifiedAt: Option.getOrNull(stat.mtime),
+                rootDir,
+                pathJoin: (relativePath) => path.join(rootDir, entry, relativePath)
+              })
+            );
+          })
+        ),
+        { concurrency: "unbounded" }
+      );
+      return A.getSomes(possibleSessions);
+    });
+    const createSession = Effect.gen(function* () {
+      const slug = generateSlug(1, { partsOfSpeech: ["noun"] });
+      yield* fs.makeDirectory(getPath2(slug), { recursive: true });
+      return DevSession.make({
+        name: slug,
+        lastModifiedAt: null,
+        rootDir,
+        pathJoin: (relativePath) => path.join(rootDir, slug, relativePath)
+      });
+    });
+    return {
+      dir: rootDir,
+      path: getPath2,
+      getSessions,
+      createSession,
+      getLatestOrCreate: Effect.gen(function* () {
+        yield* fs.makeDirectory(rootDir, { recursive: true });
+        const sessions = yield* getSessions;
+        if (sessions.length > 0) {
+          sessions.sort(
+            (a, b) => (b.lastModifiedAt?.getTime() ?? 0) - (a.lastModifiedAt?.getTime() ?? 0)
+          );
+          const latest = sessions[0];
+          return latest;
+        }
+        return yield* createSession;
+      })
+    };
+  })
+);
+
+// src/dev/session-state.ts
+import { Data, Effect as Effect2 } from "effect";
+import { FileSystem as FileSystem2 } from "effect/FileSystem";
+import { Path as Path2 } from "effect/Path";
+import * as S from "effect/Schema";
+var SessionStateError = class extends Data.TaggedError("SessionStateError") {
+};
+function getPath(session) {
+  return session.path("sess.json");
+}
+function read(filePath) {
+  return Effect2.gen(function* () {
+    const fs = yield* FileSystem2;
+    if (!(yield* fs.exists(filePath))) {
+      return null;
+    }
+    return yield* fs.readFileString(filePath);
+  });
+}
+var SessionState;
+((SessionState2) => {
+  function slot(schema) {
+    return {
+      read: (session) => Effect2.gen(function* () {
+        const filePath = yield* getPath(session);
+        const content = yield* read(filePath);
+        if (content == null) return null;
+        return yield* S.decodeEffect(S.fromJsonString(schema))(content).pipe(
+          Effect2.catchTag("SchemaError", () => Effect2.succeed(null))
+        );
+      }),
+      write: (session, data) => Effect2.gen(function* () {
+        const fs = yield* FileSystem2;
+        const path = yield* Path2;
+        const filePath = yield* getPath(session);
+        yield* fs.makeDirectory(path.dirname(filePath), { recursive: true });
+        const existing = yield* read(filePath);
+        const parsed = yield* Effect2.try({
+          try: () => JSON.parse(existing ?? "{}"),
+          catch: (cause) => new SessionStateError({
+            message: `Failed to parse ${filePath} as JSON`,
+            cause
+          })
+        });
+        const merged = { ...parsed, ...data };
+        yield* fs.writeFileString(filePath, JSON.stringify(merged));
+      })
+    };
+  }
+  SessionState2.slot = slot;
+})(SessionState || (SessionState = {}));
+
+// src/dev/run-dev-cli.ts
+import { join } from "path";
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import { Effect as Effect3, Layer as Layer2 } from "effect";
+import * as cli from "effect/unstable/cli";
+var runDevCli = (config) => {
+  const command = cli.Command.make(
+    config.name,
+    config.options ?? {},
+    (opts) => config.makeHandler(opts)
+  );
+  return (argv) => {
+    const layer = makeDevSessionsLayer(join(config.dir, ".data/sessions")).pipe(
+      Layer2.provideMerge(NodeServices.layer)
+    );
+    const program = cli.Command.runWith(command, {
+      version: "0.0.0"
+    })(argv);
+    NodeRuntime.runMain(Effect3.scoped(Effect3.provide(program, layer)));
+  };
+};
+
+// src/dev/running-signal.ts
+import { watch as fsWatch, realpathSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join as join2, resolve } from "path";
+import { Deferred, Effect as Effect4 } from "effect";
+import { FileSystem as FileSystem3 } from "effect/FileSystem";
+import { Path as Path3 } from "effect/Path";
+var RUNNING_SIGNAL_FILE = ".data/running.json";
+var runningSignalPath = (dir) => join2(dir, RUNNING_SIGNAL_FILE);
+var resolveSiblingDir = (spec, fromDir) => {
+  if (spec.startsWith(".") || spec.startsWith("/")) {
+    return resolve(fromDir, spec);
+  }
+  const require2 = createRequire(join2(fromDir, "package.json"));
+  const pkgJsonPath = require2.resolve(`${spec}/package.json`);
+  return dirname(realpathSync(pkgJsonPath));
+};
+var publishRunningSignal = (filePath, value) => Effect4.acquireRelease(
+  Effect4.gen(function* () {
+    const fs = yield* FileSystem3;
+    const path = yield* Path3;
+    const tmp = `${filePath}.tmp`;
+    yield* fs.makeDirectory(path.dirname(filePath), { recursive: true });
+    yield* fs.writeFileString(tmp, JSON.stringify(value));
+    yield* fs.rename(tmp, filePath);
+  }),
+  () => Effect4.gen(function* () {
+    const fs = yield* FileSystem3;
+    yield* fs.remove(filePath).pipe(Effect4.catch(() => Effect4.void));
+  })
+);
+var awaitRunningSignal = (filePath, opts) => Effect4.scoped(
+  Effect4.gen(function* () {
+    const fs = yield* FileSystem3;
+    const path = yield* Path3;
+    const dir = path.dirname(filePath);
+    const filename = path.basename(filePath);
+    const deferred = yield* Deferred.make();
+    const tryRead = Effect4.gen(function* () {
+      if (!(yield* fs.exists(filePath))) return false;
+      const raw = yield* fs.readFileString(filePath).pipe(Effect4.catch(() => Effect4.succeed(null)));
+      if (raw == null) return false;
+      const parsed = yield* Effect4.try(() => opts.parse(raw)).pipe(
+        Effect4.catch(() => Effect4.succeed(null))
+      );
+      if (parsed == null) return false;
+      yield* Deferred.succeed(deferred, parsed);
+      return true;
+    });
+    yield* fs.makeDirectory(dir, { recursive: true });
+    yield* Effect4.acquireRelease(
+      Effect4.sync(
+        () => (
+          // Watch parent dir — the file may not exist yet, and watching a missing file errors.
+          fsWatch(dir, { recursive: false }, (eventType, eventFilename) => {
+            if (eventFilename !== filename) return;
+            if (eventType !== "rename" && eventType !== "change") return;
+            Effect4.runFork(tryRead);
+          })
+        )
+      ),
+      (watcher) => Effect4.sync(() => watcher.close())
+    );
+    yield* tryRead;
+    return yield* Deferred.await(deferred);
+  })
+);
+
+// src/dev/sticky-port.ts
+import { Effect as Effect5 } from "effect";
+import * as S2 from "effect/Schema";
+import getPort from "get-port";
+var StickyPort = SessionState.slot(S2.Struct({ port: S2.Number }));
+var getStickyPort = (session) => Effect5.gen(function* () {
+  const file = yield* StickyPort.read(session);
+  const preferred = file?.port;
+  const port = yield* Effect5.promise(
+    async () => getPort({
+      port: preferred !== void 0 ? [preferred] : void 0
+    })
+  );
+  yield* StickyPort.write(session, { port });
+  return port;
+});
+
+// src/dev/subprocess.ts
+import { Effect as Effect6 } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+var runManagedSubprocess = (cmd, args, opts) => Effect6.gen(function* () {
+  const command = ChildProcess.make(cmd, args, {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    env: { ...process.env, ...opts?.env ?? {} }
+  });
+  const label = [cmd, ...args].join(" ");
+  const child = yield* Effect6.acquireRelease(
+    Effect6.gen(function* () {
+      const proc = yield* command;
+      yield* Effect6.logInfo(`[dev] started: ${label} (pid=${proc.pid})`);
+      return proc;
+    }),
+    (proc) => Effect6.gen(function* () {
+      yield* Effect6.logInfo(`[dev] stopping: ${label} (pid=${proc.pid})`);
+      yield* proc.kill().pipe(
+        Effect6.catch(
+          (err) => Effect6.logError(
+            `[dev] failed to stop ${label} (pid=${proc.pid}): ${err}`
+          )
+        )
+      );
+    })
+  );
+  return yield* child.exitCode;
+});
+
+export {
+  DevSessions,
+  makeDevSessionsLayer,
+  runDevCli,
+  runningSignalPath,
+  resolveSiblingDir,
+  publishRunningSignal,
+  awaitRunningSignal,
+  SessionStateError,
+  SessionState,
+  getStickyPort,
+  runManagedSubprocess
+};
+//# sourceMappingURL=chunk-IEQZ3AJH.js.map