@xopcai/xopc 0.0.391 → 0.0.393

package/dist/packages/gateway-contract/src/scenes.js

@@ -1,200 +0,0 @@
-import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
-import { z } from "zod";
-//#region packages/gateway-contract/src/scenes.ts
-var identifier, uniqueIds, sceneOutcomeKinds, activationStatuses, sceneScopeSchema, limitsSchema, executionSchema, sceneTemplateSchema, scenePermissionSchema, sceneNotesSchema, activationInputSchema, SceneActivationSchema, SceneConfigureSchema, SceneTransitionSchema, SceneWorkItemCreateSchema, SceneWorkItemUpdateSchema, SceneWorkItemSchema, hour, scenePreferencesSchema, preferenceFields, ScenePreferencePatchSchema, SceneFeedbackSchema, sceneScheduleSchema;
-var init_scenes = __esmMin((() => {
-	identifier = z.string().trim().min(1).max(200);
-	uniqueIds = z.array(identifier).max(100).refine((items) => new Set(items).size === items.length, "Duplicate identifiers");
-	sceneOutcomeKinds = [
-		"no_change",
-		"observation",
-		"artifact",
-		"decision",
-		"state_change",
-		"effect_proposal",
-		"receipt"
-	];
-	activationStatuses = [
-		"needs_setup",
-		"active",
-		"paused",
-		"completed",
-		"archived"
-	];
-	sceneScopeSchema = z.discriminatedUnion("kind", [
-		z.strictObject({ kind: z.literal("personal") }),
-		z.strictObject({
-			kind: z.literal("project"),
-			id: identifier
-		}),
-		z.strictObject({
-			kind: z.literal("conversation"),
-			id: identifier
-		}),
-		z.strictObject({
-			kind: z.literal("objects"),
-			ids: uniqueIds.refine((ids) => ids.length > 0)
-		})
-	]);
-	limitsSchema = z.strictObject({
-		timeoutSeconds: z.number().int().min(1).max(600),
-		maxIterations: z.number().int().min(1).max(30),
-		maxToolCalls: z.number().int().min(0).max(100),
-		maxOutputTokens: z.number().int().min(1).max(32768)
-	});
-	executionSchema = z.strictObject({
-		kind: z.string().regex(/^[a-z][a-z0-9_-]{0,63}$/),
-		instruction: z.string().trim().min(1).max(32e3),
-		limits: limitsSchema
-	});
-	sceneTemplateSchema = z.strictObject({
-		schemaVersion: z.literal(1),
-		key: z.string().regex(/^[a-z][a-z0-9-]{0,79}$/),
-		version: z.string().regex(/^\d+\.\d+\.\d+$/),
-		title: z.string().trim().min(1).max(120),
-		description: z.string().trim().min(1).max(2e3),
-		goalMode: z.enum(["finite", "ongoing"]),
-		contextProviders: uniqueIds,
-		triggers: z.array(z.discriminatedUnion("type", [
-			z.strictObject({
-				id: identifier,
-				type: z.literal("manual")
-			}),
-			z.strictObject({
-				id: identifier,
-				type: z.literal("event"),
-				eventType: identifier
-			}),
-			z.strictObject({
-				id: identifier,
-				type: z.literal("schedule")
-			})
-		])).min(1).max(20).refine((items) => new Set(items.map((item) => item.id)).size === items.length, "Duplicate trigger IDs"),
-		execution: executionSchema,
-		allowedOutcomeKinds: z.array(z.enum(sceneOutcomeKinds)).min(1),
-		allowedEffectHandlers: uniqueIds
-	});
-	scenePermissionSchema = z.strictObject({
-		accountIds: uniqueIds,
-		contextProviders: uniqueIds,
-		effectHandlers: uniqueIds
-	});
-	sceneNotesSchema = z.strictObject({
-		expectedRevision: z.number().int().nonnegative(),
-		content: z.string().trim().max(32e3),
-		validUntil: z.number().int().nonnegative().nullable().default(null)
-	});
-	activationInputSchema = z.strictObject({
-		templateKey: identifier,
-		templateVersion: identifier,
-		goal: z.string().trim().min(1).max(12e3),
-		scope: sceneScopeSchema,
-		permissions: scenePermissionSchema
-	});
-	SceneActivationSchema = activationInputSchema.extend({
-		id: identifier,
-		ownerId: identifier,
-		workspaceId: z.string().min(1),
-		status: z.enum(activationStatuses),
-		setupMissing: z.array(z.string()).optional(),
-		revision: z.number().int().positive()
-	});
-	SceneConfigureSchema = activationInputSchema.pick({
-		goal: true,
-		scope: true,
-		permissions: true
-	}).extend({ expectedRevision: z.number().int().positive() });
-	SceneTransitionSchema = z.strictObject({
-		expectedRevision: z.number().int().positive(),
-		status: z.enum(activationStatuses)
-	});
-	SceneWorkItemCreateSchema = z.strictObject({
-		subjectId: identifier,
-		accountId: identifier,
-		dueAt: z.number().int().nonnegative()
-	});
-	SceneWorkItemUpdateSchema = z.strictObject({
-		expectedRevision: z.number().int().positive(),
-		dueAt: z.number().int().nonnegative().optional(),
-		status: z.enum([
-			"watching",
-			"paused",
-			"completed"
-		]).optional()
-	}).refine((value) => value.dueAt !== void 0 || value.status !== void 0, "Work item update is empty");
-	SceneWorkItemSchema = SceneWorkItemCreateSchema.extend({
-		id: identifier,
-		activationId: identifier,
-		revision: z.number().int().positive(),
-		status: z.enum([
-			"watching",
-			"paused",
-			"completed"
-		])
-	});
-	hour = z.number().int().min(0).max(23);
-	scenePreferencesSchema = z.strictObject({
-		level: z.enum([
-			"quiet",
-			"balanced",
-			"active"
-		]).default("balanced"),
-		timezone: z.string().min(1).max(100).refine((value) => {
-			try {
-				new Intl.DateTimeFormat("en", { timeZone: value });
-				return true;
-			} catch {
-				return false;
-			}
-		}).default("Asia/Shanghai"),
-		quietStartHour: hour.default(22),
-		quietEndHour: hour.default(8),
-		dailyNotificationLimit: z.number().int().min(0).max(30).default(3),
-		digestEnabled: z.boolean().default(false),
-		digestHour: hour.default(18),
-		digestMinute: z.number().int().min(0).max(59).default(0),
-		preferredChannel: z.enum(["in_app", "browser"]).default("browser"),
-		suppressWhileViewing: z.boolean().default(true),
-		checksPaused: z.boolean().default(false),
-		checksPausedUntil: z.string().datetime({ offset: true }).nullable().default(null),
-		notificationsMuted: z.boolean().default(false)
-	});
-	preferenceFields = scenePreferencesSchema.shape;
-	ScenePreferencePatchSchema = z.strictObject({
-		expectedRevision: z.number().int().nonnegative(),
-		level: preferenceFields.level.removeDefault().optional(),
-		timezone: preferenceFields.timezone.removeDefault().optional(),
-		quietStartHour: preferenceFields.quietStartHour.removeDefault().optional(),
-		quietEndHour: preferenceFields.quietEndHour.removeDefault().optional(),
-		dailyNotificationLimit: preferenceFields.dailyNotificationLimit.removeDefault().optional(),
-		digestEnabled: preferenceFields.digestEnabled.removeDefault().optional(),
-		digestHour: preferenceFields.digestHour.removeDefault().optional(),
-		digestMinute: preferenceFields.digestMinute.removeDefault().optional(),
-		preferredChannel: preferenceFields.preferredChannel.removeDefault().optional(),
-		suppressWhileViewing: preferenceFields.suppressWhileViewing.removeDefault().optional(),
-		checksPaused: preferenceFields.checksPaused.removeDefault().optional(),
-		checksPausedUntil: preferenceFields.checksPausedUntil.removeDefault().optional(),
-		notificationsMuted: preferenceFields.notificationsMuted.removeDefault().optional()
-	});
-	SceneFeedbackSchema = z.strictObject({
-		expectedRevision: z.number().int().nonnegative(),
-		rating: z.enum(["useful", "not_useful"]),
-		note: z.string().trim().max(2e3).optional()
-	});
-	sceneScheduleSchema = z.strictObject({
-		weekdays: z.array(z.number().int().min(0).max(6)).min(1).max(7).refine((days) => new Set(days).size === days.length, "Duplicate weekdays"),
-		hour: z.number().int().min(0).max(23),
-		minute: z.number().int().min(0).max(59),
-		timeZone: z.string().trim().min(1).max(100).refine((timeZone) => {
-			try {
-				new Intl.DateTimeFormat("en", { timeZone });
-				return true;
-			} catch {
-				return false;
-			}
-		}, "Invalid time zone")
-	});
-}));
-//#endregion
-init_scenes();
-export { SceneActivationSchema, SceneConfigureSchema, SceneFeedbackSchema, ScenePreferencePatchSchema, SceneTransitionSchema, SceneWorkItemCreateSchema, SceneWorkItemSchema, SceneWorkItemUpdateSchema, activationInputSchema, activationStatuses, init_scenes, sceneNotesSchema, sceneOutcomeKinds, scenePermissionSchema, scenePreferencesSchema, sceneScheduleSchema, sceneScopeSchema, sceneTemplateSchema };

