@hachej/boring-core 0.1.81 → 0.1.83

package/dist/{PostgresModelBudgetStore-BbqIF5TR.d.ts → PostgresModelBudgetStore-Ulw6ijJG.d.ts}

@@ -1,5 +1,5 @@
 import postgres from 'postgres';
-import { C as CoreConfig } from './types-DDnayJjI.js';
+import { C as CoreConfig } from './types-Di-eoc58.js';
 import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
 
 type CoreMigrationSql = postgres.Sql;
@@ -275,6 +275,30 @@ interface ReserveBudgetResult {
     created: boolean;
     period: string;
 }
+type BudgetSpendQuery = {
+    scope: 'user';
+    userId: string;
+    now?: Date;
+} | {
+    scope: 'model';
+    userId: string;
+    provider: string;
+    model: string;
+    now?: Date;
+};
+interface BudgetSpendSnapshot {
+    scope: BudgetReservationScope;
+    /** Settled usage (ledger + settled fallback reservations) in micros for the current period. */
+    usedMicros: number;
+    /** In-flight active holds in micros for the current period. */
+    heldMicros: number;
+    /** Period key (e.g. "2026-07"). */
+    period: string;
+    /** Inclusive UTC start of the current budget period. */
+    periodStart: Date;
+    /** Exclusive UTC end of the current budget period == the reset boundary. */
+    periodEnd: Date;
+}
 interface BudgetReservationAdmissionInput {
     user?: Extract<ReserveBudgetInput, {
         scope: 'user';
@@ -305,6 +329,13 @@ declare class PostgresBudgetReservationStore {
     });
     static monthPeriodUtc(now?: Date): string;
     sweepExpired(now?: Date): Promise<number>;
+    /**
+     * Read-only snapshot of current-period used/held spend for a budget target,
+     * reusing the exact same accounting the admission path applies during a
+     * reservation (usage ledger + settled/active reservations). No rows are
+     * written. The reset boundary is derived from the same monthly period logic.
+     */
+    getSpendSnapshot(query: BudgetSpendQuery): Promise<BudgetSpendSnapshot>;
     reserve(input: ReserveBudgetInput): Promise<ReserveBudgetResult>;
     reserveAdmission(input: BudgetReservationAdmissionInput): Promise<BudgetReservationAdmission>;
     reserveMany(inputs: readonly ReserveBudgetInput[]): Promise<ReserveBudgetResult[]>;
@@ -354,4 +385,4 @@ declare class PostgresModelBudgetStore {
     release(input: FinishModelBudgetReservationInput): Promise<void>;
 }
 
-export { type BudgetReservationAdmission as B, type CreditLedgerEntry as C, type FinishReservationInput as F, type GrantOnceInput as G, InsufficientCreditError as I, type MeteringBalance as M, PostgresBudgetReservationStore as P, type RecordUsageInput as R, UserBudgetExceededError as U, type BudgetReservationAdmissionInput as a, type BudgetReservationScope as b, type FinishReservationInput$1 as c, ModelBudgetExceededError as d, PostgresMeteringStore as e, PostgresModelBudgetStore as f, type RecordUsageResult as g, type ReservationFinalStatus as h, type ReserveBudgetInput as i, type ReserveBudgetResult as j, type ReserveInput as k, type ReserveResult as l, type RunMigrationsOptions as m, runMigrations as r };
+export { type BudgetReservationAdmission as B, type CreditLedgerEntry as C, type FinishReservationInput as F, type GrantOnceInput as G, InsufficientCreditError as I, type MeteringBalance as M, PostgresBudgetReservationStore as P, type RecordUsageInput as R, UserBudgetExceededError as U, type BudgetReservationAdmissionInput as a, type BudgetReservationScope as b, type BudgetSpendQuery as c, type BudgetSpendSnapshot as d, type FinishReservationInput$1 as e, ModelBudgetExceededError as f, PostgresMeteringStore as g, PostgresModelBudgetStore as h, type RecordUsageResult as i, type ReservationFinalStatus as j, type ReserveBudgetInput as k, type ReserveBudgetResult as l, type ReserveInput as m, type ReserveResult as n, type RunMigrationsOptions as o, runMigrations as r };

package/dist/app/front/index.js

@@ -9,12 +9,12 @@ import {
   useSignIn,
   useSignUp,
   useWorkspaceRouteStatus
-} from "../../chunk-3B7LU76T.js";
+} from "../../chunk-DGBJFPUK.js";
 import "../../chunk-HYNKZSTF.js";
 import {
   isRuntimeEmailVerificationEnabled
 } from "../../chunk-I4PGL4ZD.js";
