@selvajs/selva 4.20.0-beta.1 → 4.20.0-beta.10

package/build/server/chunks/chunks/access.js-BataxwA1.js

@@ -0,0 +1,812 @@
+import { A as ALL_PLATFORM_PERMISSIONS, a as ALL_ORG_PERMISSIONS, h as hasPermission, o as outsideTokenOrg } from './src.js-CkFJvvTE.js';
+
+//#region ../platform/src/access/rules.ts
+/**
+* Pure access-control rules — single source of truth for UI gating across
+* adapters. Mutating store methods MUST re-enforce the same predicate
+* independently (RLS in SQL, code in local/JSON).
+*
+* `instance_admin` bypass is not baked into rule bodies — wrap calls with
+* `withAdminBypass` at the call site.
+*/
+function isInstanceAdmin(platformPermissions) {
+	return platformPermissions.includes("instance_admin");
+}
+function withAdminBypass(platformPermissions, rule) {
+	if (isInstanceAdmin(platformPermissions)) return true;
+	return rule();
+}
+/**
+* Authenticated-user view rule. Anonymous access goes through share-link
+* tokens instead — the route resolves a valid token before this runs.
+*
+* Platform projects: `instance_admin` always passes; otherwise any grant
+* (view-only or canSolve) satisfies view access.
+*/
+function canView(input) {
+	const { project, member, orgMember, allowCrossOrgPublic, enablePlatformProjects, platformPermissions, platformGrants, actingOrgId, userId } = input;
+	if (!project) return false;
+	if (project.visibility === "platform") {
+		if (!enablePlatformProjects) return false;
+		if (isInstanceAdmin(platformPermissions)) return true;
+		return platformGrants.some((g) => g.granteeType === "user" && g.granteeId === userId || g.granteeType === "org" && g.granteeId === actingOrgId);
+	}
+	if (project.visibility === "private") return member !== null;
+	if (project.visibility === "org") return orgMember !== null;
+	if (project.visibility === "public") return allowCrossOrgPublic ? true : orgMember !== null;
+	return false;
+}
+/**
+* Non-platform projects: same as `canView` — kept as a separate function so
+* cost gating can diverge from view access later.
+*
+* Platform projects: `instance_admin` always passes; a view-only grant
+* satisfies `canView` but not `canSolve` — the grant needs `canSolve: true`.
+*/
+function canSolve(input) {
+	const { project, enablePlatformProjects, platformPermissions, platformGrants, actingOrgId, userId } = input;
+	if (!project) return false;
+	if (project.visibility === "platform") {
+		if (!enablePlatformProjects) return false;
+		if (isInstanceAdmin(platformPermissions)) return true;
+		return platformGrants.some((g) => g.canSolve && (g.granteeType === "user" && g.granteeId === userId || g.granteeType === "org" && g.granteeId === actingOrgId));
+	}
+	return canView(input);
+}
+/**
+* Platform projects: `instance_admin` only (they have no member rows).
+* All other visibilities: project owner/editor.
+*/
+function canEdit(input) {
+	const { member, project, enablePlatformProjects, platformPermissions } = input;
+	if (project?.visibility === "platform") {
+		if (!enablePlatformProjects) return false;
+		return isInstanceAdmin(platformPermissions);
+	}
+	return member?.role === "owner" || member?.role === "editor";
+}
+/**
+* Adding a new definition. Commons projects (`autoJoinOnUpload`) take uploads
+* from anyone who reaches them, and the uploader owns what they upload;
+* everywhere else it needs {@link canEdit}.
+*/
+function canCreateDefinition(input) {
+	return input.project?.autoJoinOnUpload === true || canEdit(input);
+}
+/** Platform projects: `instance_admin` only. All other visibilities: project owner. */
+function canManage(input) {
+	if (input.project?.visibility === "platform") {
+		if (!input.enablePlatformProjects) return false;
+		return isInstanceAdmin(input.platformPermissions);
+	}
+	return input.member?.role === "owner";
+}
+/** Platform projects: `instance_admin` only. All other visibilities: project owner. */
+function canEditProjectSettings(input) {
+	if (input.project?.visibility === "platform") {
+		if (!input.enablePlatformProjects) return false;
+		return isInstanceAdmin(input.platformPermissions);
+	}
+	return input.member?.role === "owner";
+}
+/**
+* Authorization to flip a project to `public`. The `ALLOW_CROSS_ORG_PUBLIC`
+* flag only changes what `public` means post-flip; the flip itself is gated
+* by org owner/admin role.
+*/
+function canChangeVisibilityToPublic(input) {
+	const role = input.orgMember?.role;
+	return role === "owner" || role === "admin";
+}
+/**
+* For platform projects: `instance_admin` only.
+* For all other projects: project editor/owner can always edit (moderation).
+* On commons projects (`autoJoinOnUpload=true`) the definition owner can edit
+* their own, as long as they still belong to the project's org.
+*/
+function canEditDefinition(input) {
+	const { project, definition, member, orgMember, userId, platformPermissions, enablePlatformProjects } = input;
+	if (!project || !definition) return false;
+	if (project.visibility === "platform") {
+		if (!enablePlatformProjects) return false;
+		return isInstanceAdmin(platformPermissions);
+	}
+	if (member?.role === "owner" || member?.role === "editor") return true;
+	if (project.autoJoinOnUpload && userId === definition.ownerId && orgMember) return true;
+	return false;
+}
+/**
+* Org leadership escape hatch: adds the actor as co-owner without demoting
+* the existing owner. Tenancy must match.
+*
+* Platform projects can't be reclaimed — `instance_admin` already has
+* management access to them.
+*/
+function canReclaim(input) {
+	const { project, orgMember, actingOrgId } = input;
+	if (!project || !actingOrgId) return false;
+	if (project.visibility === "platform") return false;
+	if (actingOrgId !== project.orgId) return false;
+	const role = orgMember?.role;
+	return role === "owner" || role === "admin";
+}
+/**
+* Owner/admin can always create; a `member` needs `manage_projects` org
+* permission. Tenancy is enforced.
+*
+* Platform projects (`visibility: 'platform'`) go through the admin API,
+* gated on `instance_admin` — this rule isn't consulted for them.
+*/
+function canCreateProject(input) {
+	const { orgMember, orgPermissions, actingOrgId, targetOrgId } = input;
+	if (actingOrgId !== targetOrgId) return false;
+	const role = orgMember?.role;
+	if (role === "owner" || role === "admin") return true;
+	if (role === "member" && orgPermissions.includes("manage_projects")) return true;
+	return false;
+}
+/**
+* Whether the actor may hand out or take away org `owner`/`admin` standing (§3).
+*
+* Three routes decide this — inviting someone as owner/admin, changing an
+* existing member's role, and removing an owner — and all three had written it
+* out longhand. Two of them had drifted by the time the access audit found
+* them: the invite route let an admin mint an `owner` invite for themselves,
+* and DELETE let an admin remove an owner that PATCH would not let them demote.
+* They are one rule, so they read it from one place.
+*
+* Reads the actor's **membership row**. `Organization.ownerId` is a separate
+* field that can disagree with it — see the sole-`instance_admin` finding — and
+* is not authority for this decision.
+*/
+function canChangeOrgRole(input) {
+	if (input.role === "member") return true;
+	return input.actorMember?.role === "owner";
+}
+function checkOwnerRemoval(input) {
+	if (input.target.role !== "owner") return "ok";
+	if (input.allMembers.filter((m) => m.role === "owner").length <= 1) return "sole_owner";
+	if (!input.confirmed) return "needs_confirm";
+	return "ok";
+}
+//#endregion
+//#region ../platform/src/logging/interface.ts
+/**
+* Default `ILogger` — discards everything. Lets library code log
+* unconditionally without a configured backend, and keeps test output clean.
+* The app wires a real logger at its composition root; a consumer that wires
+* nothing gets silence rather than unsolicited stdout writes.
+*/
+var NoopLogger = class {
+	debug(_message, _fields) {}
+	info(_message, _fields) {}
+	warn(_message, _fields) {}
+	error(_message, _fields) {}
+	child(_fields) {
+		return this;
+	}
+};
+//#endregion
+//#region ../platform/src/config.ts
+function isFlagEnabled(config, flag) {
+	return Boolean(config.flags?.[flag]);
+}
+//#endregion
+//#region ../server/src/compute/limits.ts
+/**
+* Compute/solve server limits, resolved from an injected env map.
+*
+* Env comes in as a parameter — nothing ambient is read — so this is importable
+* from any runtime and testable without env plumbing. Defaults are sized for
+* typical interactive use (sliders + small uploads).
+*
+* Client-side counterparts (the in-flight compute throttle and slider debounce)
+* are bundled into the client in `@selvajs/ui` and can't read env — they carry
+* their own defaults.
+*/
+var MB = 1048576;
+/**
+* Default logger for the env-parsing warnings below. This is library code, so an
+* embedder that wires nothing gets silence rather than unsolicited stdout writes.
+*/
+var noop = new NoopLogger();
+/** Parse a positive integer env value; absent, or present but not finite and positive, falls back. */
+function readPositiveInt(env, name, fallback, logger = noop) {
+	const raw = env[name];
+	if (!raw) return fallback;
+	const parsed = Number(raw);
+	if (!Number.isFinite(parsed) || parsed <= 0) {
+		logger.warn("Invalid env value, falling back to default", {
+			component: "selva",
+			envVar: name,
+			value: raw,
+			fallback
+		});
+		return fallback;
+	}
+	return Math.floor(parsed);
+}
+/** Like {@link readPositiveInt}, but `0` is valid — knobs where it means "disable". */
+function readNonNegativeInt(env, name, fallback, logger = noop) {
+	const raw = env[name];
+	if (!raw) return fallback;
+	const parsed = Number(raw);
+	if (!Number.isFinite(parsed) || parsed < 0) {
+		logger.warn("Invalid env value, falling back to default", {
+			component: "selva",
+			envVar: name,
+			value: raw,
+			fallback
+		});
+		return fallback;
+	}
+	return Math.floor(parsed);
+}
+/**
+* Fall back to a variable's previous name, warning when the old one is used.
+* Setting both is not an error: the new name wins silently, which is what an
+* operator mid-migration expects.
+*
+* A var that quietly stops being read looks exactly like one that is working —
+* the failure only surfaces as a memory number nobody is watching.
+*/
+function readRenamed(env, name, oldName, logger) {
+	if (env[name] !== void 0 || env[oldName] === void 0) return env;
+	logger.warn("Deprecated env var: rename it", {
+		component: "selva",
+		envVar: oldName,
+		renamedTo: name
+	});
+	return {
+		...env,
+		[name]: env[oldName]
+	};
+}
+/**
+* Parse a boolean env flag. Accepts `true/1/yes/on` and `false/0/no/off`
+* (case-insensitive); any other spelling warns and falls back.
+*/
+function readBool(env, name, fallback, logger = noop) {
+	const raw = env[name];
+	if (raw == null || raw === "") return fallback;
+	const v = raw.trim().toLowerCase();
+	if (v === "true" || v === "1" || v === "yes" || v === "on") return true;
+	if (v === "false" || v === "0" || v === "no" || v === "off") return false;
+	logger.warn("Invalid env value, falling back to default", {
+		component: "selva",
+		envVar: name,
+		value: raw,
+		fallback
+	});
+	return fallback;
+}
+/**
+* Resolve every server-side compute limit from an env map. The app calls this
+* once at its composition root with `$env/dynamic/private`.
+*/
+function resolveComputeLimits(env, logger = noop) {
+	env = readRenamed(env, "COMPUTE_DEFINITION_CACHE_MB", "COMPUTE_DEFINITION_BYTE_CACHE_MB", logger);
+	env = readRenamed(env, "COMPUTE_SOLVE_CACHE_MB", "COMPUTE_RESPONSE_CACHE_MB", logger);
+	env = readRenamed(env, "REMOTE_DEFINITION_CACHE_TTL_MS", "DEFINITION_CACHE_TTL_MS", logger);
+	env = readRenamed(env, "COMPUTE_SOLVE_DEADLINE_MS", "MAX_SOLVE_DURATION_MS", logger);
+	const maxDefinitionFileSize = readPositiveInt(env, "MAX_DEFINITION_FILE_SIZE_BYTES", 50 * MB, logger);
+	return {
+		solveDeadlineMs: readPositiveInt(env, "COMPUTE_SOLVE_DEADLINE_MS", 1e5, logger),
+		rateLimitWindowMs: readPositiveInt(env, "COMPUTE_RATE_LIMIT_WINDOW_MS", 1e5, logger),
+		rateLimitMaxRequests: readPositiveInt(env, "COMPUTE_RATE_LIMIT_MAX", 120, logger),
+		maxDefinitionFileSize,
+		maxImageFileSize: readPositiveInt(env, "MAX_IMAGE_FILE_SIZE_BYTES", 10 * MB, logger),
+		computeRequestMaxBytes: readPositiveInt(env, "COMPUTE_REQUEST_MAX_BYTES", 256 * MB, logger),
+		computeResponseMaxBytes: readPositiveInt(env, "COMPUTE_RESPONSE_MAX_BYTES", 300 * MB, logger),
+		remoteDefinitionMaxBytes: maxDefinitionFileSize,
+		remoteDefinitionFetchTimeoutMs: readPositiveInt(env, "REMOTE_DEFINITION_FETCH_TIMEOUT_MS", 3e4, logger),
+		remoteDefinitionCacheTtlMs: readPositiveInt(env, "REMOTE_DEFINITION_CACHE_TTL_MS", 3e5, logger),
+		computeReuseDefinitionCache: readBool(env, "COMPUTE_REUSE_DEFINITION_CACHE", true, logger),
+		computeServerCachesolve: readBool(env, "COMPUTE_SERVER_CACHESOLVE", true, logger),
+		computeCacheErroredSolves: readBool(env, "COMPUTE_CACHE_ERRORED_SOLVES", false, logger),
+		computeMaxQueueDepth: readNonNegativeInt(env, "COMPUTE_MAX_QUEUE_DEPTH", 0, logger),
+		computeQueueWaitMs: readNonNegativeInt(env, "COMPUTE_QUEUE_WAIT_MS", 0, logger),
+		computeDefinitionCacheBytes: readNonNegativeInt(env, "COMPUTE_DEFINITION_CACHE_MB", 256, logger) * MB,
+		computeSolveCacheBytes: readNonNegativeInt(env, "COMPUTE_SOLVE_CACHE_MB", 256, logger) * MB
+	};
+}
+//#endregion
+//#region ../server/src/compute/errors.ts
+/**
+* Compute error types, kept in a leaf module with no imports.
+*
+* Separate from the function that throws them on purpose: an error mapper needs
+* nothing but the class to `instanceof` against, and importing it from beside
+* the throw site drags that module's dependencies into every mapper. Anything
+* an error mapper imports belongs here.
+*/
+/**
+* Thrown when no compute server is configured or visible for the org — a
+* misconfiguration an operator must fix in `/admin/compute`, not a bug. Routes
+* map this to 503 instead of letting the pure helper's plain `Error` surface as
+* a generic 500.
+*/
+var ComputeServerUnconfiguredError = class extends Error {
+	constructor(message = "No compute server configured. Ask an admin to add one in /admin/compute.") {
+		super(message);
+		this.name = "ComputeServerUnconfiguredError";
+	}
+};
+//#endregion
+//#region ../server/src/api/errors.ts
+/**
+* The transport-free error type every API handler raises.
+*
+* `apiError` used to throw SvelteKit's `error()` directly, which welded all 151
+* of its call sites to one framework. `ApiError` carries the same envelope as a
+* plain exception; the host adapter converts it to whatever its framework
+* expects (see `toApiResponse`). Call sites are unchanged — only the throw
+* site and the boundary know the difference.
+*/
+/** Stable, machine-readable error codes. Append-only — never renumber/rename. */
+var ApiErrorCode = {
+	VALIDATION_FAILED: "VALIDATION_FAILED",
+	UNAUTHORIZED: "UNAUTHORIZED",
+	FORBIDDEN: "FORBIDDEN",
+	NOT_FOUND: "NOT_FOUND",
+	CONFLICT: "CONFLICT",
+	UNPROCESSABLE: "UNPROCESSABLE",
+	COMPUTE_UNAVAILABLE: "COMPUTE_UNAVAILABLE",
+	SETUP_REQUIRED: "SETUP_REQUIRED",
+	INTERNAL: "INTERNAL",
+	/** API tokens are switched off or misconfigured here; browser sessions still work. */
+	API_TOKENS_UNAVAILABLE: "API_TOKENS_UNAVAILABLE",
+	/** Too many requests, or a share link's solve cap is spent. `Retry-After`, when sent, says when to retry. */
+	RATE_LIMITED: "RATE_LIMITED",
+	/** The key is valid, but the host's holder policy no longer lets its owner hold API tokens. */
+	API_TOKEN_HOLDER_REFUSED: "API_TOKEN_HOLDER_REFUSED"
+};
+var ApiError = class extends Error {
+	status;
+	code;
+	/** Per-field validation messages, keyed by dotted path. Only on VALIDATION_FAILED. */
+	fields;
+	/** Machine-readable context, e.g. `requiredScope` on a scope refusal. */
+	details;
+	constructor(status, code, message, fields, details) {
+		super(message);
+		this.name = "ApiError";
+		this.status = status;
+		this.code = code;
+		this.fields = fields;
+		this.details = details;
+	}
+};
+function toErrorBody(err) {
+	const body = {
+		message: err.message,
+		code: err.code
+	};
+	if (err.fields) body.fields = err.fields;
+	if (err.details) body.details = err.details;
+	return body;
+}
+function isApiError(err) {
+	return err instanceof ApiError;
+}
+/** Raise a structured API error. The only way handlers should fail. */
+function apiError(status, code, message, fields, details) {
+	throw new ApiError(status, code, message, fields, details);
+}
+/** Default code for a status, for mapping errors that carry no code of their own. */
+function codeForStatus(status) {
+	switch (status) {
+		case 400: return ApiErrorCode.VALIDATION_FAILED;
+		case 401: return ApiErrorCode.UNAUTHORIZED;
+		case 403: return ApiErrorCode.FORBIDDEN;
+		case 404: return ApiErrorCode.NOT_FOUND;
+		case 409: return ApiErrorCode.CONFLICT;
+		case 422: return ApiErrorCode.UNPROCESSABLE;
+		case 429: return ApiErrorCode.RATE_LIMITED;
+		case 503: return ApiErrorCode.COMPUTE_UNAVAILABLE;
+		default: return ApiErrorCode.INTERNAL;
+	}
+}
+//#endregion
+//#region ../server/src/access/project-access-input.ts
+function createProjectAccessInputBuilder(deps) {
+	return {
+		async buildProjectAccessInput(ctx, project, overrides = {}) {
+			const { allowCrossOrgPublic, enablePlatformProjects } = deps.flags();
+			let member = null;
+			let orgMember = null;
+			let platformGrants = [];
+			if (project.visibility === "platform") {
+				if (enablePlatformProjects) platformGrants = await deps.listPlatformGrants(ctx, project.id);
+			} else if (project.visibility === "private") member = await deps.getProjectMember(ctx, project.id, ctx.userId);
+			else {
+				const skipOrgMember = project.visibility === "public" && allowCrossOrgPublic;
+				[member, orgMember] = await Promise.all([deps.getProjectMember(ctx, project.id, ctx.userId), skipOrgMember ? Promise.resolve(null) : deps.getOrgMember(ctx, project.orgId, ctx.userId)]);
+			}
+			return {
+				orgPermissions: ctx.orgPermissions,
+				platformPermissions: ctx.platformPermissions,
+				project,
+				member,
+				orgMember,
+				allowCrossOrgPublic,
+				enablePlatformProjects,
+				platformGrants,
+				actingOrgId: ctx.actingOrgId ?? null,
+				userId: ctx.userId,
+				...overrides
+			};
+		},
+		projectAccessInputFromRows(ctx, project, rows) {
+			const { allowCrossOrgPublic, enablePlatformProjects } = deps.flags();
+			return {
+				orgPermissions: ctx.orgPermissions,
+				platformPermissions: ctx.platformPermissions,
+				project,
+				member: rows.member ?? null,
+				orgMember: rows.orgMember ?? null,
+				allowCrossOrgPublic,
+				enablePlatformProjects,
+				platformGrants: rows.platformGrants ?? [],
+				actingOrgId: ctx.actingOrgId ?? null,
+				userId: ctx.userId
+			};
+		}
+	};
+}
+//#endregion
+//#region ../server/src/access/guards.ts
+/**
+* Derive the stores a guard needs from a resolved config.
+*
+* Pure — it reads the config it is handed and nothing else, which is what keeps
+* this module free of any import that boots the app. Page loads pass
+* `locals.providers`; `hooks.server.ts` sets it on every request.
+*/
+function accessDepsFromConfig(config) {
+	return {
+		orgs: config.data.orgs,
+		projects: config.data.projects,
+		definitionMeta: config.data.definitions,
+		platformProjectGrants: config.data.platformProjectGrants,
+		flag: (name) => isFlagEnabled(config, name)
+	};
+}
+/** `locals` as a store-reading guard wants it. */
+function scoped(locals) {
+	return {
+		...locals,
+		deps: accessDepsFromConfig(locals.providers)
+	};
+}
+var orgsOf = (src) => src.deps.orgs;
+var projectsOf = (src) => src.deps.projects;
+var definitionMetaOf = (src) => src.deps.definitionMeta;
+var flagOf = (src) => src.deps.flag;
+function requireAuthed(locals) {
+	const { user, ctx } = locals;
+	if (!user || !ctx) apiError(401, ApiErrorCode.UNAUTHORIZED, "Unauthorized");
+	return {
+		user,
+		ctx
+	};
+}
+/** Throws 403 — use in API routes. */
+function requirePermission(locals, permission) {
+	const { user, ctx } = requireAuthed(locals);
+	if (!hasPermission(ctx, permission)) apiError(403, ApiErrorCode.FORBIDDEN, `You don't have permission to do this.`);
+	return user;
+}
+var requireManageInstanceUsers = (locals) => requirePermission(locals, "manage_instance_users");
+var requireManageCompute = (locals) => requirePermission(locals, "manage_compute");
+var requireManageOrgMembers = (locals) => requirePermission(locals, "manage_org_members");
+var requireManageOrgCompute = (locals) => requirePermission(locals, "manage_org_compute");
+var requireInstanceAdmin = (locals) => requirePermission(locals, "instance_admin");
+/**
+* Platform scope is not delegable: `manage_instance_users` runs the user-admin
+* surface but must not be able to mint an `instance_admin`, or an org admin
+* holding it self-elevates. Three routes write platform permissions — the two
+* `/api/admin/users` handlers and the invite mint route — and each carried its
+* own copy of this check.
+*
+* Pass `current` on an update. Revoking is a platform-scope change too, so a
+* PATCH that drops `instance_admin` is refused for the same reason granting it
+* is; without `current` the caller is creating (a user, an invite) and there is
+* nothing to compare against.
+*
+* Requesting nothing on a create is always allowed — that is a
+* `manage_instance_users` operation, not a platform-scope one.
+*/
+function assertCanGrantPlatformPermissions(ctx, requested, current) {
+	if (!(current ? requested.length !== current.length || requested.some((p) => !current.includes(p)) || current.some((p) => !requested.includes(p)) : requested.length > 0)) return;
+	if (hasPermission(ctx, "instance_admin")) return;
+	apiError(403, ApiErrorCode.FORBIDDEN, current ? "Only a platform admin can change platform-scope permissions" : "Only a platform admin can grant platform-scope permissions");
+}
+/**
+* Tenancy gate for `/api/v1/orgs/{orgId}/…`. The URL id is never trusted alone
+* — the acting context decides which tenant a request applies to, so a
+* mismatch is 403 rather than a silent read of the caller's own org.
+*/
+function requireActingOrg(locals, orgId) {
+	const ctx = locals.ctx;
+	if (!ctx) apiError(401, ApiErrorCode.UNAUTHORIZED, "Unauthorized");
+	if (!orgId) apiError(400, ApiErrorCode.VALIDATION_FAILED, "Missing org ID");
+	if (!ctx.actingOrgId) apiError(400, ApiErrorCode.VALIDATION_FAILED, "No active organization");
+	if (ctx.actingOrgId !== orgId) apiError(403, ApiErrorCode.FORBIDDEN, "Acting org does not match the target org.");
+	return {
+		ctx,
+		orgId
+	};
+}
+/**
+* Gate for pages reachable by any platform-class permission holder (the
+
+/**
+* Management-scope bypass — used for org governance and project management
+* actions (Reclaim, create project, delete project, manage members, edit
+* settings). `instance_admin` bypasses these so platform staff can administer
+* the instance without being a member of every org.
+*
+* NOT used for content access (view, solve, edit definitions):
+* `instance_admin` follows the same `canView`/`canEdit` rules as any other
+* user there, keeping blast radius small and forcing content escalation
+* through Reclaim, which leaves an audit trail.
+*/
+async function managementBypassOrRun(ctx, check) {
+	if (hasPermission(ctx, "instance_admin")) return true;
+	return await check();
+}
+async function contentCheck(check) {
+	return await check();
+}
+async function loadProjectOr404(ctx, projectId, src) {
+	const project = await projectsOf(src).getProject(ctx, projectId);
+	if (!project || outsideTokenOrg(ctx, project.orgId)) apiError(404, ApiErrorCode.NOT_FOUND, "Project not found");
+	return project;
+}
+function accessInputsFor(src) {
+	const readFlag = flagOf(src);
+	return createProjectAccessInputBuilder({
+		getProjectMember: (ctx, projectId, userId) => projectsOf(src).getProjectMember(ctx, projectId, userId),
+		getOrgMember: (ctx, orgId, userId) => orgsOf(src).getOrgMember(ctx, orgId, userId),
+		listPlatformGrants: (ctx, projectId) => src.deps.platformProjectGrants.listByProject(ctx, projectId),
+		flags: () => ({
+			allowCrossOrgPublic: readFlag("ALLOW_CROSS_ORG_PUBLIC"),
+			enablePlatformProjects: readFlag("ENABLE_PLATFORM_PROJECTS")
+		})
+	});
+}
+function buildProjectAccessInput(ctx, project, src, overrides) {
+	return accessInputsFor(src).buildProjectAccessInput(ctx, project, overrides);
+}
+/**
+* Assemble a rule input from rows the caller already loaded.
+*
+* Unlike the other builders this one issues no reads — the caller batched them.
+* It still needs `deps` for the flag lookups, which decide whether a
+* cross-org-public or platform project is visible at all.
+*/
+function projectAccessInputFromRowsWith(src, ...args) {
+	return accessInputsFor(src).projectAccessInputFromRows(...args);
+}
+/**
+* Gates creation of a *new* definition. Container projects require project
+* owner/editor (canEdit). Commons projects (`autoJoinOnUpload=true`) accept
+* any authenticated user — the handler stamps `ownerId = user.id` so the
+* uploader becomes the owner.
+*/
+async function requireCanCreateDefinition(locals, projectId) {
+	const { user, ctx } = requireAuthed(locals);
+	const project = await loadProjectOr404(ctx, projectId, locals);
+	if (!await contentCheck(async () => canCreateDefinition(await buildProjectAccessInput(ctx, project, locals)))) apiError(403, ApiErrorCode.FORBIDDEN, "You do not have permission to upload definitions to this project.");
+	return {
+		user,
+		ctx,
+		project
+	};
+}
+/**
+* Org-content gate — the caller must be a member of `orgId`. Used by the
+* file-serving proxy for org-private assets (e.g. pricing sheets under
+* `orgs/{id}/private/*`). Org membership is the only rule; runs through
+* `contentCheck` (no `instance_admin` bypass) — platform staff use Reclaim
+* if they need access without membership.
+*
+* Throws 401 unauthenticated, 403 when not a member.
+*/
+async function requireCanViewOrg(locals, orgId) {
+	const { user, ctx } = requireAuthed(locals);
+	if (!await contentCheck(async () => {
+		return await orgsOf(locals).getOrgMember(ctx, orgId, ctx.userId) !== null;
+	})) apiError(403, ApiErrorCode.FORBIDDEN, "You do not have access to this organization.");
+	return user;
+}
+/**
+* Project members must belong to the project's parent org. Enforced at the
+* rule layer, not as a DB constraint, to leave room for cross-org guests
+* later without a schema migration.
+*/
+async function requireTargetIsOrgMember(locals, orgId, targetUserId) {
+	const { ctx } = requireAuthed(locals);
+	if (!await orgsOf(locals).getOrgMember(ctx, orgId, targetUserId)) apiError(400, ApiErrorCode.VALIDATION_FAILED, "User must be a member of this organization to be added to a project.");
+}
+/**
+* `canChangeOrgRole` with the actor's membership row loaded — whether the
+* caller may grant or revoke org `owner`/`admin` standing (§3).
+*
+* Returns rather than throws: the three callers each phrase the refusal for
+* what they were doing ("invite someone as owner", "change roles", "remove
+* another owner") and raise it through `apiError`. What must not diverge is the
+* decision, which is why that half lives in `rules.ts` and this loads its input.
+*/
+async function canActorChangeOrgRole(ctx, orgId, role, src) {
+	if (role === "member") return true;
+	return canChangeOrgRole({
+		actorMember: await orgsOf(src).getOrgMember(ctx, orgId, ctx.userId),
+		role
+	});
+}
+/**
+* `canReclaim` — org owner/admin escape hatch. Returns the project so the
+* handler can use its `orgId` without re-fetching.
+*/
+async function requireCanReclaim(locals, projectId) {
+	const { user, ctx } = requireAuthed(locals);
+	const project = await loadProjectOr404(ctx, projectId, locals);
+	if (project.visibility === "platform") apiError(403, ApiErrorCode.FORBIDDEN, "Platform projects cannot be reclaimed.");
+	if (!await managementBypassOrRun(ctx, async () => {
+		const orgMember = await orgsOf(locals).getOrgMember(ctx, project.orgId, ctx.userId);
+		return canReclaim({
+			project,
+			orgMember,
+			actingOrgId: ctx.actingOrgId ?? null
+		});
+	})) apiError(403, ApiErrorCode.FORBIDDEN, "Only org owners or admins of this project’s org can reclaim it.");
+	return {
+		user,
+		ctx,
+		project
+	};
+}
+/**
+* `canCreateProject` — owner/admin always; member needs `manage_projects`.
+* Tenancy is enforced via `actingOrgId`.
+*/
+async function requireCanCreateProject(locals, targetOrgId) {
+	const { user, ctx } = requireAuthed(locals);
+	if (!await managementBypassOrRun(ctx, async () => {
+		const orgMember = await orgsOf(locals).getOrgMember(ctx, targetOrgId, ctx.userId);
+		return canCreateProject({
+			orgPermissions: ctx.orgPermissions,
+			orgMember,
+			actingOrgId: ctx.actingOrgId ?? null,
+			targetOrgId
+		});
+	})) apiError(403, ApiErrorCode.FORBIDDEN, "You do not have permission to create projects in this org.");
+	return {
+		user,
+		ctx
+	};
+}
+/**
+* Project-management gate (`canManage` — owner, or `instance_admin` via the
+* bypass). Managing members is the same authority as managing the project, so
+* both callers share this; `action` only shapes the 403 message.
+*/
+async function requireCanManage(locals, projectId, action = "project") {
+	const { user, ctx } = requireAuthed(locals);
+	if (!await managementBypassOrRun(ctx, async () => {
+		const project = await loadProjectOr404(ctx, projectId, locals);
+		return canManage(await buildProjectAccessInput(ctx, project, locals));
+	})) apiError(403, ApiErrorCode.FORBIDDEN, action === "members" ? "Only project owners can manage members." : "Only project owners can manage this project.");
+	return user;
+}
+async function requireCanEditProjectSettings(locals, projectId) {
+	const { user, ctx } = requireAuthed(locals);
+	const project = await loadProjectOr404(ctx, projectId, locals);
+	if (!await managementBypassOrRun(ctx, async () => canEditProjectSettings(await buildProjectAccessInput(ctx, project, locals)))) apiError(403, ApiErrorCode.FORBIDDEN, "Only project owners can edit project settings.");
+	return {
+		user,
+		ctx,
+		project
+	};
+}
+async function requireCanViewProject(locals, projectId) {
+	const { user, ctx } = requireAuthed(locals);
+	if (!await contentCheck(async () => {
+		const project = await loadProjectOr404(ctx, projectId, locals);
+		return canView(await buildProjectAccessInput(ctx, project, locals));
+	})) apiError(403, ApiErrorCode.FORBIDDEN, "You do not have access to this project.");
+	return user;
+}
+/**
+* Solve gating. Today `canSolve === canView` for non-platform projects, but
+* the rule lives in its own function so future cost-gating (quotas, rate
+* limits) lands without touching view semantics. `viewer` project role
+* passes; platform projects narrow to grants with `canSolve=true`.
+*/
+async function requireCanSolve(locals, projectId, preloadedProject) {
+	const { user, ctx } = requireAuthed(locals);
+	const project = preloadedProject ?? await loadProjectOr404(ctx, projectId, locals);
+	if (outsideTokenOrg(ctx, project.orgId)) apiError(404, ApiErrorCode.NOT_FOUND, "Project not found");
+	if (!await contentCheck(async () => canSolve(await buildProjectAccessInput(ctx, project, locals)))) apiError(403, ApiErrorCode.FORBIDDEN, "You do not have access to this project.");
+	return {
+		user,
+		ctx,
+		project
+	};
+}
+/**
+* Org membership for the commons branch of `canEditDefinition`, or `null` when
+* that branch cannot fire. Skipping the round-trip on container projects keeps
+* the common edit path at the same two reads it had before commons gained the
+* membership test.
+*/
+async function loadCommonsOrgMember(ctx, project, src) {
+	if (!project?.autoJoinOnUpload) return null;
+	return await orgsOf(src).getOrgMember(ctx, project.orgId, ctx.userId);
+}
+/**
+* Loads the record and gates editing. Returns the record AND the project it
+* loads for the gate, so callers skip a re-fetch of either.
+*/
+async function requireEditableDefinition(locals, guid) {
+	const { ctx } = requireAuthed(locals);
+	const record = await definitionMetaOf(locals).get(ctx, guid);
+	if (!record) apiError(404, ApiErrorCode.NOT_FOUND, "Definition not found");
+	const [project, member] = await Promise.all([projectsOf(locals).getProject(ctx, record.projectId), projectsOf(locals).getProjectMember(ctx, record.projectId, ctx.userId)]);
+	if (project && outsideTokenOrg(ctx, project.orgId)) apiError(404, ApiErrorCode.NOT_FOUND, "Definition not found");
+	if (!await contentCheck(async () => canEditDefinition({
+		project,
+		definition: record,
+		member,
+		orgMember: await loadCommonsOrgMember(ctx, project, locals),
+		userId: ctx.userId,
+		platformPermissions: ctx.platformPermissions,
+		enablePlatformProjects: flagOf(locals)("ENABLE_PLATFORM_PROJECTS")
+	}))) apiError(403, ApiErrorCode.FORBIDDEN, "You do not have permission to edit this definition.");
+	return {
+		record,
+		ctx,
+		project
+	};
+}
+async function requireCanEditDefinition(locals, projectId, definitionGuid, preloaded) {
+	const { user, ctx } = requireAuthed(locals);
+	if (!await contentCheck(async () => {
+		const [project, definition, member] = await Promise.all([
+			preloaded?.project !== void 0 ? Promise.resolve(preloaded.project) : projectsOf(locals).getProject(ctx, projectId),
+			preloaded?.definition !== void 0 ? Promise.resolve(preloaded.definition) : definitionMetaOf(locals).get(ctx, definitionGuid),
+			projectsOf(locals).getProjectMember(ctx, projectId, ctx.userId)
+		]);
+		if (project && outsideTokenOrg(ctx, project.orgId)) return false;
+		return canEditDefinition({
+			project,
+			definition,
+			member,
+			orgMember: await loadCommonsOrgMember(ctx, project, locals),
+			userId: ctx.userId,
+			platformPermissions: ctx.platformPermissions,
+			enablePlatformProjects: flagOf(locals)("ENABLE_PLATFORM_PROJECTS")
+		});
+	})) apiError(403, ApiErrorCode.FORBIDDEN, "You do not have permission to edit this definition.");
+	return user;
+}
+//#endregion
+//#region ../server/src/access/permissions-scope.ts
+var PLATFORM_SET = new Set(ALL_PLATFORM_PERMISSIONS);
+var ORG_SET = new Set(ALL_ORG_PERMISSIONS);
+/** Split a flat array into platform + org scope buckets, dropping unknowns. */
+function splitFlatPermissions(flat) {
+	const platform = [];
+	const org = [];
+	for (const p of flat) if (PLATFORM_SET.has(p)) platform.push(p);
+	else if (ORG_SET.has(p)) org.push(p);
+	return {
+		platform,
+		org
+	};
+}
+
+export { ApiErrorCode as A, canEdit as B, ComputeServerUnconfiguredError as C, requireCanEditProjectSettings as D, withAdminBypass as E, requireCanManage as F, requireTargetIsOrgMember as G, checkOwnerRemoval as H, requireCanReclaim as I, canChangeVisibilityToPublic as J, requireAuthed as K, accessDepsFromConfig as L, requirePermission as M, NoopLogger as N, requireCanSolve as O, scoped as P, canManage as Q, requireManageCompute as R, requireInstanceAdmin as S, requireManageInstanceUsers as T, requireCanViewOrg as U, requireCanEditDefinition as V, canView as a, canEditDefinition as b, canCreateDefinition as c, apiError as d, resolveComputeLimits as e, ApiError as f, isApiError as g, readNonNegativeInt as h, isFlagEnabled as i, readPositiveInt as j, codeForStatus as k, requireCanViewProject as l, requireCanCreateDefinition as m, requireEditableDefinition as n, requireActingOrg as o, projectAccessInputFromRowsWith as p, requireManageOrgMembers as q, readBool as r, requireManageOrgCompute as s, toErrorBody as t, splitFlatPermissions as u, assertCanGrantPlatformPermissions as v, canActorChangeOrgRole as w, canChangeOrgRole as x, requireCanCreateProject as y, canSolve as z };
+//# sourceMappingURL=access.js-BataxwA1.js.map