package/dist/src/agent/bootstrap/project-agents-context.d.ts

@@ -1,2 +0,0 @@
-import type { EmbeddedContextFile } from './types.js';
-export declare function loadProjectAgentsContextFile(workspaceDir: string): EmbeddedContextFile | null;

package/dist/src/agent/bootstrap/project-agents-context.js

@@ -1,30 +0,0 @@
-import { DEFAULT_AGENTS_FILENAME, stripFrontMatter } from "../context/workspace.js";
-import { join, resolve } from "node:path";
-import { existsSync, readFileSync } from "node:fs";
-//#region src/agent/bootstrap/project-agents-context.ts
-const PROJECT_AGENTS_MAX_CHARS = 2e4;
-function truncateProjectAgentsContent(content) {
-	if (content.length <= PROJECT_AGENTS_MAX_CHARS) return content;
-	const suffix = `\n\n[Project AGENTS.md truncated to ${PROJECT_AGENTS_MAX_CHARS} characters]`;
-	return `${content.slice(0, Math.max(0, PROJECT_AGENTS_MAX_CHARS - suffix.length)).trimEnd()}${suffix}`;
-}
-function loadProjectAgentsContextFile(workspaceDir) {
-	const agentsPath = resolve(join(workspaceDir, DEFAULT_AGENTS_FILENAME));
-	if (!existsSync(agentsPath)) return null;
-	try {
-		const content = truncateProjectAgentsContent(stripFrontMatter(readFileSync(agentsPath, "utf-8")).trim());
-		if (!content) return null;
-		return {
-			path: agentsPath,
-			content: [
-				"Workspace AGENTS.md contains project-local instructions. Follow it for this workspace's coding conventions, commands, tests, and repository-specific workflows. If it conflicts with higher-priority system instructions, tool safety, or the user's explicit request, follow the higher-priority instruction.",
-				"",
-				content
-			].join("\n")
-		};
-	} catch {
-		return null;
-	}
-}
-//#endregion
-export { loadProjectAgentsContextFile };

