@junejs/server 0.1.2-dev.9 → 1.0.0-dev.11

package/dist/agent-durable.js

@@ -1,3 +1,4 @@
+import { isolateLocal } from "./isolate-local.js";
 import { assertCoreRuntimeVersion } from "./core-version.js";
 import { channelDispatch, resolveChannel } from "@junejs/core/agent-config";
 import { AgentSession, ResumeAuthorizationError, withSystem } from "@junejs/core/agent-runtime";
@@ -325,6 +326,18 @@ function durableAgentSurface(getNamespace, opts) {
 		return Response.json({ text: await sseTurnFinalText(res) });
 	};
 }
+function resolveServices(factory, env, agentName) {
+	if (!factory) return void 0;
+	if (typeof env !== "object" || env === null) return factory(env);
+	const cache = isolateLocal("june.durableChannelSurface.services", () => /* @__PURE__ */ new WeakMap());
+	let perAgent = cache.get(env);
+	if (!perAgent) {
+		perAgent = /* @__PURE__ */ new Map();
+		cache.set(env, perAgent);
+	}
+	if (!perAgent.has(agentName)) perAgent.set(agentName, factory(env));
+	return perAgent.get(agentName);
+}
 function durableChannelSurface(getNamespace, opts) {
 	return channelDispatch(opts.channels.map((c) => resolveChannel(c, opts.env)), {
 		agent: {
@@ -335,7 +348,7 @@ function durableChannelSurface(getNamespace, opts) {
 			channels: [],
 			connections: []
 		},
-		services: opts.services?.(opts.env),
+		services: resolveServices(opts.services, opts.env, opts.agentName),
 		waitUntil: opts.waitUntil,
 		run: async (message, o) => {
 			const namespace = getNamespace();

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { AdapterCapabilities, AdapterEmitContext, AdapterEntry, JuneAdapter, ResourcePlan, deno, staticSite, vercel, workers } from "./adapter.js";
 import { CreateAppOptions, JuneApp, createApp } from "./app.js";
 import { R2Bucket, localBlob, r2 } from "./blob.js";
-import { a as Pipeline, d as createPipeline, n as LayoutComponent, o as PipelineConfig, s as Resolved, u as RouteResolver } from "./pipeline-CCp9idQ4.js";
+import { a as Pipeline, d as createPipeline, n as LayoutComponent, o as PipelineConfig, s as Resolved, u as RouteResolver } from "./pipeline-cCR6MGNK.js";
 import { WorkerManifest, createWorker } from "./worker.js";
 import { BuildResult, buildManifest, freezeConfig, generateContent, juneBuild, scanRoutes } from "./build.js";
 import { loadJuneConfig } from "./config-loader.js";

package/dist/isolate-local.d.ts

@@ -0,0 +1,6 @@
+//#region src/isolate-local.d.ts
+type IsolateLocal = <T>(key: string | symbol, make: () => T) => T;
+declare function makeIsolateLocalFallback(): IsolateLocal;
+declare const isolateLocal: IsolateLocal;
+//#endregion
+export { IsolateLocal, isolateLocal, makeIsolateLocalFallback };

package/dist/isolate-local.js

@@ -0,0 +1,12 @@
+import * as juneDb from "@junejs/db";
+//#region src/isolate-local.ts
+function makeIsolateLocalFallback() {
+	const values = /* @__PURE__ */ new Map();
+	return (key, make) => {
+		if (!values.has(key)) values.set(key, make());
+		return values.get(key);
+	};
+}
+const isolateLocal = juneDb.isolateLocal ?? makeIsolateLocalFallback();
+//#endregion
+export { isolateLocal, makeIsolateLocalFallback };

package/dist/{pipeline-CCp9idQ4.d.ts → pipeline-cCR6MGNK.d.ts}

@@ -4,6 +4,7 @@ import React from "react";
 import { DocumentConfig } from "@junejs/core/document";
 import { I18nConfig } from "@junejs/core/i18n";
 import { Resources } from "@junejs/core/resources";
+import { Principal, Session } from "@junejs/core/context";
 //#region src/pipeline.d.ts
 type LayoutComponent = React.ComponentType<{
   children: React.ReactNode;
@@ -32,6 +33,13 @@ type PipelineConfig = {
   resolve: RouteResolver;
   resources?: () => Promise<Resources> | Resources;
   services?: () => Promise<unknown> | unknown;
+  identity?: (request: Request) => Promise<{
+    user?: Principal;
+    session?: Session;
+  }> | {
+    user?: Principal;
+    session?: Session;
+  };
   earlyHints?: string[];
   htmlCacheControl?: string;
   notFoundComponent?: React.ComponentType<{

package/dist/pipeline.d.ts

@@ -1,2 +1,2 @@
-import { a as Pipeline, c as ResolvedResource, d as createPipeline, i as MiddlewareHandler, l as ResourceHandler, n as LayoutComponent, o as PipelineConfig, r as LoadingComponent, s as Resolved, t as ExtraHandler, u as RouteResolver } from "./pipeline-CCp9idQ4.js";
+import { a as Pipeline, c as ResolvedResource, d as createPipeline, i as MiddlewareHandler, l as ResourceHandler, n as LayoutComponent, o as PipelineConfig, r as LoadingComponent, s as Resolved, t as ExtraHandler, u as RouteResolver } from "./pipeline-cCR6MGNK.js";
 export { ExtraHandler, LayoutComponent, LoadingComponent, MiddlewareHandler, Pipeline, PipelineConfig, Resolved, ResolvedResource, ResourceHandler, RouteResolver, createPipeline };

package/dist/pipeline.js

@@ -171,7 +171,10 @@ function createPipeline(cfg) {
 		const url = new URL(request.url);
 		if (url.pathname === "/mcp") {
 			if (!agent.mcp) return notFoundResponse("view", url.pathname);
-			return mcpHandler(request, { request });
+			return mcpHandler(request, {
+				request,
+				...cfg.identity ? await cfg.identity(request) : void 0
+			});
 		}
 		if (request.method === "GET" && agent.discovery) {
 			const d = await discovery(url);

package/dist/worker.d.ts

@@ -1,4 +1,4 @@
-import { l as ResourceHandler, n as LayoutComponent, r as LoadingComponent, t as ExtraHandler } from "./pipeline-CCp9idQ4.js";
+import { l as ResourceHandler, n as LayoutComponent, r as LoadingComponent, t as ExtraHandler } from "./pipeline-cCR6MGNK.js";
 import { BrandedRoute } from "@junejs/core/route";
 import { AgentConfig } from "@junejs/core/config";
 import React from "react";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "0.1.2-dev.9",
+  "version": "1.0.0-dev.11",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -125,14 +125,14 @@
     "build": "tsdown"
   },
   "dependencies": {
-    "@junejs/db": ">=0.0.34-dev.0",
+    "@junejs/db": ">=0.1.0-dev.2",
     "@momiji-rs/sparkdown": "^0.0.4",
     "lightningcss": "^1.27.0",
     "oxc-parser": "^0.137.0",
     "rolldown": "^1.1.0"
   },
   "peerDependencies": {
-    "@junejs/core": ">=0.1.1-dev.16",
+    "@junejs/core": ">=0.2.0-dev.26",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "react-server-dom-webpack": "19.2.7",
@@ -156,7 +156,8 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/junebuild/june"
+    "url": "git+https://github.com/junebuild/june.git",
+    "directory": "packages/june"
   },
   "devDependencies": {
     "@libsql/client": "^0.17.3",

package/src/agent-durable.ts

@@ -41,6 +41,7 @@ import {
   type ChannelFactory,
 } from "@junejs/core/agent-config";
 import { ensureScope, runInScope } from "@junejs/db";
+import { isolateLocal } from "./isolate-local";
 import { assertCoreRuntimeVersion } from "./core-version";
 
 // ── minimal structural Cloudflare surface (no @cloudflare/workers-types dep) ──
@@ -605,6 +606,43 @@ export function durableAgentSurface(
 // fails in the background — surfaced via the channel's onError IF one is configured,
 // otherwise swallowed (runBackground never rejects). The app is expected to bind
 // env.AGENT when it mounts channels. Returns null for unclaimed requests.
+// The services bag, memoized per (env object, agentName).
+//
+// Why that key. `env` identity is what makes the memo survive: a worker builds
+// the surface inside `fetch`, so the only thing stable across requests is the
+// env object the host hands in — and NOT the provider function, which the
+// documented shape (`services: (e) => makeServices(e)`) recreates on every
+// fetch. But env alone is too coarse: two surfaces mounted in one worker over
+// the same env would then share whichever bag was built first, making the
+// result depend on mount order. `agentName` is the surface's own stable
+// identity, so it partitions them. (One agent must therefore have ONE services
+// provider — mounting the same agentName twice with different providers is
+// incoherent and keeps the first bag.)
+//
+// Held in an isolateLocal so duplicate module instances (workspace symlinks)
+// share one cache; the outer WeakMap is keyed by env so a host handing out
+// fresh env objects gets fresh bags instead of a leak. A non-object env (tests
+// passing a primitive) skips memoization rather than throwing.
+function resolveServices(
+  factory: ((env: unknown) => unknown) | undefined,
+  env: unknown,
+  agentName: string,
+): unknown {
+  if (!factory) return undefined;
+  if (typeof env !== "object" || env === null) return factory(env);
+  const cache = isolateLocal(
+    "june.durableChannelSurface.services",
+    () => new WeakMap<object, Map<string, unknown>>(),
+  );
+  let perAgent = cache.get(env);
+  if (!perAgent) {
+    perAgent = new Map<string, unknown>();
+    cache.set(env, perAgent);
+  }
+  if (!perAgent.has(agentName)) perAgent.set(agentName, factory(env));
+  return perAgent.get(agentName);
+}
+
 export function durableChannelSurface(
   getNamespace: () => DurableObjectNamespace | undefined,
   opts: {
@@ -614,7 +652,17 @@ export function durableChannelSurface(
     // The app's services factory — the SAME one AgentDurableObject uses — resolved HERE
     // (worker isolate) and exposed to channel hooks as ctx.services. Channel hooks run at
     // the edge, outside the DO, so they can't read the DO's ambient currentServices(); this
-    // gives them the same DI bag. Resolved once per surface construction.
+    // gives them the same DI bag.
+    //
+    // Called once per (env object, agentName) — NOT once per surface. A worker
+    // typically constructs the surface inside `fetch` (env only exists inside an
+    // invocation), so resolving per construction rebuilt every client on every
+    // request and any cache the bag held could never hit. Memoizing on env
+    // identity fixes that; see resolveServices above for why the key is env ×
+    // agentName and not the provider function. Practical consequences: the
+    // provider must be a function of `env` alone, it runs again whenever the
+    // host hands in a different env object (a new isolate, or a test), and one
+    // agentName must have one provider.
     services?: (env: unknown) => unknown;
     waitUntil?: (p: Promise<unknown>) => void;
   },
@@ -624,7 +672,7 @@ export function durableChannelSurface(
     // A minimal but complete AgentDefinition — channels only read ctx.agent.name; the
     // full def isn't present in the worker (tools/model live in the DO).
     agent: { name: opts.agentName, instructions: "", tools: [], skills: [], channels: [], connections: [] } satisfies AgentDefinition,
-    services: opts.services?.(opts.env),
+    services: resolveServices(opts.services, opts.env, opts.agentName),
     waitUntil: opts.waitUntil,
     run: async (message, o) => {
       const namespace = getNamespace();

package/src/isolate-local.ts

@@ -0,0 +1,33 @@
+// isolate-local.ts — read @junejs/db's `isolateLocal` WITHOUT a named import.
+//
+// Same hazard core-version.ts exists for: a NAMED import of an export the
+// resolved copy doesn't have dies at module LINK time with an unhelpful
+// SyntaxError, before any of our own diagnostics can run. `isolateLocal` is new
+// in @junejs/db 0.1.0-dev.2, and a version range cannot save us here — the
+// floor has to stay satisfiable by the workspace's own db (which is the very
+// version that lacks it), and `bun pm pack` rewrites a `workspace:*` dep to
+// whatever version it resolves, which can be OLDER still.
+//
+// So: namespace import + optional read, with a local fallback. Unlike the core
+// runtime contract, this one does NOT warrant throwing — isolate-scoped
+// memoization is a lifetime optimization, not a correctness contract. The
+// fallback memoizes in this module instance, so callers keep their cache; the
+// only thing lost against an older db is sharing one value across DUPLICATE
+// copies of the module (workspace symlinks), which costs a missed cache hit,
+// never a wrong answer.
+import * as juneDb from "@junejs/db";
+
+export type IsolateLocal = <T>(key: string | symbol, make: () => T) => T;
+
+// Exported for tests: the ambient read below can only ever see the workspace's
+// own (matching) db, so the degraded path needs a direct handle to be provable.
+export function makeIsolateLocalFallback(): IsolateLocal {
+  const values = new Map<string | symbol, unknown>();
+  return <T>(key: string | symbol, make: () => T): T => {
+    if (!values.has(key)) values.set(key, make());
+    return values.get(key) as T;
+  };
+}
+
+export const isolateLocal: IsolateLocal =
+  (juneDb as { isolateLocal?: IsolateLocal }).isolateLocal ?? makeIsolateLocalFallback();

package/src/pipeline.ts

@@ -34,6 +34,7 @@ import {
   sitemapXml,
 } from "@junejs/core/discovery";
 import { mcpHandler, mcpTools } from "@junejs/core/mcp";
+import type { Principal, Session } from "@junejs/core/context";
 
 import { ensureScope, runInScope, setRequestLocale } from "@junejs/db";
 import type { AgentConfig } from "@junejs/core/config";
@@ -126,6 +127,14 @@ export type PipelineConfig = {
   // `currentServices()` resolves in loaders/views/actions. Absent → currentServices()
   // is undefined. This is the Worker-side twin of a Durable Object seeding services.
   services?: () => Promise<unknown> | unknown;
+  // Resolve the request's authenticated identity (the auth integration's job —
+  // e.g. Better Auth reading the session cookie). The result rides every
+  // ActionContext the pipeline builds, starting with the /mcp mount, so
+  // requiresPrincipal actions and per-call connection auth see the SAME
+  // principal a UI dispatch would. Absent → anonymous (identity-gated actions
+  // reject); a THROWING resolver propagates as a server error — it must never
+  // silently degrade to anonymous.
+  identity?: (request: Request) => Promise<{ user?: Principal; session?: Session }> | { user?: Principal; session?: Session };
   earlyHints?: string[];
   htmlCacheControl?: string;
   notFoundComponent?: React.ComponentType<{ pathname: string }>;
@@ -473,9 +482,11 @@ export function createPipeline(cfg: PipelineConfig): Pipeline {
       if (url.pathname === "/mcp") {
         if (!agent.mcp) return notFoundResponse("view", url.pathname);
         // The agent's tool calls run inside the same request scope, so an action's
-        // ambient `db` is the SAME resource the UI uses (and, once auth is wired,
-        // the same principal via ctx). ctx carries identity only — not resources.
-        return mcpHandler(request, { request });
+        // ambient `db` is the SAME resource the UI uses, and — via cfg.identity —
+        // the same principal: requiresPrincipal actions and per-call connection
+        // auth are live on this surface. ctx carries identity only — not resources.
+        const identity = cfg.identity ? await cfg.identity(request) : undefined;
+        return mcpHandler(request, { request, ...identity });
       }
       if (request.method === "GET" && agent.discovery) {
         const d = await discovery(url);