-import "../../chunk-QZGYKLXB.js";
+import "../../chunk-H7EYII35.js";
 import "../../chunk-MLKGABMK.js";
 
 // src/app/front/CoreWorkspaceAgentFront.tsx

package/dist/app/server/index.d.ts

@@ -1,11 +1,12 @@
 import { RuntimeProvisioningContribution, RegisterAgentRoutesOptions } from '@hachej/boring-agent/server';
 import { DirPluginEntry, CreateWorkspaceAgentServerOptions, WorkspaceAgentServerPluginContext } from '@hachej/boring-workspace/app/server';
 import { WorkspaceServerPlugin, WorkspaceBridgeOperationDefinition, WorkspaceBridgeHandler, WorkspaceBridgeRuntimeEnvOptions, WorkspaceBridgeCallRequest, WorkspaceBridgeCallResponse } from '@hachej/boring-workspace/server';
-import { FastifyInstance } from 'fastify';
-import { C as CoreConfig } from '../../types-DDnayJjI.js';
+import { FastifyRequest, FastifyReply, FastifyInstance } from 'fastify';
+import { C as CoreConfig } from '../../types-Di-eoc58.js';
 import { T as TelemetrySink } from '../../telemetry-DR18MeI0.js';
-import { B as BetterAuthInstance, L as LoadConfigOptions } from '../../loadConfig-C3iHuZNw.js';
-import { D as Database, U as UserStore, W as WorkspaceStore } from '../../types-Dm11Zm56.js';
+import { B as BetterAuthInstance, L as LoadConfigOptions } from '../../loadConfig-CuRGCFmt.js';
+import { D as Database, U as UserStore, W as WorkspaceStore, C as CoreRequestScopeResolver } from '../../types-CHdS89JJ.js';
+export { a as CoreRequestScope } from '../../types-CHdS89JJ.js';
 import { IncomingMessage, ServerResponse } from 'node:http';
 import 'better-auth';
 import 'drizzle-orm/postgres-js';
@@ -72,7 +73,10 @@ interface CreateCoreWorkspaceAgentServerOptions extends Omit<RegisterAgentRoutes
     telemetry?: TelemetrySink;
     /** Verified actor resolver exposed only to boot-time internal plugins. */
     trustedPluginActorResolver?: NonNullable<WorkspaceAgentServerPluginContext['trusted']>['actorResolver'];
+    requestScopeResolver?: CoreRequestScopeResolver;
+    frontendRootHandler?: CoreFrontendRootHandler;
 }
+type CoreFrontendRootHandler = (request: FastifyRequest, reply: FastifyReply) => boolean | Promise<boolean>;
 type AgentPiOptions = RegisterAgentRoutesOptions['pi'];
 declare function createCoreWorkspaceAgentServer(options?: CreateCoreWorkspaceAgentServerOptions): Promise<CoreWorkspaceAgentServer>;
 
@@ -126,4 +130,4 @@ interface RunCoreWorkspaceAgentServerOptions {
 }
 declare function runCoreWorkspaceAgentServer(importMetaUrl: string, opts?: RunCoreWorkspaceAgentServerOptions): Promise<void>;
 