package/dist/src/gateway/hono/routes/scenes.d.ts

@@ -1,3 +0,0 @@
-import { Hono } from 'hono';
-import type { AuthenticatedRouteDeps } from './deps.js';
-export declare function registerSceneRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/scenes.js

@@ -1,271 +0,0 @@
-import { createLogger } from "../../../utils/logger/index.js";
-import { init_logger } from "../../../utils/logger.js";
-import { ProductReadContracts } from "../../../../packages/gateway-contract/src/capabilities.js";
-import { init_src } from "../../../../packages/gateway-contract/src/index.js";
-import { CapabilityError } from "../../../capabilities/runtime/errors.js";
-import "../../../capabilities/runtime/dispatcher.js";
-import { SceneConflictError, SceneInputError, SceneNotFoundError } from "../../../scenes/repository.js";
-import { SceneSetupError } from "../../../scenes/service.js";
-import { createProductDispatcher } from "../../../capabilities/runtime/product.js";
-import { getGatewayPrincipal } from "../../security/gateway-principal.js";
-import { capabilityHttpContext, capabilityHttpError } from "../../../capabilities/adapters/http.js";
-import { randomUUID } from "node:crypto";
-import { z } from "zod";
-import { Hono } from "hono";
-//#region src/gateway/hono/routes/scenes.ts
-init_src();
-init_logger();
-const log = createLogger("Hono:Scenes");
-const requestIdentity = z.string().trim().min(1).max(200);
-function registerSceneRoutes(authenticated, deps) {
-	const app = new Hono();
-	app.onError((error, c) => {
-		if (error instanceof CapabilityError && error.cause instanceof SceneSetupError) return c.json({
-			error: "scene_needs_setup",
-			message: error.cause.message,
-			missing: error.cause.missing
-		}, 422);
-		if (error instanceof CapabilityError) return capabilityHttpError(c, error);
-		if (error instanceof SceneNotFoundError) return c.json({ error: "scene_not_found" }, 404);
-		if (error instanceof SceneConflictError) return c.json({
-			error: "scene_changed",
-			message: error.message
-		}, 409);
-		if (error instanceof SceneSetupError) return c.json({
-			error: "scene_needs_setup",
-			message: error.message,
-			missing: error.missing
-		}, 422);
-		if (error instanceof z.ZodError || error instanceof SyntaxError || error instanceof SceneInputError) return c.json({ error: "invalid_scene_input" }, 400);
-		log.error({
-			err: error,
-			phase: "scene_request"
-		}, "Scene request failed");
-		return c.json({ error: "scene_request_failed" }, 500);
-	});
-	app.use("*", async (c, next) => {
-		if (!deps.scenes) return c.json({ error: "scene_runtime_not_installed" }, 503);
-		await next();
-	});
-	const principal = (c) => ({
-		ownerId: getGatewayPrincipal(c).scopes.includes("gateway.admin") ? "local-owner" : getGatewayPrincipal(c).principalId,
-		workspaceId: deps.service.currentWorkspacePath
-	});
-	const capabilities = createProductDispatcher(void 0, { getSceneAccess: () => deps.scenes ? {
-		services: deps.scenes,
-		principal: {
-			ownerId: "local-owner",
-			workspaceId: deps.service.currentWorkspacePath
-		}
-	} : void 0 });
-	const read = async (c, operation, input) => ProductReadContracts[operation].output.parse(await capabilities.call(operation, input, capabilityHttpContext(c)));
-	const write = (c, operation, input) => {
-		const context = capabilityHttpContext(c);
-		return capabilities.call(operation, input, context, {
-			...capabilities.describe(operation, context),
-			idempotencyKey: c.req.header("Idempotency-Key") ?? randomUUID()
-		});
-	};
-	const template = (key, version) => deps.scenes.repository.getTemplate(key, version);
-	const adapterTarget = (key, version) => {
-		const manifest = template(key, version);
-		return manifest.execution.kind === "agent" ? void 0 : {
-			manifest,
-			adapter: deps.scenes.activationAdapters.get(manifest.execution.kind)
-		};
-	};
-	app.get("/source-providers", (c) => c.json({ providers: deps.scenes.sourceProviders.providers() }));
-	app.get("/source-providers/:provider/accounts", (c) => c.json({ accounts: deps.scenes.sourceProviders.get(c.req.param("provider")).listAccounts?.(principal(c)) ?? [] }));
-	app.post("/source-providers/:provider/resolve-link", deps.strictRateLimitMiddleware, async (c) => {
-		const input = z.strictObject({
-			accountId: z.string().min(1).max(200),
-			url: z.string().url().max(2e3)
-		}).parse(await c.req.json());
-		const source = deps.scenes.sourceProviders.get(c.req.param("provider"));
-		if (!source?.resolveLink) return c.json({ error: "source_resolution_unavailable" }, 422);
-		const reference = await source.resolveLink(principal(c), input.accountId, input.url, AbortSignal.any([c.req.raw.signal, AbortSignal.timeout(3e4)]));
-		return c.json({ source: {
-			provider: source.id,
-			reference
-		} });
-	});
-	app.get("/resources/projects/:projectId/branches", async (c) => {
-		const owner = deps.scenes.activationAdapters.list().find((item) => item.listProjectBranches);
-		if (!owner?.listProjectBranches) return c.json({ error: "branch_inventory_unavailable" }, 503);
-		return c.json(await owner.listProjectBranches(principal(c), c.req.param("projectId")));
-	});
-	app.post("/resources/branch-links", deps.strictRateLimitMiddleware, async (c) => {
-		const input = z.strictObject({
-			projectId: z.string().min(1).max(200),
-			taskId: z.string().uuid(),
-			branchRef: z.string().startsWith("refs/heads/").max(300),
-			expectedSha: z.string().regex(/^[a-f0-9]{40,64}$/)
-		}).parse(await c.req.json());
-		const owner = deps.scenes.activationAdapters.list().find((item) => item.associateBranch);
-		if (!owner?.associateBranch) return c.json({ error: "branch_inventory_unavailable" }, 503);
-		return c.json(await owner.associateBranch(principal(c), input));
-	});
-	app.post("/browser/prepare", deps.strictRateLimitMiddleware, (c) => c.json(deps.scenes.browser.prepare()));
-	app.post("/browser/subscriptions", deps.strictRateLimitMiddleware, async (c) => c.json(deps.scenes.browser.register(principal(c), await c.req.json()), 201));
-	app.delete("/browser/subscriptions/:id", deps.strictRateLimitMiddleware, (c) => {
-		deps.scenes.browser.remove(principal(c), c.req.param("id"));
-		return c.json({ ok: true });
-	});
-	app.get("/preferences", async (c) => c.json(await read(c, "xopc.scenes.get_preferences", {})));
-	app.patch("/preferences", deps.strictRateLimitMiddleware, async (c) => c.json(await write(c, "xopc.scenes.set_preferences", await c.req.json())));
-	app.post("/presence", deps.strictRateLimitMiddleware, async (c) => {
-		deps.scenes.preferences.recordPresence(principal(c), await c.req.json());
-		return c.json({ ok: true });
-	});
-	app.get("/templates", async (c) => c.json(await read(c, "xopc.scenes.templates", {})));
-	app.get("/diagnostics", async (c) => c.json(await read(c, "xopc.scenes.diagnostics", {})));
-	app.get("/metrics", async (c) => {
-		return c.json(await read(c, "xopc.scenes.metrics", {
-			...c.req.query(),
-			...c.req.query("days") === void 0 ? {} : { days: Number(c.req.query("days")) }
-		}));
-	});
-	app.get("/sources/mail/accounts", async (c) => c.json(await read(c, "xopc.scenes.mail_accounts", {})));
-	app.post("/sources/mail/search", deps.strictRateLimitMiddleware, async (c) => {
-		if (!deps.scenes.mailDiscovery) return c.json({ error: "mail_search_unavailable" }, 503);
-		const signal = AbortSignal.any([c.req.raw.signal, AbortSignal.timeout(15e3)]);
-		return c.json({ sources: await deps.scenes.mailDiscovery.searchSources(principal(c), await c.req.json(), signal) });
-	});
-	app.get("/sources/mail", async (c) => {
-		return c.json(await read(c, "xopc.scenes.mail_sources", {
-			...c.req.query(),
-			...c.req.query("limit") === void 0 ? {} : { limit: Number(c.req.query("limit")) }
-		}));
-	});
-	app.get("/templates/:key/versions/:version", async (c) => c.json(await read(c, "xopc.scenes.get_template", {
-		key: c.req.param("key"),
-		version: c.req.param("version")
-	})));
-	app.post("/preflight", deps.strictRateLimitMiddleware, async (c) => {
-		const body = await c.req.json();
-		if (typeof body.templateKey === "string" && typeof body.templateVersion === "string") {
-			const target = adapterTarget(body.templateKey, body.templateVersion);
-			if (target) return c.json(await target.adapter.preflight(principal(c), target.manifest, body.configuration));
-		}
-		return c.json(await read(c, "xopc.scenes.preflight", body));
-	});
-	app.get("/activations", async (c) => {
-		return c.json(await read(c, "xopc.scenes.list", {
-			...c.req.query(),
-			...c.req.query("limit") === void 0 ? {} : { limit: Number(c.req.query("limit")) }
-		}));
-	});
-	app.post("/activations", deps.strictRateLimitMiddleware, async (c) => {
-		requestIdentity.parse(c.req.header("Idempotency-Key"));
-		const body = await c.req.json();
-		if (typeof body.templateKey === "string" && typeof body.templateVersion === "string") {
-			const target = adapterTarget(body.templateKey, body.templateVersion);
-			if (target) return c.json(await target.adapter.create(principal(c), target.manifest, body.configuration), 201);
-		}
-		return c.json(await write(c, "xopc.scenes.start", body), 201);
-	});
-	app.get("/activations/:id", async (c) => {
-		const { activation } = ProductReadContracts["xopc.scenes.get"].output.parse(await read(c, "xopc.scenes.get", { id: c.req.param("id") }));
-		const manifest = template(activation.templateKey, activation.templateVersion);
-		const activationAdapter = manifest.execution.kind === "agent" ? void 0 : deps.scenes.activationAdapters.get(manifest.execution.kind);
-		return c.json({
-			activation,
-			template: manifest,
-			...activationAdapter ? { details: activationAdapter.get(principal(c), activation.id) } : {}
-		});
-	});
-	app.patch("/activations/:id", deps.strictRateLimitMiddleware, async (c) => {
-		const body = await c.req.json();
-		const activation = deps.scenes.repository.getActivation(principal(c), c.req.param("id"));
-		const manifest = template(activation.templateKey, activation.templateVersion);
-		if (manifest.execution.kind !== "agent") {
-			const input = z.union([z.strictObject({
-				expectedRevision: z.number().int().positive(),
-				status: z.enum([
-					"active",
-					"paused",
-					"archived"
-				])
-			}), z.strictObject({
-				expectedRevision: z.number().int().positive(),
-				configuration: z.unknown()
-			})]).parse(body);
-			const execution = deps.scenes.activationAdapters.get(manifest.execution.kind);
-			return c.json("configuration" in input ? await execution.configure(principal(c), activation.id, input.expectedRevision, input.configuration) : await execution.transition(principal(c), activation.id, input.expectedRevision, input.status));
-		}
-		if (!(typeof body === "object" && body !== null && Object.hasOwn(body, "status"))) return c.json(await write(c, "xopc.scenes.configure", {
-			...body,
-			id: c.req.param("id")
-		}));
-		return c.json(await write(c, "xopc.scenes.transition", {
-			...body,
-			id: c.req.param("id")
-		}));
-	});
-	app.post("/activations/:id/checks", deps.strictRateLimitMiddleware, async (c) => {
-		requestIdentity.parse(c.req.header("Idempotency-Key"));
-		return c.json(await write(c, "xopc.scenes.check", { id: c.req.param("id") }), 202);
-	});
-	app.get("/activations/:id/runs", async (c) => {
-		return c.json(await read(c, "xopc.scenes.list_runs", {
-			...c.req.query(),
-			id: c.req.param("id"),
-			...c.req.query("limit") === void 0 ? {} : { limit: Number(c.req.query("limit")) }
-		}));
-	});
-	app.patch("/activations/:id/notes", deps.strictRateLimitMiddleware, async (c) => c.json(await write(c, "xopc.scenes.notes", {
-		...await c.req.json(),
-		id: c.req.param("id")
-	})));
-	app.get("/activations/:id/notes", async (c) => c.json(await read(c, "xopc.scenes.read_notes", { id: c.req.param("id") })));
-	app.get("/activations/:id/work-items", async (c) => {
-		return c.json(await read(c, "xopc.scenes.list_work_items", {
-			...c.req.query(),
-			id: c.req.param("id"),
-			...c.req.query("limit") === void 0 ? {} : { limit: Number(c.req.query("limit")) }
-		}));
-	});
-	app.post("/activations/:id/work-items", deps.strictRateLimitMiddleware, async (c) => c.json(await write(c, "xopc.scenes.work_item", {
-		...await c.req.json(),
-		id: c.req.param("id")
-	}), 201));
-	app.get("/activations/:id/schedules", async (c) => c.json(await read(c, "xopc.scenes.list_schedules", { id: c.req.param("id") })));
-	app.patch("/activations/:id/schedules/:triggerKey", deps.strictRateLimitMiddleware, async (c) => c.json(await write(c, "xopc.scenes.schedule", {
-		...await c.req.json(),
-		id: c.req.param("id"),
-		triggerKey: c.req.param("triggerKey")
-	})));
-	app.patch("/work-items/:id", deps.strictRateLimitMiddleware, async (c) => c.json(await write(c, "xopc.scenes.update_work_item", {
-		...await c.req.json(),
-		id: c.req.param("id")
-	})));
-	app.get("/outcomes", async (c) => {
-		return c.json(await read(c, "xopc.scenes.results", {
-			...c.req.query(),
-			...c.req.query("limit") === void 0 ? {} : { limit: Number(c.req.query("limit")) }
-		}));
-	});
-	app.get("/digests/:id", async (c) => {
-		return c.json(await read(c, "xopc.scenes.digest_results", {
-			...c.req.query(),
-			id: c.req.param("id"),
-			...c.req.query("limit") === void 0 ? {} : { limit: Number(c.req.query("limit")) }
-		}));
-	});
-	app.get("/presentations/:id/feedback", async (c) => c.json(await read(c, "xopc.scenes.get_feedback", { id: c.req.param("id") })));
-	app.get("/presentations/:id", async (c) => c.json(await read(c, "xopc.scenes.get_presentation", { id: c.req.param("id") })));
-	app.post("/presentations/:id/feedback", deps.strictRateLimitMiddleware, async (c) => c.json(await write(c, "xopc.scenes.feedback", {
-		...await c.req.json(),
-		id: c.req.param("id")
-	})));
-	app.patch("/presentations/:id", deps.strictRateLimitMiddleware, async (c) => {
-		await write(c, "xopc.scenes.mark_read", {
-			...await c.req.json(),
-			id: c.req.param("id")
-		});
-		return c.json({ ok: true });
-	});
-	authenticated.route("/api/scenes", app);
-}
-//#endregion
-export { registerSceneRoutes };

