@selvajs/selva 4.17.1 → 4.18.0

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

@@ -0,0 +1,756 @@
+import { A as ALL_PLATFORM_PERMISSIONS, a as ALL_ORG_PERMISSIONS, h as hasPermission } from './src.js-Cf1j97Z6.js';
+import { t as tt, Z as Ze, U as UI_SCHEMA_VERSION } from './schema.js-YChb_4u9.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 ../platform/src/events/interface.ts
+/**
+* `ctx.userId === ''` is the `SYSTEM_CONTEXT` convention for a server-internal
+* caller (bootstrap, janitors, migrations), which resolves to `'system'` here.
+*/
+function actorFrom(ctx) {
+	return ctx.userId || "system";
+}
+/** Discards every event. Used when `SelvaConfig.events` is omitted. */
+var NoopEventSink = class {
+	async emit(_event) {}
+};
+//#endregion
+//#region ../platform/src/config.ts
+function isFlagEnabled(config, flag) {
+	return Boolean(config.flags?.[flag]);
+}
+//#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",
+	INTERNAL: "INTERNAL"
+};
+var ApiError = class extends Error {
+	status;
+	code;
+	/** Per-field validation messages, keyed by dotted path. Only on VALIDATION_FAILED. */
+	fields;
+	constructor(status, code, message, fields) {
+		super(message);
+		this.name = "ApiError";
+		this.status = status;
+		this.code = code;
+		this.fields = fields;
+	}
+};
+function isApiError(err) {
+	return err instanceof ApiError;
+}
+/** Raise a structured API error. The only way handlers should fail. */
+function apiError(status, code, message, fields) {
+	throw new ApiError(status, code, message, fields);
+}
+/** 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 503: return ApiErrorCode.COMPUTE_UNAVAILABLE;
+		default: return ApiErrorCode.INTERNAL;
+	}
+}
+//#endregion
+//#region ../server/src/definitions/schema-extraction.ts
+/** Thin re-export of @selvajs/compute's unwrap, typed to `UISchema`. */
+function readSchemaResults(raw) {
+	return Ze(raw);
+}
+/** Thrown when compute is reachable but the definition yields no usable schema. */
+var SchemaExtractionError = class extends Error {
+	kind;
+	constructor(kind, message) {
+		super(message);
+		this.kind = kind;
+		this.name = "SchemaExtractionError";
+	}
+};
+/**
+* Rejects a schema whose keys are not camelCase by the time it reaches a consumer.
+*
+* Compute serializes the plugin's `UISchema` POCO, whose camelCase names live in
+* `[JsonProperty]` attributes. `Selva.gha` ILRepack-merges Newtonsoft, so those
+* attributes have type `Selva!Newtonsoft.Json.JsonPropertyAttribute`; a compute
+* server serializing with its OWN Newtonsoft does not recognize them, reads no
+* attributes, and falls back to raw CLR member names — `Inputs`, `Layout`.
+* Nothing throws on the wire: every consumer just reads `schema.inputs` as
+* undefined and renders a definition with no inputs.
+*
+* `postSchemaFormData` repairs that casing via `normalizeUISchemaCasing`, so a
+* schema fresh off the wire never trips this. It stays because schemas are also
+* PERSISTED: a row cached before the normalizer existed still holds PascalCase,
+* and it reaches consumers without passing through `postSchemaFormData` again.
+* A schema with no `inputs` in any casing lands here too. It is a backstop, not
+* the primary defense — which is why it names the missing key rather than telling
+* the operator to go update their compute server.
+*
+* Checked structurally rather than by plugin version, because the casing depends
+* on which assembly serialized the schema, not on any version number.
+*/
+function assertCamelCaseSchema(schema) {
+	const raw = schema;
+	if (Array.isArray(raw.inputs)) return;
+	const pascalKeys = [
+		"Inputs",
+		"Outputs",
+		"Layout",
+		"SchemaVersion"
+	].filter((k) => k in raw);
+	if (pascalKeys.length > 0) throw new SchemaExtractionError("malformed", `Schema keys are PascalCase (found ${pascalKeys.join(", ")}), so every property name is wrong and the definition would render with no inputs. Compute serialized it with its own Newtonsoft instead of the one merged into Selva.gha. Fresh responses are normalized, so this is most likely a schema cached before that fix — re-save the definition version to re-extract it.`);
+	throw new SchemaExtractionError("malformed", `Compute returned a schema with no 'inputs' array (got keys: ${Object.keys(raw).slice(0, 12).join(", ")}).`);
+}
+function parseSemver(version) {
+	const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
+	return m ? [
+		Number(m[1]),
+		Number(m[2]),
+		Number(m[3])
+	] : null;
+}
+/**
+* Rejects a schema from a NEWER plugin than this app was built against — its
+* shape may contain constructs the renderer doesn't know. Older (or missing)
+* versions pass: the compute-side C# migrator always emits its own current
+* version, and an older shape only lacks optional additions.
+*/
+function assertSupportedSchemaVersion(schema) {
+	const version = schema.schemaVersion;
+	if (!version) return;
+	const extracted = parseSemver(version);
+	const supported = parseSemver(UI_SCHEMA_VERSION);
+	if (!extracted || !supported) return;
+	if (extracted[0] > supported[0] || extracted[0] === supported[0] && (extracted[1] > supported[1] || extracted[1] === supported[1] && extracted[2] > supported[2])) throw new SchemaExtractionError("unsupported", `This definition was authored with a newer Selva plugin (schema format ${version}); this server supports schema format ≤ ${UI_SCHEMA_VERSION}. Update the server, or re-save the definition with a matching plugin version.`);
+}
+/**
+* POSTs a multipart form to Rhino Compute's `/grasshopper/schema` endpoint (no
+* solve required). Throws 'unreachable' on a network failure or non-2xx. The
+* per-file `error` Compute reports on its 200-with-no-schemas case is left to
+* the caller — single-file and multi-file callers want different messages.
+*/
+async function postSchemaFormData(formData, server) {
+	const schemaUrl = new URL("/grasshopper/schema", server.serverUrl).toString();
+	const headers = {};
+	if (server.apiKey) headers["RhinoComputeKey"] = server.apiKey;
+	let response;
+	try {
+		response = await fetch(schemaUrl, {
+			method: "POST",
+			headers,
+			body: formData
+		});
+	} catch (err) {
+		throw new SchemaExtractionError("unreachable", `Compute server is unreachable: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (!response.ok) throw new SchemaExtractionError("unreachable", `Schema endpoint returned ${response.status}: ${response.statusText}`);
+	return readSchemaResults(await response.json()).map((result) => ({
+		...result,
+		schemas: result.schemas?.map((schema) => tt(schema))
+	}));
+}
+/**
+* Throws `SchemaExtractionError` so callers can map to the right HTTP status:
+* 503 unreachable / 422 invalid or unsupported.
+*/
+async function fetchSchemaFromCompute(definitionBytes, server) {
+	const formData = new FormData();
+	const blob = new Blob([new Uint8Array(definitionBytes)], { type: "application/octet-stream" });
+	formData.append("file", blob, "definition.gh");
+	const results = await postSchemaFormData(formData, server);
+	const schemas = results.flatMap((r) => r.schemas ?? []);
+	if (schemas.length === 0) {
+		const diagnosis = results.map((r) => r.error).filter(Boolean);
+		if (diagnosis.length > 0) throw new SchemaExtractionError("invalid", diagnosis.join("\n"));
+		throw new SchemaExtractionError("invalid", "No schemas found in definition.\n\nIn Grasshopper, verify a Context Bake component with the output name \"Schema\" is present and wired to the solver.");
+	}
+	assertSupportedSchemaVersion(schemas[0]);
+	assertCamelCaseSchema(schemas[0]);
+	return schemas[0];
+}
+//#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) 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 (!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 (!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)
+		]);
+		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 { ApiError as A, requireEditableDefinition as B, requireActingOrg as C, requireManageOrgMembers as D, requireManageOrgCompute as E, splitFlatPermissions as F, canActorChangeOrgRole as G, canChangeOrgRole as H, requireCanCreateProject as I, canSolve as J, requireCanEditProjectSettings as K, withAdminBypass as L, requireCanManage as M, NoopEventSink as N, requireTargetIsOrgMember as O, checkOwnerRemoval as P, requireCanReclaim as Q, canChangeVisibilityToPublic as R, SchemaExtractionError as S, actorFrom as a, ApiErrorCode as b, canView as c, codeForStatus as d, isApiError as e, fetchSchemaFromCompute as f, accessDepsFromConfig as g, apiError as h, isFlagEnabled as i, requirePermission as j, requireCanSolve as k, canManage as l, canEdit as m, requireManageCompute as n, requireInstanceAdmin as o, projectAccessInputFromRowsWith as p, requireManageInstanceUsers as q, requireAuthed as r, scoped as s, assertCanGrantPlatformPermissions as t, requireCanViewProject as u, requireCanViewOrg as v, requireCanEditDefinition as w, requireCanCreateDefinition as x, postSchemaFormData as y, assertCamelCaseSchema as z };
+//# sourceMappingURL=access.js-DFbcJ7ZG.js.map