-export { type CoreWorkspaceAgentDevServerHandle, type CoreWorkspaceAgentServer, type CoreWorkspaceAgentServerPlugin, type CreateCoreWorkspaceAgentServerOptions, type CreateVercelFastifyHandlerOptions, type RunCoreWorkspaceAgentServerOptions, type StartCoreWorkspaceAgentDevServerFromMetaOptions, type StartCoreWorkspaceAgentDevServerOptions, type VercelFastifyHandler, type VercelFastifyLikeServer, appRootFromImportMeta, createCoreWorkspaceAgentServer, createVercelFastifyHandler, runCoreWorkspaceAgentServer, startCoreWorkspaceAgentDevServer, startCoreWorkspaceAgentDevServerFromMeta };
+export { type CoreFrontendRootHandler, CoreRequestScopeResolver, type CoreWorkspaceAgentDevServerHandle, type CoreWorkspaceAgentServer, type CoreWorkspaceAgentServerPlugin, type CreateCoreWorkspaceAgentServerOptions, type CreateVercelFastifyHandlerOptions, type RunCoreWorkspaceAgentServerOptions, type StartCoreWorkspaceAgentDevServerFromMetaOptions, type StartCoreWorkspaceAgentDevServerOptions, type VercelFastifyHandler, type VercelFastifyLikeServer, appRootFromImportMeta, createCoreWorkspaceAgentServer, createVercelFastifyHandler, runCoreWorkspaceAgentServer, startCoreWorkspaceAgentDevServer, startCoreWorkspaceAgentDevServerFromMeta };

package/dist/app/server/index.js

@@ -1,4 +1,5 @@
 import {
+  REQUEST_SCOPE_WORKSPACE_HEADER,
   WorkspaceRuntimeSandboxHandleStore,
   authHook,
   createAuth,
@@ -9,21 +10,22 @@ import {
   registerRoutes,
   registerSettingsRoutes,
   registerWorkspaceRoutes
-} from "../../chunk-VB2N2DG5.js";
+} from "../../chunk-YFCR6SAS.js";
 import {
   PostgresUserStore,
   PostgresWorkspaceStore,
   createDatabase,
   telemetryEvents
-} from "../../chunk-H5BQOHWR.js";
+} from "../../chunk-RVVE5WOB.js";
 import {
   noopTelemetry,
   safeCapture
 } from "../../chunk-AQBXNPMD.js";
 import "../../chunk-I4PGL4ZD.js";
 import {
-  ERROR_CODES
-} from "../../chunk-QZGYKLXB.js";
+  ERROR_CODES,
+  HttpError
+} from "../../chunk-H7EYII35.js";
 import "../../chunk-MLKGABMK.js";
 
 // src/app/server/createCoreWorkspaceAgentServer.ts