package/dist/src/gateway/scenes/browserNotifications.d.ts

@@ -1,4 +0,0 @@
-import type { DatabaseSync } from 'node:sqlite';
-import { NotificationDispatcher } from '../../notifications/dispatch.js';
-import { type SceneActivation, type ScenePermission } from '../../scenes/contracts.js';
-export declare function createSceneBrowserDispatcher(db: DatabaseSync, authorize: (activation: SceneActivation) => ScenePermission, clock?: () => number): NotificationDispatcher;

package/dist/src/gateway/scenes/browserNotifications.js

@@ -1,54 +0,0 @@
-import { intersectPermissions, sceneContentHash } from "../../scenes/contracts.js";
-import { SceneRepository } from "../../scenes/repository.js";
-import { ScenePreferenceService, sceneChecksAllowed } from "../../scenes/preferences.js";
-import { notificationQuietUntil } from "../../notifications/quietHours.js";
-import { sceneNotificationEligibility } from "../../scenes/notificationEligibility.js";
-import { createBrowserNotificationTransport } from "../../notifications/browserTransport.js";
-import { NotificationDispatcher } from "../../notifications/dispatch.js";
-//#region src/gateway/scenes/browserNotifications.ts
-function createSceneBrowserDispatcher(db, authorize, clock = Date.now) {
-	const repository = new SceneRepository(db);
-	const members = (dispatch) => dispatch.subjectId ? [{
-		subject_id: dispatch.subjectId,
-		subject_revision: dispatch.subjectRevision
-	}] : db.prepare(`SELECT m.subject_id, m.subject_revision FROM notification_digest_members m
-        JOIN notification_digests d ON d.id = m.digest_id
-        WHERE d.notification_id = ? AND d.owner_id = ? AND d.workspace_id = ?`).all(dispatch.notificationId, dispatch.ownerId, dispatch.workspaceId);
-	const eligible = (dispatch, subject) => {
-		const result = sceneNotificationEligibility(db, {
-			...dispatch,
-			subjectId: String(subject.subject_id)
-		}, clock(), Number(subject.subject_revision));
-		if (result.action !== "eligible") return null;
-		const activation = repository.getActivation(dispatch, result.activationId);
-		if (sceneContentHash(intersectPermissions(activation.permissions, authorize(activation))) !== sceneContentHash(intersectPermissions(activation.permissions))) return null;
-		return result;
-	};
-	return new NotificationDispatcher(db, {
-		clock,
-		send: createBrowserNotificationTransport(db, {
-			clock,
-			route: (dispatch) => {
-				if (!dispatch.subjectId) return "/scenes/inbox";
-				const result = eligible(dispatch, {
-					subject_id: dispatch.subjectId,
-					subject_revision: dispatch.subjectRevision
-				});
-				return result ? `/scenes/${encodeURIComponent(result.activationId)}?result=${encodeURIComponent(result.presentationId)}` : null;
-			}
-		}),
-		authorize: async (dispatch) => {
-			const policy = new ScenePreferenceService(db).get(dispatch);
-			if (!sceneChecksAllowed(policy, clock()) || policy.notificationsMuted || policy.level === "quiet" || policy.preferredChannel !== "browser") return { action: "cancel" };
-			if (!members(dispatch).filter((subject) => eligible(dispatch, subject)).filter((subject) => !policy.suppressWhileViewing || !db.prepare(`SELECT 1 FROM notification_presence WHERE owner_id = ? AND workspace_id = ?
-        AND subject_id = ? AND subject_revision = ? AND expires_at > ?`).get(dispatch.ownerId, dispatch.workspaceId, subject.subject_id, subject.subject_revision, clock())).length) return { action: "cancel" };
-			const until = notificationQuietUntil(policy, clock());
-			return until === null ? { action: "send" } : {
-				action: "defer",
-				until
-			};
-		}
-	});
-}
-//#endregion
-export { createSceneBrowserDispatcher };

