@selvajs/selva 4.20.0-beta.6 → 4.20.0-beta.7

package/build/server/chunks/chunks/access.js-rwe-SmJo.js

@@ -1,571 +0,0 @@
-import { A as ALL_PLATFORM_PERMISSIONS, a as ALL_ORG_PERMISSIONS, h as hasPermission, o as outsideTokenOrg } from './src.js-CkL6l768.js';
-import { i as isFlagEnabled } from './schema-extraction.js-BYMAfcf8.js';
-import { a as apiError, A as ApiErrorCode } from './errors.js-BNBva9oZ.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";
-}
-/** 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 ../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 () => {
-		if (project.autoJoinOnUpload) return true;
-		return canEdit(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 { requireCanReclaim as A, canChangeVisibilityToPublic as B, requireManageCompute as C, requireInstanceAdmin as D, requireManageInstanceUsers as E, requireCanViewOrg as F, requireCanEditDefinition as G, accessDepsFromConfig as a, requirePermission as b, canView as c, requireCanSolve as d, canManage as e, canEdit as f, requireCanCreateDefinition as g, requireEditableDefinition as h, requireActingOrg as i, requireManageOrgMembers as j, requireManageOrgCompute as k, splitFlatPermissions as l, assertCanGrantPlatformPermissions as m, canActorChangeOrgRole as n, canChangeOrgRole as o, projectAccessInputFromRowsWith as p, requireCanViewProject as q, requireAuthed as r, scoped as s, requireCanCreateProject as t, canSolve as u, requireCanEditProjectSettings as v, withAdminBypass as w, requireCanManage as x, requireTargetIsOrgMember as y, checkOwnerRemoval as z };
-//# sourceMappingURL=access.js-rwe-SmJo.js.map