@@ -66,6 +68,8 @@ import {
 var MAX_SESSION_OWNER_CACHE = 5e3;
 function createCoreWorkspaceBridge(options) {
   const { resolveWorkspaceId, workspaceStore, validateWorkspaceId, agentSessionId } = options;
+  const admittedBrowserWorkspaces = /* @__PURE__ */ new WeakMap();
+  const admittedRuntimeWorkspaces = /* @__PURE__ */ new WeakMap();
   const bridges = /* @__PURE__ */ new Map();
   const getBridge = (workspaceId) => {
     const safeWorkspaceId = validateWorkspaceId(workspaceId);
@@ -97,13 +101,15 @@ function createCoreWorkspaceBridge(options) {
     return runtime;
   };
   const resolveBridgeWorkspaceId = async (request) => {
+    const admittedRuntimeWorkspace = admittedRuntimeWorkspaces.get(request);
+    if (admittedRuntimeWorkspace) return admittedRuntimeWorkspace;
     const authHeader = request.headers.authorization;
     if (options.workspaceBridge?.runtimeTokenSecret && typeof authHeader === "string" && authHeader.startsWith("Bearer ")) {
       return verifyWorkspaceBridgeRuntimeToken(authHeader.slice("Bearer ".length), {
         secret: options.workspaceBridge.runtimeTokenSecret
       }).authContext.workspaceId;
     }
-    return await resolveWorkspaceId(request);
+    return admittedBrowserWorkspaces.get(request) ?? await resolveWorkspaceId(request);
   };
   const rememberSessionOwner = async (request) => {
     const user = request.user;
@@ -173,25 +179,39 @@ function createCoreWorkspaceBridge(options) {
     }
   } : void 0;
   const registerHttpRoutes = async (app) => {
-    await app.register(workspaceBridgeHttpRoutes, {
-      getRegistry: async (request) => getRuntime(await resolveBridgeWorkspaceId(request)).registry,
-      getIdempotencyStore: async (request) => getRuntime(await resolveBridgeWorkspaceId(request)).idempotencyStore,
-      runtimeTokenSecret: options.workspaceBridge?.runtimeTokenSecret,
-      runtimeRefreshTokenSecret: options.workspaceBridge?.runtimeRefreshTokenSecret,
-      getRuntimeRefreshTokenStore: (_request, claims) => getRuntime(claims.workspaceId).refreshTokenStore,
-      getOwnerWorkspaceId: async (request) => await resolveBridgeWorkspaceId(request),
-      browserAuthPolicy: createBrowserBridgeAuthPolicy({
-        getPrincipal: (input) => {
-          const user = input.request?.user;
-          return user?.id ? { userId: user.id, email: user.email ?? void 0 } : null;
-        },
-        authorizeWorkspace: async ({ principal, workspaceId, definition }) => ({
-          allowed: await workspaceStore.isMember(workspaceId, principal.userId),
-          capabilities: definition.requiredCapabilities
-        }),
-        allowedOrigins: options.corsOrigins,
-        requireCsrfHeader: true
-      })
+    const assertRuntimeWorkspaceScope = options.assertRuntimeWorkspaceScope;
+    await app.register(async (bridgeApp) => {
+      bridgeApp.addHook("preHandler", async (request) => {
+        const pathname = request.url.split("?")[0];
+        const authHeader = request.headers.authorization;
+        if (request.requestScope && pathname === "/api/v1/workspace-bridge/call" && !(typeof authHeader === "string" && authHeader.startsWith("Bearer "))) {
+          admittedBrowserWorkspaces.set(request, await resolveWorkspaceId(request));
+        }
+      });
+      await bridgeApp.register(workspaceBridgeHttpRoutes, {
+        getRegistry: async (request) => getRuntime(await resolveBridgeWorkspaceId(request)).registry,
+        getIdempotencyStore: async (request) => getRuntime(await resolveBridgeWorkspaceId(request)).idempotencyStore,
+        runtimeTokenSecret: options.workspaceBridge?.runtimeTokenSecret,
+        runtimeRefreshTokenSecret: options.workspaceBridge?.runtimeRefreshTokenSecret,
+        assertRuntimeWorkspaceScope: assertRuntimeWorkspaceScope ? async (request, claims) => {
+          await assertRuntimeWorkspaceScope(request, claims.workspaceId);
+          admittedRuntimeWorkspaces.set(request, claims.workspaceId);
+        } : void 0,
+        getRuntimeRefreshTokenStore: (_request, claims) => getRuntime(claims.workspaceId).refreshTokenStore,
+        getOwnerWorkspaceId: async (request) => await resolveBridgeWorkspaceId(request),
+        browserAuthPolicy: createBrowserBridgeAuthPolicy({
+          getPrincipal: (input) => {
+            const user = input.request?.user;
+            return user?.id ? { userId: user.id, email: user.email ?? void 0 } : null;
+          },
+          authorizeWorkspace: async ({ principal, workspaceId, definition }) => ({
+            allowed: await workspaceStore.isMember(workspaceId, principal.userId),
+            capabilities: definition.requiredCapabilities
+          }),
+          allowedOrigins: options.corsOrigins,
+          requireCsrfHeader: true
+        })
+      });
     });
   };
   return { getBridge, callAsRuntime, rememberSessionOwner, runtimeEnvContribution, registerHttpRoutes };
@@ -542,8 +562,54 @@ function resolveWorkspaceIdFromRequest(request) {
   const query = request.query;
   return validateWorkspaceIdSegment(firstString(headerValue) ?? firstString(query?.workspaceId) ?? "");
 }
-async function resolveAuthorizedWorkspaceId(request, workspaceStore) {
-  const normalizedWorkspaceId = resolveWorkspaceIdFromRequest(request);
+function d1HostScopeViolation(request) {
+  throw new HttpError({
+    status: 421,
+    code: ERROR_CODES.D1_HOST_SCOPE_VIOLATION,
+    message: ERROR_CODES.D1_HOST_SCOPE_VIOLATION,
+    requestId: request.id
+  });
+}
+function resolveRequestScopedWorkspaceId(request, presentedWorkspaceId) {
+  const scope = request.requestScope;
+  if (!scope) return resolveWorkspaceIdFromRequest(request);
+  const presented = [];
+  const rawHeaders = request.raw?.rawHeaders;
+  if (rawHeaders) {
+    for (let index = 0; index < rawHeaders.length; index += 2) {
+      if (rawHeaders[index]?.toLowerCase() === "x-boring-workspace-id") presented.push(...rawHeaders[index + 1]?.split(",") ?? [void 0]);
+    }
+  }
+  if (!presented.length) {
+    for (const [key, value] of Object.entries(request.headers)) {
+      if (key.toLowerCase() !== "x-boring-workspace-id") continue;
+      if (Array.isArray(value) && value.length === 0) d1HostScopeViolation(request);
+      presented.push(...Array.isArray(value) ? value : [value]);
+    }
+  }
+  const query = request.query;
+  if (query && Object.prototype.hasOwnProperty.call(query, "workspaceId")) {
+    const value = query.workspaceId;
+    const values = Array.isArray(value) ? value : [value];
+    if (values.length === 0) d1HostScopeViolation(request);
+    presented.push(...values);
+  }
+  if (presentedWorkspaceId !== void 0) presented.push(presentedWorkspaceId);
+  for (const value of presented) {
+    if (typeof value !== "string") d1HostScopeViolation(request);
+    let normalized;
+    try {
+      normalized = validateWorkspaceIdSegment(value);
+    } catch {
+      d1HostScopeViolation(request);
+    }
+    if (normalized !== scope.workspaceId) d1HostScopeViolation(request);
+  }
+  request.headers["x-boring-workspace-id"] = scope.workspaceId;
+  return scope.workspaceId;
+}
+async function resolveAuthorizedWorkspaceId(request, workspaceStore, presentedWorkspaceId) {
+  const normalizedWorkspaceId = resolveRequestScopedWorkspaceId(request, presentedWorkspaceId);
   const user = request.user;
   if (!user?.id) throw httpError("authentication required", 401);
   let member = false;
@@ -602,10 +668,15 @@ async function registerAuthProxy(app, options) {
     }
     const body = encodeAuthRequestBody(request);
     const targetUrl = new URL(request.url, app.config.auth.url).toString();
+    const authHeaders = toHeaders(request.headers);
+    authHeaders.delete(REQUEST_SCOPE_WORKSPACE_HEADER);
+    if (request.requestScope) {
+      authHeaders.set(REQUEST_SCOPE_WORKSPACE_HEADER, encodeURIComponent(request.requestScope.workspaceId));
+    }
     const response = await app.auth.handler(
       new Request(targetUrl, {
         method: request.method,
-        headers: toHeaders(request.headers),
+        headers: authHeaders,
         body
       })
     );
@@ -658,10 +729,17 @@ async function registerFrontendAuthPages(app, appRoot, telemetry) {
     app.get(pagePath, async (request, reply) => serveFrontendShell(request, reply, indexPath, telemetry));
   }
 }
-async function registerFrontendFallback(app, appRoot, telemetry) {
+async function registerFrontendFallback(app, appRoot, telemetry, rootHandler) {
   const frontDistDir = path.resolve(appRoot, "dist/front");
   const indexPath = path.resolve(frontDistDir, "index.html");
-  app.get("/", async (request, reply) => serveFrontendShell(request, reply, indexPath, telemetry));
+  if (rootHandler) {
+    app.get("/", async (request, reply) => {
+      if (await rootHandler(request, reply)) return reply;
+      return serveFrontendShell(request, reply, indexPath, telemetry);
+    });
+  } else {
+    app.get("/", async (request, reply) => serveFrontendShell(request, reply, indexPath, telemetry));
+  }
   app.get("/*", async (request, reply) => {
     const pathname = request.url.split("?")[0] ?? "/";
     if (!shouldServeFrontend(pathname)) return reply.callNotFound();
@@ -686,7 +764,7 @@ async function registerFrontendFallback(app, appRoot, telemetry) {
     return serveFrontendShell(request, reply, indexPath, telemetry);
   });
 }
-async function createCoreRuntime(config, customTelemetry) {
+async function createCoreRuntime(config, customTelemetry, requestScopeResolver) {
   if (config.stores !== "postgres") {
     throw new Error("createCoreWorkspaceAgentServer currently supports only CORE_STORES=postgres");
   }
@@ -697,11 +775,16 @@ async function createCoreRuntime(config, customTelemetry) {
     storeDb,
     config.encryption.workspaceSettingsKey
   );
-  const app = await createCoreApp(config);
+  const app = await createCoreApp(config, { requestScopeResolver });
   const telemetry = customTelemetry ?? createDatabaseTelemetryFromEnv(db, { appId: config.appId }, process.env);
   const telemetrySource = customTelemetry ? "custom" : process.env.BORING_TELEMETRY_ENABLED === "true" ? "db-env" : "noop-env";
   app.log.debug({ telemetry: { source: telemetrySource } }, "resolved telemetry sink");
-  const auth = createAuth(config, db, { workspaceStore, logger: app.log, telemetry });
+  const auth = createAuth(config, db, {
+    workspaceStore,
+    logger: app.log,
+    telemetry,
+    disableDefaultWorkspaceCreation: requestScopeResolver !== void 0
+  });
   app.decorate("db", db);
   app.decorate("auth", auth);
   app.decorate("userStore", userStore);
@@ -740,7 +823,7 @@ async function createCoreWorkspaceAgentServer(options = {}) {
   }
   assertCoreStaticPluginEntries(options.plugins);
   const config = options.config ?? await loadConfig(resolveCoreLoadConfigOptions(options));
-  const { app, sql, db, userStore, workspaceStore, telemetry } = await createCoreRuntime(config, options.telemetry);
+  const { app, sql, db, userStore, workspaceStore, telemetry } = await createCoreRuntime(config, options.telemetry, options.requestScopeResolver);
   const appRoot = options.appRoot;
   const serveFrontend = options.serveFrontend ?? (process.env.NODE_ENV !== "development" && Boolean(appRoot));
   const pluginWorkspaceRoot = process.cwd();
@@ -785,12 +868,20 @@ async function createCoreWorkspaceAgentServer(options = {}) {
     workspaceRoot: pluginWorkspaceRoot,
     bridge: createUnavailableCorePluginBridge()
   };
-  const trustedPluginActorResolver = options.trustedPluginActorResolver ?? (async (request) => {
+  const defaultPluginActorResolver = async (request) => {
     const workspaceId = await resolveAuthorizedWorkspaceId(request, workspaceStore);
     const userId = request.user?.id;
     if (!userId) throw httpError("authentication required", 401);
     return { workspaceId, userId };
-  });
+  };
+  const trustedPluginActorResolver = async (request) => {
+    if (!options.trustedPluginActorResolver) return await defaultPluginActorResolver(request);
+    if (!request.requestScope) return await options.trustedPluginActorResolver(request);
+    const workspaceId = await resolveAuthorizedWorkspaceId(request, workspaceStore);
+    const actor = await options.trustedPluginActorResolver(request);
+    if (actor.workspaceId !== workspaceId) d1HostScopeViolation(request);
+    return actor;
+  };
   const trustedPluginResolveContext = {
     ...basePluginResolveContext,
     trusted: {
@@ -823,7 +914,7 @@ async function createCoreWorkspaceAgentServer(options = {}) {
     excludeDefaults: options.excludeDefaults,
     installPluginAuthoring
   });
-  const resolveWorkspaceId = async (request) => options.getWorkspaceId ? await options.getWorkspaceId(request) : await resolveAuthorizedWorkspaceId(request, workspaceStore);
+  const resolveWorkspaceId = async (request, presentedWorkspaceId) => request.requestScope ? await resolveAuthorizedWorkspaceId(request, workspaceStore, presentedWorkspaceId) : options.getWorkspaceId ? await options.getWorkspaceId(request) : await resolveAuthorizedWorkspaceId(request, workspaceStore, presentedWorkspaceId);
   const resolveRoot = async (workspaceId, request) => {
     const root = options.getWorkspaceRoot ? await options.getWorkspaceRoot(workspaceId, request) : await resolveWorkspaceRoot(workspaceRoot, workspaceId);
     return root;
@@ -840,7 +931,10 @@ async function createCoreWorkspaceAgentServer(options = {}) {
     workspaceStore,
     corsOrigins: app.config.cors.origins,
     validateWorkspaceId: validateWorkspaceIdSegment,
-    agentSessionId: agentSessionIdFromRequest
+    agentSessionId: agentSessionIdFromRequest,
+    assertRuntimeWorkspaceScope: options.requestScopeResolver ? (request, workspaceId) => {
+      if (request.requestScope?.workspaceId !== workspaceId) d1HostScopeViolation(request);
+    } : void 0
   });
   app.addHook("preHandler", async (request) => {
     await coreBridge.rememberSessionOwner(request);
@@ -890,6 +984,9 @@ async function createCoreWorkspaceAgentServer(options = {}) {
         projectName: workspace?.name ?? "Workspace"
       };
     } catch (error) {
+      if (error?.status === 421 && error?.code === ERROR_CODES.D1_HOST_SCOPE_VIOLATION) {
+        throw error;
+      }
       const statusCode = typeof error?.statusCode === "number" ? error.statusCode : 500;
       const message = error instanceof Error ? error.message : "workspace meta failed";
       return reply.code(statusCode).send({ error: message });
@@ -976,7 +1073,7 @@ async function createCoreWorkspaceAgentServer(options = {}) {
     await app.register(routes);
   }
   if (serveFrontend && appRoot) {
-    await registerFrontendFallback(app, appRoot, telemetry);
+    await registerFrontendFallback(app, appRoot, telemetry, options.frontendRootHandler);
   }
   return app;
 }

package/dist/{chunk-3B7LU76T.js → chunk-DGBJFPUK.js}

@@ -9,7 +9,7 @@ import {
   ConfigFetchError,
   ERROR_CODES,
   HttpError
-} from "./chunk-QZGYKLXB.js";
+} from "./chunk-H7EYII35.js";
 
 // src/front/AppErrorBoundary.tsx
 import { Component } from "react";

package/dist/{chunk-QZGYKLXB.js → chunk-H7EYII35.js}

@@ -29,6 +29,8 @@ var ERROR_CODES = {
   MAIL_DISABLED: "mail_disabled",
   DB_UNAVAILABLE: "db_unavailable",
   INTERNAL_ERROR: "internal_error",
+  D1_HOST_SCOPE_VIOLATION: "D1_HOST_SCOPE_VIOLATION",
+  D1_MANAGED_WORKSPACE_MUTATION_FORBIDDEN: "D1_MANAGED_WORKSPACE_MUTATION_FORBIDDEN",
   // Credits + purchases
   PAYMENT_REQUIRED: "payment_required",
   INVALID_PACK: "invalid_pack",

package/dist/{chunk-H5BQOHWR.js → chunk-RVVE5WOB.js}

@@ -1,7 +1,7 @@
 import {
   ERROR_CODES,
   HttpError
-} from "./chunk-QZGYKLXB.js";
+} from "./chunk-H7EYII35.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
@@ -296,10 +296,15 @@ var LocalWorkspaceStore = class {
     this.members.set(key, member);
     return member;
   }
-  async updateMemberRole(workspaceId, userId, role) {
+  async createMemberIfAbsent(workspaceId, userId, role) {
+    if (this.members.has(`${workspaceId}:${userId}`)) return null;
+    return this.upsertMember(workspaceId, userId, role);
+  }
+  async updateMemberRole(workspaceId, userId, role, opts) {
     const key = `${workspaceId}:${userId}`;
     const membership = this.members.get(key);
     if (!membership) return { code: ERROR_CODES.NOT_MEMBER };
+    if (opts?.forbidExistingOwnerMutation && membership.role === "owner" && role !== "owner") return { code: ERROR_CODES.D1_MANAGED_WORKSPACE_MUTATION_FORBIDDEN };
     if (membership.role === "owner" && role !== "owner") {
       let otherOwnerExists = false;
       for (const m of this.members.values()) {
@@ -318,6 +323,7 @@ var LocalWorkspaceStore = class {
     const key = `${workspaceId}:${userId}`;
     const membership = this.members.get(key);
     if (!membership) return { removed: false, code: ERROR_CODES.NOT_MEMBER };
+    if (opts?.forbidExistingOwnerMutation && membership.role === "owner") return { removed: false, code: ERROR_CODES.D1_MANAGED_WORKSPACE_MUTATION_FORBIDDEN };
     if (!opts?.allowLastOwner && membership.role === "owner") {
       let otherOwnerExists = false;
       for (const m of this.members.values()) {
@@ -1293,7 +1299,11 @@ var PostgresWorkspaceStore = class {
     }).returning();
     return toWorkspaceMember(row);
   }
-  async updateMemberRole(workspaceId, userId, role) {
+  async createMemberIfAbsent(workspaceId, userId, role) {
+    const [row] = await this.db.insert(workspaceMembers).values({ workspaceId, userId, role }).onConflictDoNothing().returning();
+    return row ? toWorkspaceMember(row) : null;
+  }
+  async updateMemberRole(workspaceId, userId, role, opts) {
     return this.db.transaction(async (tx) => {
       await tx.execute(sql4`
         SELECT user_id
@@ -1309,6 +1319,7 @@ var PostgresWorkspaceStore = class {
       ).limit(1);
       const currentRole = memberRows[0]?.role;
       if (!currentRole) return { code: ERROR_CODES.NOT_MEMBER };
+      if (opts?.forbidExistingOwnerMutation && currentRole === "owner" && role !== "owner") return { code: ERROR_CODES.D1_MANAGED_WORKSPACE_MUTATION_FORBIDDEN };
       if (currentRole === "owner" && role !== "owner") {
         const [{ count }] = await tx.select({ count: sql4`count(*)::int` }).from(workspaceMembers).where(
           and(
@@ -1335,7 +1346,7 @@ var PostgresWorkspaceStore = class {
         SELECT user_id
         FROM workspace_members
         WHERE workspace_id = ${workspaceId}
-          AND role = 'owner'
+          ${opts?.forbidExistingOwnerMutation ? sql4`` : sql4`AND role = 'owner'`}
         FOR UPDATE
       `);
       const memberRows = await tx.select({ role: workspaceMembers.role }).from(workspaceMembers).where(
@@ -1346,6 +1357,7 @@ var PostgresWorkspaceStore = class {
       ).limit(1);
       const role = memberRows[0]?.role;
       if (!role) return { removed: false, code: ERROR_CODES.NOT_MEMBER };
+      if (opts?.forbidExistingOwnerMutation && role === "owner") return { removed: false, code: ERROR_CODES.D1_MANAGED_WORKSPACE_MUTATION_FORBIDDEN };
       if (!opts?.allowLastOwner && role === "owner") {
         const [{ count }] = await tx.select({ count: sql4`count(*)::int` }).from(workspaceMembers).where(
           and(
@@ -2772,6 +2784,20 @@ var PostgresBudgetReservationStore = class {
       return count;
     });
   }
+  /**
+   * Read-only snapshot of current-period used/held spend for a budget target,
+   * reusing the exact same accounting the admission path applies during a
+   * reservation (usage ledger + settled/active reservations). No rows are
+   * written. The reset boundary is derived from the same monthly period logic.
+   */
+  async getSpendSnapshot(query) {
+    if (!query.userId) throw new Error("getSpendSnapshot requires userId");
+    const now = query.now ?? /* @__PURE__ */ new Date();
+    const period = monthPeriodUtc(now);
+    const input = query.scope === "model" ? { scope: "model", userId: query.userId, provider: query.provider, model: query.model, runId: "", budgetMicros: 1, holdMicros: 1, ttlSeconds: 1 } : { scope: "user", userId: query.userId, runId: "", budgetMicros: 1, holdMicros: 1, ttlSeconds: 1 };
+    const { usedMicros, heldMicros } = await this.db.transaction((tx) => this.spend(tx, input, period.period, period.start, period.end));
+    return { scope: query.scope, usedMicros, heldMicros, period: period.period, periodStart: period.start, periodEnd: period.end };
+  }
   async reserve(input) {
     assertReserveInput(input);
     const now = input.now ?? /* @__PURE__ */ new Date();