package/dist/src/gateway/scenes/host.d.ts

@@ -1,34 +0,0 @@
-import type { DatabaseSync } from 'node:sqlite';
-import type { ProductNotification } from '@xopcai/gateway-contract';
-import type { Config } from '../../config/schema.js';
-import type { ScenePrincipal } from '../../scenes/contracts.js';
-import { type SceneReadOnlyExecutor } from '../../scenes/execution.js';
-import type { SceneHttpServices } from '../../scenes/httpServices.js';
-import type { SceneMailContextProvider } from '../../scenes/mailContext.js';
-/** Composition root for the initialized database. Never creates tables or starts an old worker. */
-export declare class GatewaySceneHost {
-    private readonly db;
-    readonly http: SceneHttpServices;
-    private readonly runtime;
-    private readonly notifications;
-    private readonly browserDispatcher;
-    private timer?;
-    private active?;
-    private stopped;
-    private nextMaintenanceAt;
-    private readonly clock;
-    constructor(db: DatabaseSync, input: {
-        principal: ScenePrincipal;
-        config: () => Config;
-        publish: (type: 'notification.created', notification: ProductNotification) => void;
-        executor?: SceneReadOnlyExecutor;
-        mail?: SceneMailContextProvider;
-        clock?: () => number;
-        intervalMs?: number;
-    });
-    private readonly intervalMs;
-    start(): void;
-    tick(): Promise<void>;
-    /** Must finish before the Gateway closes SQLite or its realtime broker. */
-    stop(): Promise<void>;
-}