@pipeline-builder/api-core 3.4.126 → 4.0.2

package/README.md

@@ -19,7 +19,7 @@ Provides the cross-cutting primitives every backend service depends on: JWT auth
 | `requireAdmin`, `requireSystemAdmin` | Role gates (admin/owner; system-org admin/owner) |
 | `requireFeature` | Feature-flag gate |
 | `isSystemOrgId`, `isSystemAdmin`, `isServicePrincipal` | Authorization helpers (`isServicePrincipal` is true when `req.user.sub` starts with `service:`) |
-| `resolveAccessModifier` | Coerces requested `'public'` to `'private'` unless caller is admin/owner |
+| `resolveVisibility` | Resolves the sharing rung: `'public'` needs the resource's `:publish` permission (clamped to `'org'` otherwise); an unspecified rung falls back per-entity |
 | `signServiceToken`, `getServiceAuthHeader` | Mint short-lived inter-service JWTs (default TTL 5 min) accepted unmodified by `requireAuth` |
 
 ### Responses & errors (`./utils`, `./errors`)
@@ -51,7 +51,7 @@ Provides the cross-cutting primitives every backend service depends on: JWT auth
 | Export | Purpose |
 | --- | --- |
 | `createLogger`, `logger` | Winston structured logger factory and default instance |
-| `AIGenerateBodySchema`, `AIGenerateFromUrlBodySchema`, `PluginCreateSchema`, `PipelineFilterSchema`, `MessageCreateSchema`, plus `PaginationSchema`, `UUIDSchema`, `AccessModifierSchema` | Zod request-validation schemas and shared building blocks |
+| `AIGenerateBodySchema`, `AIGenerateFromUrlBodySchema`, `PluginCreateSchema`, `PipelineFilterSchema`, `MessageCreateSchema`, plus `PaginationSchema`, `UUIDSchema`, `VisibilitySchema` | Zod request-validation schemas and shared building blocks |
 | `registry`, `generateOpenApiSpec` | Shared schema registry and OpenAPI spec generation |
 
 ### AI provider catalog (`./constants`)

package/lib/constants/ai-providers.d.ts

@@ -25,6 +25,24 @@ export declare const AI_PROVIDER_CATALOG: Record<string, AIProviderInfo>;
  * Used by backend services to initialize the provider registry.
  */
 export declare const AI_PROVIDER_ENV_VARS: Record<string, string>;
+/**
+ * Provider id for a self-hosted, OpenAI-compatible endpoint — a Docker model image
+ * (Ollama, Docker Model Runner, vLLM) or any other server that speaks the OpenAI
+ * chat API. Unlike the fixed providers above, this one is NOT in the static catalog:
+ * its endpoint and model list are deployment-defined and resolved from env at
+ * runtime by {@link getOpenAICompatibleProvider}.
+ */
+export declare const OPENAI_COMPATIBLE_PROVIDER_ID = "openai-compatible";
+/**
+ * Resolve the OpenAI-compatible (local / self-hosted) provider from env, or `null`
+ * when no endpoint is configured. Enabled by `OPENAI_COMPATIBLE_BASE_URL`; the model
+ * list comes from `OPENAI_COMPATIBLE_MODELS` (comma list of `id[|Display Name]`),
+ * falling back to `OPENAI_COMPATIBLE_MODEL`, then a generic `local` id. The display
+ * name is overridable via `OPENAI_COMPATIBLE_NAME`.
+ *
+ * @returns Provider info for the configured local endpoint, or null if unset
+ */
+export declare function getOpenAICompatibleProvider(): AIProviderInfo | null;
 /**
  * Get the model list for a given provider ID.
  *

package/lib/constants/ai-providers.js

@@ -66,6 +66,53 @@ export const AI_PROVIDER_ENV_VARS = {
     'xai': 'XAI_API_KEY',
     'amazon-bedrock': 'AWS_ACCESS_KEY_ID',
 };
+/**
+ * Provider id for a self-hosted, OpenAI-compatible endpoint — a Docker model image
+ * (Ollama, Docker Model Runner, vLLM) or any other server that speaks the OpenAI
+ * chat API. Unlike the fixed providers above, this one is NOT in the static catalog:
+ * its endpoint and model list are deployment-defined and resolved from env at
+ * runtime by {@link getOpenAICompatibleProvider}.
+ */
+export const OPENAI_COMPATIBLE_PROVIDER_ID = 'openai-compatible';
+/**
+ * Parse a `id[|Display Name][,id2[|Name2]]` env string into model metadata. The
+ * id/name separator is `|` (NOT `:`) because model ids commonly contain colons —
+ * e.g. Ollama tags (`qwen2.5-coder:7b`) and Bedrock inference profiles.
+ */
+function parseModelList(raw) {
+    return raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .map((entry) => {
+        const idx = entry.indexOf('|');
+        const id = (idx === -1 ? entry : entry.slice(0, idx)).trim();
+        const name = (idx === -1 ? '' : entry.slice(idx + 1)).trim() || id;
+        return { id, name };
+    })
+        .filter((m) => m.id.length > 0);
+}
+/**
+ * Resolve the OpenAI-compatible (local / self-hosted) provider from env, or `null`
+ * when no endpoint is configured. Enabled by `OPENAI_COMPATIBLE_BASE_URL`; the model
+ * list comes from `OPENAI_COMPATIBLE_MODELS` (comma list of `id[|Display Name]`),
+ * falling back to `OPENAI_COMPATIBLE_MODEL`, then a generic `local` id. The display
+ * name is overridable via `OPENAI_COMPATIBLE_NAME`.
+ *
+ * @returns Provider info for the configured local endpoint, or null if unset
+ */
+export function getOpenAICompatibleProvider() {
+    const baseURL = process.env.OPENAI_COMPATIBLE_BASE_URL;
+    if (!baseURL)
+        return null;
+    const raw = process.env.OPENAI_COMPATIBLE_MODELS ?? process.env.OPENAI_COMPATIBLE_MODEL ?? 'local|Local model';
+    const models = parseModelList(raw);
+    return {
+        id: OPENAI_COMPATIBLE_PROVIDER_ID,
+        name: process.env.OPENAI_COMPATIBLE_NAME || 'Local model (OpenAI-compatible)',
+        models: models.length > 0 ? models : [{ id: 'local', name: 'Local model' }],
+    };
+}
 // Helpers
 /**
  * Get the model list for a given provider ID.
@@ -74,6 +121,9 @@ export const AI_PROVIDER_ENV_VARS = {
  * @returns Array of models, or empty array if the provider is unknown
  */
 export function getAIProviderModels(providerId) {
+    if (providerId === OPENAI_COMPATIBLE_PROVIDER_ID) {
+        return getOpenAICompatibleProvider()?.models ?? [];
+    }
     return AI_PROVIDER_CATALOG[providerId]?.models ?? [];
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai-providers.js","sourceRoot":"","sources":["../../src/constants/ai-providers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n// Types\n\n/** Metadata for a single AI model. */\nexport interface AIModelInfo {\n  /** Model identifier used in API calls (e.g. \"claude-sonnet-5\"). */\n  id: string;\n  /** Human-readable display name (e.g. \"Claude Sonnet 5\"). */\n  name: string;\n}\n\n/** Metadata for an AI provider with its available models. */\nexport interface AIProviderInfo {\n  /** Provider identifier (e.g. \"anthropic\", \"openai\", \"google\"). */\n  id: string;\n  /** Human-readable display name (e.g. \"Anthropic\"). */\n  name: string;\n  /** Models available for this provider. */\n  models: AIModelInfo[];\n}\n\n// Catalog\n\n/**\n * Standard AI provider catalog — single source of truth for all supported\n * providers and their models. Used by both backend services and frontend\n * components.\n */\nexport const AI_PROVIDER_CATALOG: Record<string, AIProviderInfo> = {\n  'anthropic': {\n    id: 'anthropic',\n    name: 'Anthropic',\n    models: [\n      { id: 'claude-sonnet-5', name: 'Claude Sonnet 5' },\n      { id: 'claude-opus-5', name: 'Claude Opus 5' },\n      { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5' },\n    ],\n  },\n  'openai': {\n    id: 'openai',\n    name: 'OpenAI',\n    models: [\n      { id: 'gpt-5.6-sol', name: 'GPT-5.6 Sol' },\n      { id: 'gpt-5.6-terra', name: 'GPT-5.6 Terra' },\n      { id: 'gpt-5.6-luna', name: 'GPT-5.6 Luna' },\n    ],\n  },\n  'google': {\n    id: 'google',\n    name: 'Google',\n    models: [\n      { id: 'gemini-3.7-flash', name: 'Gemini 3.7 Flash' },\n      { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro' },\n    ],\n  },\n  'xai': {\n    id: 'xai',\n    name: 'xAI (Grok)',\n    models: [\n      { id: 'grok-4.6', name: 'Grok 4.6' },\n      { id: 'grok-4.5', name: 'Grok 4.5' },\n      { id: 'grok-4.3', name: 'Grok 4.3' },\n    ],\n  },\n  'amazon-bedrock': {\n    id: 'amazon-bedrock',\n    name: 'Amazon Bedrock',\n    // Bedrock ids are region-scoped cross-region inference profiles; the `us.`\n    // prefix targets US regions — swap the prefix (eu./apac./…) to match your\n    // deploy region, and confirm availability in the Bedrock console.\n    models: [\n      { id: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0', name: 'Claude Sonnet 4.5' },\n      { id: 'us.amazon.nova-pro-v1:0', name: 'Amazon Nova Pro' },\n      { id: 'us.amazon.nova-lite-v1:0', name: 'Amazon Nova Lite' },\n    ],\n  },\n};\n\n/**\n * Environment variable names for each AI provider's API key.\n * Used by backend services to initialize the provider registry.\n */\nexport const AI_PROVIDER_ENV_VARS: Record<string, string> = {\n  'anthropic': 'ANTHROPIC_API_KEY',\n  'openai': 'OPENAI_API_KEY',\n  'google': 'GOOGLE_GENERATIVE_AI_API_KEY',\n  'xai': 'XAI_API_KEY',\n  'amazon-bedrock': 'AWS_ACCESS_KEY_ID',\n};\n\n/**\n * Provider id for a self-hosted, OpenAI-compatible endpoint — a Docker model image\n * (Ollama, Docker Model Runner, vLLM) or any other server that speaks the OpenAI\n * chat API. Unlike the fixed providers above, this one is NOT in the static catalog:\n * its endpoint and model list are deployment-defined and resolved from env at\n * runtime by {@link getOpenAICompatibleProvider}.\n */\nexport const OPENAI_COMPATIBLE_PROVIDER_ID = 'openai-compatible';\n\n/**\n * Parse a `id[|Display Name][,id2[|Name2]]` env string into model metadata. The\n * id/name separator is `|` (NOT `:`) because model ids commonly contain colons —\n * e.g. Ollama tags (`qwen2.5-coder:7b`) and Bedrock inference profiles.\n */\nfunction parseModelList(raw: string): AIModelInfo[] {\n  return raw\n    .split(',')\n    .map((s) => s.trim())\n    .filter(Boolean)\n    .map((entry) => {\n      const idx = entry.indexOf('|');\n      const id = (idx === -1 ? entry : entry.slice(0, idx)).trim();\n      const name = (idx === -1 ? '' : entry.slice(idx + 1)).trim() || id;\n      return { id, name };\n    })\n    .filter((m) => m.id.length > 0);\n}\n\n/**\n * Resolve the OpenAI-compatible (local / self-hosted) provider from env, or `null`\n * when no endpoint is configured. Enabled by `OPENAI_COMPATIBLE_BASE_URL`; the model\n * list comes from `OPENAI_COMPATIBLE_MODELS` (comma list of `id[|Display Name]`),\n * falling back to `OPENAI_COMPATIBLE_MODEL`, then a generic `local` id. The display\n * name is overridable via `OPENAI_COMPATIBLE_NAME`.\n *\n * @returns Provider info for the configured local endpoint, or null if unset\n */\nexport function getOpenAICompatibleProvider(): AIProviderInfo | null {\n  const baseURL = process.env.OPENAI_COMPATIBLE_BASE_URL;\n  if (!baseURL) return null;\n  const raw = process.env.OPENAI_COMPATIBLE_MODELS ?? process.env.OPENAI_COMPATIBLE_MODEL ?? 'local|Local model';\n  const models = parseModelList(raw);\n  return {\n    id: OPENAI_COMPATIBLE_PROVIDER_ID,\n    name: process.env.OPENAI_COMPATIBLE_NAME || 'Local model (OpenAI-compatible)',\n    models: models.length > 0 ? models : [{ id: 'local', name: 'Local model' }],\n  };\n}\n\n// Helpers\n\n/**\n * Get the model list for a given provider ID.\n *\n * @param providerId - Provider identifier (e.g. \"anthropic\")\n * @returns Array of models, or empty array if the provider is unknown\n */\nexport function getAIProviderModels(providerId: string): AIModelInfo[] {\n  if (providerId === OPENAI_COMPATIBLE_PROVIDER_ID) {\n    return getOpenAICompatibleProvider()?.models ?? [];\n  }\n  return AI_PROVIDER_CATALOG[providerId]?.models ?? [];\n}\n"]}

package/lib/helpers/access-helpers.d.ts

@@ -1,22 +1,63 @@
 import type { Request, Response } from 'express';
 import type { Permission } from '../types/permissions.js';
+import type { Visibility } from '../types/visibility.js';
+/** The slice of a catalog entity the write gate needs. */
+export interface VisibilityWriteTarget {
+    /** Rung the row currently sits at — see {@link Visibility}. */
+    visibility?: string;
+    /** Author. The only non-admin who may touch a `private` row. */
+    createdBy?: string;
+}
 /**
- * Check whether a non-admin user may modify a public resource.
+ * Check whether the caller may modify a catalog entity, per its visibility rung.
+ * The single write gate behind every pipeline / plugin / template mutation.
  *
- * Returns `true` if the request may proceed. Returns `false` and sends
- * a 403 response if the user lacks permission.
+ * - `public` — a system admin, or the holder of `publishPermission` (the same
+ *   permission that let them publish it in the first place, so whoever can
+ *   publish can also manage what they published)
+ * - `org` — anyone who got this far: the resource's `:write` permission plus the
+ *   org scoping the caller already passed IS the gate
+ * - `private` — the AUTHOR alone (plus system admins)
  *
- * @param req - Express request
- * @param res - Express response
- * @param resource - Resource with an accessModifier field
- * @returns `true` if access is allowed, `false` if blocked (response already sent)
+ * The `private` branch is load-bearing on the TOMBSTONE paths (restore / purge),
+ * which are org-scoped rather than visibility-scoped because soft-delete is one
+ * shared code path — without it, any org member could resurrect someone else's
+ * personal draft. On the live paths the read predicate has already hidden the
+ * row, making this defense in depth.
+ *
+ * Returns `true` if the request may proceed; returns `false` having ALREADY sent
+ * a 403.
  *
  * @example
  * ```typescript
- * if (!requirePublicAccess(req, res, pipeline)) return;
+ * if (!requireVisibilityWriteAccess(req, res, pipeline, userId, 'pipelines:publish')) return;
  * await pipelineService.delete(id, orgId, userId);
  * ```
  */
-export declare function requirePublicAccess(req: Request, res: Response, resource: {
-    accessModifier?: string;
-}, publishPermission?: Permission): boolean;
+export declare function requireVisibilityWriteAccess(req: Request, res: Response, resource: VisibilityWriteTarget, userId: string, publishPermission: Permission): boolean;
+/**
+ * Resolve the effective visibility for an entity being created or updated.
+ *
+ * `public` requires the publish capability (superadmins pass via implicit-all);
+ * a caller who asks for it without the permission is clamped to `org` rather
+ * than dropped to a personal draft — they asked to SHARE it, and `org` is the
+ * widest rung they are entitled to. Anything else passes through.
+ *
+ * `fallback` is the rung an UNSPECIFIED visibility lands on, and it is
+ * deliberately per-entity even though the ladder itself is identical everywhere:
+ *
+ * - **templates** default to `private` — draft-first is the whole point of the
+ *   personal rung; you polish a starter before publishing it.
+ * - **pipelines / plugins** default to `org` — they are team assets that deploy
+ *   shared infrastructure, so creating one must not hide it from the team. A
+ *   personal draft stays available, but opt-in.
+ *
+ * Same ladder, same gate, different centre of gravity — expressed as an argument
+ * rather than a second code path.
+ *
+ * Permission-based (not coarse-role-based): a bespoke custom Role can be granted
+ * publish rights and is no longer forced private by its `member` label. Built-in
+ * Admin/Owner bundles carry the publish permissions; the built-in Member bundle
+ * does not, so members top out at `org`.
+ */
+export declare function resolveVisibility(req: Request, requested: string | undefined, publishPermission: Permission, fallback?: Visibility): Visibility;

package/lib/helpers/access-helpers.js

@@ -2,36 +2,81 @@
 // SPDX-License-Identifier: Apache-2.0
 import { isSystemAdmin, userHasPermission } from '../middleware/auth.js';
 import { ErrorCode } from '../types/error-codes.js';
-import { AccessModifier } from '../types/pipeline.js';
 import { sendError } from '../utils/response.js';
 /**
- * Check whether a non-admin user may modify a public resource.
+ * Check whether the caller may modify a catalog entity, per its visibility rung.
+ * The single write gate behind every pipeline / plugin / template mutation.
  *
- * Returns `true` if the request may proceed. Returns `false` and sends
- * a 403 response if the user lacks permission.
+ * - `public` — a system admin, or the holder of `publishPermission` (the same
+ *   permission that let them publish it in the first place, so whoever can
+ *   publish can also manage what they published)
+ * - `org` — anyone who got this far: the resource's `:write` permission plus the
+ *   org scoping the caller already passed IS the gate
+ * - `private` — the AUTHOR alone (plus system admins)
  *
- * @param req - Express request
- * @param res - Express response
- * @param resource - Resource with an accessModifier field
- * @returns `true` if access is allowed, `false` if blocked (response already sent)
+ * The `private` branch is load-bearing on the TOMBSTONE paths (restore / purge),
+ * which are org-scoped rather than visibility-scoped because soft-delete is one
+ * shared code path — without it, any org member could resurrect someone else's
+ * personal draft. On the live paths the read predicate has already hidden the
+ * row, making this defense in depth.
+ *
+ * Returns `true` if the request may proceed; returns `false` having ALREADY sent
+ * a 403.
  *
  * @example
  * ```typescript
- * if (!requirePublicAccess(req, res, pipeline)) return;
+ * if (!requireVisibilityWriteAccess(req, res, pipeline, userId, 'pipelines:publish')) return;
  * await pipelineService.delete(id, orgId, userId);
  * ```
  */
-export function requirePublicAccess(req, res, resource, publishPermission) {
-    // Private resources: no extra gate (org-scoping already applies). Public/non-private:
-    // a system admin OR the holder of the matching publish permission may modify it — so
-    // the same permission that let a non-superadmin PUBLISH it (create path) also lets
-    // them manage it. The write itself stays pinned to the caller's org, so this never
-    // grants cross-org reach. Without a publishPermission, it stays superadmin-only.
-    const mayModify = isSystemAdmin(req) || (!!publishPermission && userHasPermission(req, publishPermission));
-    if (!mayModify && resource.accessModifier !== AccessModifier.PRIVATE) {
+export function requireVisibilityWriteAccess(req, res, resource, userId, publishPermission) {
+    if (isSystemAdmin(req))
+        return true;
+    if (resource.visibility === 'public' && !userHasPermission(req, publishPermission)) {
         sendError(res, 403, 'You lack permission to modify this public resource.', ErrorCode.INSUFFICIENT_PERMISSIONS);
         return false;
     }
+    // Fail closed on an anonymous/absent caller — an empty userId must never match
+    // an empty `createdBy` and hand over someone else's draft.
+    if (resource.visibility === 'private' && (!userId || resource.createdBy !== userId)) {
+        sendError(res, 403, 'Only the author can modify a private resource.', ErrorCode.INSUFFICIENT_PERMISSIONS);
+        return false;
+    }
     return true;
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Resolve the effective visibility for an entity being created or updated.
+ *
+ * `public` requires the publish capability (superadmins pass via implicit-all);
+ * a caller who asks for it without the permission is clamped to `org` rather
+ * than dropped to a personal draft — they asked to SHARE it, and `org` is the
+ * widest rung they are entitled to. Anything else passes through.
+ *
+ * `fallback` is the rung an UNSPECIFIED visibility lands on, and it is
+ * deliberately per-entity even though the ladder itself is identical everywhere:
+ *
+ * - **templates** default to `private` — draft-first is the whole point of the
+ *   personal rung; you polish a starter before publishing it.
+ * - **pipelines / plugins** default to `org` — they are team assets that deploy
+ *   shared infrastructure, so creating one must not hide it from the team. A
+ *   personal draft stays available, but opt-in.
+ *
+ * Same ladder, same gate, different centre of gravity — expressed as an argument
+ * rather than a second code path.
+ *
+ * Permission-based (not coarse-role-based): a bespoke custom Role can be granted
+ * publish rights and is no longer forced private by its `member` label. Built-in
+ * Admin/Owner bundles carry the publish permissions; the built-in Member bundle
+ * does not, so members top out at `org`.
+ */
+export function resolveVisibility(req, requested, publishPermission, fallback = 'private') {
+    if (requested === 'public') {
+        return userHasPermission(req, publishPermission) ? 'public' : 'org';
+    }
+    if (requested === 'org')
+        return 'org';
+    if (requested === 'private')
+        return 'private';
+    return fallback;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjZXNzLWhlbHBlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGVscGVycy9hY2Nlc3MtaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBR3RDLE9BQU8sRUFBRSxhQUFhLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN6RSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFHcEQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBVWpEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBeUJHO0FBQ0gsTUFBTSxVQUFVLDRCQUE0QixDQUMxQyxHQUFZLEVBQ1osR0FBYSxFQUNiLFFBQStCLEVBQy9CLE1BQWMsRUFDZCxpQkFBNkI7SUFFN0IsSUFBSSxhQUFhLENBQUMsR0FBRyxDQUFDO1FBQUUsT0FBTyxJQUFJLENBQUM7SUFFcEMsSUFBSSxRQUFRLENBQUMsVUFBVSxLQUFLLFFBQVEsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEdBQUcsRUFBRSxpQkFBaUIsQ0FBQyxFQUFFLENBQUM7UUFDbkYsU0FBUyxDQUNQLEdBQUcsRUFDSCxHQUFHLEVBQ0gscURBQXFELEVBQ3JELFNBQVMsQ0FBQyx3QkFBd0IsQ0FDbkMsQ0FBQztRQUNGLE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUVELCtFQUErRTtJQUMvRSwyREFBMkQ7SUFDM0QsSUFBSSxRQUFRLENBQUMsVUFBVSxLQUFLLFNBQVMsSUFBSSxDQUFDLENBQUMsTUFBTSxJQUFJLFFBQVEsQ0FBQyxTQUFTLEtBQUssTUFBTSxDQUFDLEVBQUUsQ0FBQztRQUNwRixTQUFTLENBQ1AsR0FBRyxFQUNILEdBQUcsRUFDSCxnREFBZ0QsRUFDaEQsU0FBUyxDQUFDLHdCQUF3QixDQUNuQyxDQUFDO1FBQ0YsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXdCRztBQUNILE1BQU0sVUFBVSxpQkFBaUIsQ0FDL0IsR0FBWSxFQUNaLFNBQTZCLEVBQzdCLGlCQUE2QixFQUM3QixRQUFRLEdBQWUsU0FBUztJQUVoQyxJQUFJLFNBQVMsS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUMzQixPQUFPLGlCQUFpQixDQUFDLEdBQUcsRUFBRSxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQztJQUN0RSxDQUFDO0lBQ0QsSUFBSSxTQUFTLEtBQUssS0FBSztRQUFFLE9BQU8sS0FBSyxDQUFDO0lBQ3RDLElBQUksU0FBUyxLQUFLLFNBQVM7UUFBRSxPQUFPLFNBQVMsQ0FBQztJQUM5QyxPQUFPLFFBQVEsQ0FBQztBQUNsQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmltcG9ydCB0eXBlIHsgUmVxdWVzdCwgUmVzcG9uc2UgfSBmcm9tICdleHByZXNzJztcbmltcG9ydCB7IGlzU3lzdGVtQWRtaW4sIHVzZXJIYXNQZXJtaXNzaW9uIH0gZnJvbSAnLi4vbWlkZGxld2FyZS9hdXRoLmpzJztcbmltcG9ydCB7IEVycm9yQ29kZSB9IGZyb20gJy4uL3R5cGVzL2Vycm9yLWNvZGVzLmpzJztcbmltcG9ydCB0eXBlIHsgUGVybWlzc2lvbiB9IGZyb20gJy4uL3R5cGVzL3Blcm1pc3Npb25zLmpzJztcbmltcG9ydCB0eXBlIHsgVmlzaWJpbGl0eSB9IGZyb20gJy4uL3R5cGVzL3Zpc2liaWxpdHkuanMnO1xuaW1wb3J0IHsgc2VuZEVycm9yIH0gZnJvbSAnLi4vdXRpbHMvcmVzcG9uc2UuanMnO1xuXG4vKiogVGhlIHNsaWNlIG9mIGEgY2F0YWxvZyBlbnRpdHkgdGhlIHdyaXRlIGdhdGUgbmVlZHMuICovXG5leHBvcnQgaW50ZXJmYWNlIFZpc2liaWxpdHlXcml0ZVRhcmdldCB7XG4gIC8qKiBSdW5nIHRoZSByb3cgY3VycmVudGx5IHNpdHMgYXQg4oCUIHNlZSB7QGxpbmsgVmlzaWJpbGl0eX0uICovXG4gIHZpc2liaWxpdHk/OiBzdHJpbmc7XG4gIC8qKiBBdXRob3IuIFRoZSBvbmx5IG5vbi1hZG1pbiB3aG8gbWF5IHRvdWNoIGEgYHByaXZhdGVgIHJvdy4gKi9cbiAgY3JlYXRlZEJ5Pzogc3RyaW5nO1xufVxuXG4vKipcbiAqIENoZWNrIHdoZXRoZXIgdGhlIGNhbGxlciBtYXkgbW9kaWZ5IGEgY2F0YWxvZyBlbnRpdHksIHBlciBpdHMgdmlzaWJpbGl0eSBydW5nLlxuICogVGhlIHNpbmdsZSB3cml0ZSBnYXRlIGJlaGluZCBldmVyeSBwaXBlbGluZSAvIHBsdWdpbiAvIHRlbXBsYXRlIG11dGF0aW9uLlxuICpcbiAqIC0gYHB1YmxpY2Ag4oCUIGEgc3lzdGVtIGFkbWluLCBvciB0aGUgaG9sZGVyIG9mIGBwdWJsaXNoUGVybWlzc2lvbmAgKHRoZSBzYW1lXG4gKiAgIHBlcm1pc3Npb24gdGhhdCBsZXQgdGhlbSBwdWJsaXNoIGl0IGluIHRoZSBmaXJzdCBwbGFjZSwgc28gd2hvZXZlciBjYW5cbiAqICAgcHVibGlzaCBjYW4gYWxzbyBtYW5hZ2Ugd2hhdCB0aGV5IHB1Ymxpc2hlZClcbiAqIC0gYG9yZ2Ag4oCUIGFueW9uZSB3aG8gZ290IHRoaXMgZmFyOiB0aGUgcmVzb3VyY2UncyBgOndyaXRlYCBwZXJtaXNzaW9uIHBsdXMgdGhlXG4gKiAgIG9yZyBzY29waW5nIHRoZSBjYWxsZXIgYWxyZWFkeSBwYXNzZWQgSVMgdGhlIGdhdGVcbiAqIC0gYHByaXZhdGVgIOKAlCB0aGUgQVVUSE9SIGFsb25lIChwbHVzIHN5c3RlbSBhZG1pbnMpXG4gKlxuICogVGhlIGBwcml2YXRlYCBicmFuY2ggaXMgbG9hZC1iZWFyaW5nIG9uIHRoZSBUT01CU1RPTkUgcGF0aHMgKHJlc3RvcmUgLyBwdXJnZSksXG4gKiB3aGljaCBhcmUgb3JnLXNjb3BlZCByYXRoZXIgdGhhbiB2aXNpYmlsaXR5LXNjb3BlZCBiZWNhdXNlIHNvZnQtZGVsZXRlIGlzIG9uZVxuICogc2hhcmVkIGNvZGUgcGF0aCDigJQgd2l0aG91dCBpdCwgYW55IG9yZyBtZW1iZXIgY291bGQgcmVzdXJyZWN0IHNvbWVvbmUgZWxzZSdzXG4gKiBwZXJzb25hbCBkcmFmdC4gT24gdGhlIGxpdmUgcGF0aHMgdGhlIHJlYWQgcHJlZGljYXRlIGhhcyBhbHJlYWR5IGhpZGRlbiB0aGVcbiAqIHJvdywgbWFraW5nIHRoaXMgZGVmZW5zZSBpbiBkZXB0aC5cbiAqXG4gKiBSZXR1cm5zIGB0cnVlYCBpZiB0aGUgcmVxdWVzdCBtYXkgcHJvY2VlZDsgcmV0dXJucyBgZmFsc2VgIGhhdmluZyBBTFJFQURZIHNlbnRcbiAqIGEgNDAzLlxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBpZiAoIXJlcXVpcmVWaXNpYmlsaXR5V3JpdGVBY2Nlc3MocmVxLCByZXMsIHBpcGVsaW5lLCB1c2VySWQsICdwaXBlbGluZXM6cHVibGlzaCcpKSByZXR1cm47XG4gKiBhd2FpdCBwaXBlbGluZVNlcnZpY2UuZGVsZXRlKGlkLCBvcmdJZCwgdXNlcklkKTtcbiAqIGBgYFxuICovXG5leHBvcnQgZnVuY3Rpb24gcmVxdWlyZVZpc2liaWxpdHlXcml0ZUFjY2VzcyhcbiAgcmVxOiBSZXF1ZXN0LFxuICByZXM6IFJlc3BvbnNlLFxuICByZXNvdXJjZTogVmlzaWJpbGl0eVdyaXRlVGFyZ2V0LFxuICB1c2VySWQ6IHN0cmluZyxcbiAgcHVibGlzaFBlcm1pc3Npb246IFBlcm1pc3Npb24sXG4pOiBib29sZWFuIHtcbiAgaWYgKGlzU3lzdGVtQWRtaW4ocmVxKSkgcmV0dXJuIHRydWU7XG5cbiAgaWYgKHJlc291cmNlLnZpc2liaWxpdHkgPT09ICdwdWJsaWMnICYmICF1c2VySGFzUGVybWlzc2lvbihyZXEsIHB1Ymxpc2hQZXJtaXNzaW9uKSkge1xuICAgIHNlbmRFcnJvcihcbiAgICAgIHJlcyxcbiAgICAgIDQwMyxcbiAgICAgICdZb3UgbGFjayBwZXJtaXNzaW9uIHRvIG1vZGlmeSB0aGlzIHB1YmxpYyByZXNvdXJjZS4nLFxuICAgICAgRXJyb3JDb2RlLklOU1VGRklDSUVOVF9QRVJNSVNTSU9OUyxcbiAgICApO1xuICAgIHJldHVybiBmYWxzZTtcbiAgfVxuXG4gIC8vIEZhaWwgY2xvc2VkIG9uIGFuIGFub255bW91cy9hYnNlbnQgY2FsbGVyIOKAlCBhbiBlbXB0eSB1c2VySWQgbXVzdCBuZXZlciBtYXRjaFxuICAvLyBhbiBlbXB0eSBgY3JlYXRlZEJ5YCBhbmQgaGFuZCBvdmVyIHNvbWVvbmUgZWxzZSdzIGRyYWZ0LlxuICBpZiAocmVzb3VyY2UudmlzaWJpbGl0eSA9PT0gJ3ByaXZhdGUnICYmICghdXNlcklkIHx8IHJlc291cmNlLmNyZWF0ZWRCeSAhPT0gdXNlcklkKSkge1xuICAgIHNlbmRFcnJvcihcbiAgICAgIHJlcyxcbiAgICAgIDQwMyxcbiAgICAgICdPbmx5IHRoZSBhdXRob3IgY2FuIG1vZGlmeSBhIHByaXZhdGUgcmVzb3VyY2UuJyxcbiAgICAgIEVycm9yQ29kZS5JTlNVRkZJQ0lFTlRfUEVSTUlTU0lPTlMsXG4gICAgKTtcbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cblxuICByZXR1cm4gdHJ1ZTtcbn1cblxuLyoqXG4gKiBSZXNvbHZlIHRoZSBlZmZlY3RpdmUgdmlzaWJpbGl0eSBmb3IgYW4gZW50aXR5IGJlaW5nIGNyZWF0ZWQgb3IgdXBkYXRlZC5cbiAqXG4gKiBgcHVibGljYCByZXF1aXJlcyB0aGUgcHVibGlzaCBjYXBhYmlsaXR5IChzdXBlcmFkbWlucyBwYXNzIHZpYSBpbXBsaWNpdC1hbGwpO1xuICogYSBjYWxsZXIgd2hvIGFza3MgZm9yIGl0IHdpdGhvdXQgdGhlIHBlcm1pc3Npb24gaXMgY2xhbXBlZCB0byBgb3JnYCByYXRoZXJcbiAqIHRoYW4gZHJvcHBlZCB0byBhIHBlcnNvbmFsIGRyYWZ0IOKAlCB0aGV5IGFza2VkIHRvIFNIQVJFIGl0LCBhbmQgYG9yZ2AgaXMgdGhlXG4gKiB3aWRlc3QgcnVuZyB0aGV5IGFyZSBlbnRpdGxlZCB0by4gQW55dGhpbmcgZWxzZSBwYXNzZXMgdGhyb3VnaC5cbiAqXG4gKiBgZmFsbGJhY2tgIGlzIHRoZSBydW5nIGFuIFVOU1BFQ0lGSUVEIHZpc2liaWxpdHkgbGFuZHMgb24sIGFuZCBpdCBpc1xuICogZGVsaWJlcmF0ZWx5IHBlci1lbnRpdHkgZXZlbiB0aG91Z2ggdGhlIGxhZGRlciBpdHNlbGYgaXMgaWRlbnRpY2FsIGV2ZXJ5d2hlcmU6XG4gKlxuICogLSAqKnRlbXBsYXRlcyoqIGRlZmF1bHQgdG8gYHByaXZhdGVgIOKAlCBkcmFmdC1maXJzdCBpcyB0aGUgd2hvbGUgcG9pbnQgb2YgdGhlXG4gKiAgIHBlcnNvbmFsIHJ1bmc7IHlvdSBwb2xpc2ggYSBzdGFydGVyIGJlZm9yZSBwdWJsaXNoaW5nIGl0LlxuICogLSAqKnBpcGVsaW5lcyAvIHBsdWdpbnMqKiBkZWZhdWx0IHRvIGBvcmdgIOKAlCB0aGV5IGFyZSB0ZWFtIGFzc2V0cyB0aGF0IGRlcGxveVxuICogICBzaGFyZWQgaW5mcmFzdHJ1Y3R1cmUsIHNvIGNyZWF0aW5nIG9uZSBtdXN0IG5vdCBoaWRlIGl0IGZyb20gdGhlIHRlYW0uIEFcbiAqICAgcGVyc29uYWwgZHJhZnQgc3RheXMgYXZhaWxhYmxlLCBidXQgb3B0LWluLlxuICpcbiAqIFNhbWUgbGFkZGVyLCBzYW1lIGdhdGUsIGRpZmZlcmVudCBjZW50cmUgb2YgZ3Jhdml0eSDigJQgZXhwcmVzc2VkIGFzIGFuIGFyZ3VtZW50XG4gKiByYXRoZXIgdGhhbiBhIHNlY29uZCBjb2RlIHBhdGguXG4gKlxuICogUGVybWlzc2lvbi1iYXNlZCAobm90IGNvYXJzZS1yb2xlLWJhc2VkKTogYSBiZXNwb2tlIGN1c3RvbSBSb2xlIGNhbiBiZSBncmFudGVkXG4gKiBwdWJsaXNoIHJpZ2h0cyBhbmQgaXMgbm8gbG9uZ2VyIGZvcmNlZCBwcml2YXRlIGJ5IGl0cyBgbWVtYmVyYCBsYWJlbC4gQnVpbHQtaW5cbiAqIEFkbWluL093bmVyIGJ1bmRsZXMgY2FycnkgdGhlIHB1Ymxpc2ggcGVybWlzc2lvbnM7IHRoZSBidWlsdC1pbiBNZW1iZXIgYnVuZGxlXG4gKiBkb2VzIG5vdCwgc28gbWVtYmVycyB0b3Agb3V0IGF0IGBvcmdgLlxuICovXG5leHBvcnQgZnVuY3Rpb24gcmVzb2x2ZVZpc2liaWxpdHkoXG4gIHJlcTogUmVxdWVzdCxcbiAgcmVxdWVzdGVkOiBzdHJpbmcgfCB1bmRlZmluZWQsXG4gIHB1Ymxpc2hQZXJtaXNzaW9uOiBQZXJtaXNzaW9uLFxuICBmYWxsYmFjazogVmlzaWJpbGl0eSA9ICdwcml2YXRlJyxcbik6IFZpc2liaWxpdHkge1xuICBpZiAocmVxdWVzdGVkID09PSAncHVibGljJykge1xuICAgIHJldHVybiB1c2VySGFzUGVybWlzc2lvbihyZXEsIHB1Ymxpc2hQZXJtaXNzaW9uKSA/ICdwdWJsaWMnIDogJ29yZyc7XG4gIH1cbiAgaWYgKHJlcXVlc3RlZCA9PT0gJ29yZycpIHJldHVybiAnb3JnJztcbiAgaWYgKHJlcXVlc3RlZCA9PT0gJ3ByaXZhdGUnKSByZXR1cm4gJ3ByaXZhdGUnO1xuICByZXR1cm4gZmFsbGJhY2s7XG59XG4iXX0=

package/lib/helpers/restore-helpers.d.ts

@@ -3,7 +3,10 @@ import type { Permission } from '../types/permissions.js';
 /** Minimal shape a restore route needs from the entity it restores. */
 export interface RestorableEntity {
     orgId: string;
-    accessModifier?: string;
+    /** Rung the tombstone sat at — drives the restore/purge authority check. */
+    visibility?: string;
+    /** Author — the only non-admin who may restore/purge a `private` row. */
+    createdBy?: string;
 }
 /** The slice of a service a restore route uses (satisfied by any CrudService). */
 export interface RestorableService<T extends RestorableEntity> {
@@ -12,8 +15,8 @@ export interface RestorableService<T extends RestorableEntity> {
 }
 /**
  * Shared skeleton for a step-up-gated entity restore route: extract `:id`, load
- * the own-org tombstone, gate a PUBLIC entity on `publishPermission` (parity with
- * delete), restore, and 404 on miss. Returns `{ existing, restored }` on success,
+ * the own-org tombstone, gate it on the visibility ladder (parity with delete),
+ * restore, and 404 on miss. Returns `{ existing, restored }` on success,
  * or `null` when it has ALREADY sent a response (400/404/403) — the caller then
  * does the entity-specific audit + response. DRYs the near-identical
  * pipeline / plugin / pipeline_template restore routes (which differ only in
@@ -30,7 +33,7 @@ export interface PurgeableService<T extends RestorableEntity> {
 }
 /**
  * Shared skeleton for an entity PURGE route: extract `:id`, load the own-org
- * tombstone, gate a PUBLIC entity on `publishPermission` (parity with
+ * tombstone, gate it on the visibility ladder (parity with
  * delete/restore), then permanently hard-delete it — but ONLY when it is a
  * genuine tombstone (a live/active row loads as `null` here and 404s, so purge
  * can never hard-delete a live row). Returns `{ existing, purgedId }` on success
@@ -40,7 +43,7 @@ export interface PurgeableService<T extends RestorableEntity> {
  * frontend gates it with an explicit confirm dialog. DRYs the near-identical
  * pipeline / pipeline_template purge routes.
  */
-export declare function loadAndPurge<T extends RestorableEntity>(req: Request, res: Response, orgId: string, service: PurgeableService<T>, label: string, publishPermission: Permission): Promise<{
+export declare function loadAndPurge<T extends RestorableEntity>(req: Request, res: Response, orgId: string, service: PurgeableService<T>, label: string, publishPermission: Permission, userId: string): Promise<{
     existing: T;
     purgedId: string;
 } | null>;

package/lib/helpers/restore-helpers.js

@@ -1,14 +1,14 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { requirePublicAccess } from './access-helpers.js';
+import { requireVisibilityWriteAccess } from './access-helpers.js';
 import { sendEntityNotFound } from './crud-helpers.js';
 import { ErrorCode } from '../types/error-codes.js';
 import { getParam } from '../utils/params.js';
 import { sendBadRequest } from '../utils/response.js';
 /**
  * Shared skeleton for a step-up-gated entity restore route: extract `:id`, load
- * the own-org tombstone, gate a PUBLIC entity on `publishPermission` (parity with
- * delete), restore, and 404 on miss. Returns `{ existing, restored }` on success,
+ * the own-org tombstone, gate it on the visibility ladder (parity with delete),
+ * restore, and 404 on miss. Returns `{ existing, restored }` on success,
  * or `null` when it has ALREADY sent a response (400/404/403) — the caller then
  * does the entity-specific audit + response. DRYs the near-identical
  * pipeline / plugin / pipeline_template restore routes (which differ only in
@@ -26,8 +26,10 @@ export async function loadAndRestore(req, res, orgId, userId, service, label, pu
         sendEntityNotFound(res, label);
         return null;
     }
-    // Public (shared) entities: same publish gate as delete.
-    if (!requirePublicAccess(req, res, existing, publishPermission))
+    // Same ladder authority as delete: `:publish` for a public row, authorship for
+    // a private one. Load-bearing here — the tombstone load is org-scoped, not
+    // visibility-scoped, so this is what stops a colleague resurrecting a draft.
+    if (!requireVisibilityWriteAccess(req, res, existing, userId || '', publishPermission))
         return null;
     const restored = await service.restore(id, orgId, userId || 'system');
     if (!restored) {
@@ -38,7 +40,7 @@ export async function loadAndRestore(req, res, orgId, userId, service, label, pu
 }
 /**
  * Shared skeleton for an entity PURGE route: extract `:id`, load the own-org
- * tombstone, gate a PUBLIC entity on `publishPermission` (parity with
+ * tombstone, gate it on the visibility ladder (parity with
  * delete/restore), then permanently hard-delete it — but ONLY when it is a
  * genuine tombstone (a live/active row loads as `null` here and 404s, so purge
  * can never hard-delete a live row). Returns `{ existing, purgedId }` on success
@@ -48,7 +50,7 @@ export async function loadAndRestore(req, res, orgId, userId, service, label, pu
  * frontend gates it with an explicit confirm dialog. DRYs the near-identical
  * pipeline / pipeline_template purge routes.
  */
-export async function loadAndPurge(req, res, orgId, service, label, publishPermission) {
+export async function loadAndPurge(req, res, orgId, service, label, publishPermission, userId) {
     const id = getParam(req.params, 'id');
     if (!id) {
         sendBadRequest(res, `${label} ID is required.`, ErrorCode.MISSING_REQUIRED_FIELD);
@@ -61,8 +63,8 @@ export async function loadAndPurge(req, res, orgId, service, label, publishPermi
         sendEntityNotFound(res, label);
         return null;
     }
-    // Public (shared) entities: same publish gate as delete/restore.
-    if (!requirePublicAccess(req, res, existing, publishPermission))
+    // Same ladder authority as delete/restore (see loadAndRestore).
+    if (!requireVisibilityWriteAccess(req, res, existing, userId || '', publishPermission))
         return null;
     // Reuse the retention sweep's single-id hard-delete (same tombstone match +
     // dependent-teardown hooks). Returns null on a race (already purged) → 404.
@@ -73,4 +75,4 @@ export async function loadAndPurge(req, res, orgId, service, label, publishPermi
     }
     return { existing, purgedId };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"restore-helpers.js","sourceRoot":"","sources":["../../src/helpers/restore-helpers.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAGtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AActD;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,GAAY,EACZ,GAAa,EACb,KAAa,EACb,MAAc,EACd,OAA6B,EAC7B,KAAa,EACb,iBAA6B;IAE7B,MAAM,EAAE,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACtC,IAAI,CAAC,EAAE,EAAE,CAAC;QACR,cAAc,CAAC,GAAG,EAAE,GAAG,KAAK,kBAAkB,EAAE,SAAS,CAAC,sBAAsB,CAAC,CAAC;QAClF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gFAAgF;IAChF,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,eAAe,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAC1D,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,kBAAkB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,yDAAyD;IACzD,IAAI,CAAC,mBAAmB,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,iBAAiB,CAAC;QAAE,OAAO,IAAI,CAAC;IAE7E,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,IAAI,QAAQ,CAAC,CAAC;IACtE,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,kBAAkB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAChC,CAAC;AAQD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,GAAY,EACZ,GAAa,EACb,KAAa,EACb,OAA4B,EAC5B,KAAa,EACb,iBAA6B;IAE7B,MAAM,EAAE,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACtC,IAAI,CAAC,EAAE,EAAE,CAAC;QACR,cAAc,CAAC,GAAG,EAAE,GAAG,KAAK,kBAAkB,EAAE,SAAS,CAAC,sBAAsB,CAAC,CAAC;QAClF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gFAAgF;IAChF,wEAAwE;IACxE,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,eAAe,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAC1D,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,kBAAkB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,iEAAiE;IACjE,IAAI,CAAC,mBAAmB,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,iBAAiB,CAAC;QAAE,OAAO,IAAI,CAAC;IAE7E,4EAA4E;IAC5E,4EAA4E;IAC5E,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IACpD,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,kBAAkB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAChC,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Request, Response } from 'express';\nimport { requirePublicAccess } from './access-helpers.js';\nimport { sendEntityNotFound } from './crud-helpers.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport type { Permission } from '../types/permissions.js';\nimport { getParam } from '../utils/params.js';\nimport { sendBadRequest } from '../utils/response.js';\n\n/** Minimal shape a restore route needs from the entity it restores. */\nexport interface RestorableEntity {\n  orgId: string;\n  accessModifier?: string;\n}\n\n/** The slice of a service a restore route uses (satisfied by any CrudService). */\nexport interface RestorableService<T extends RestorableEntity> {\n  findDeletedById(id: string, orgId?: string): Promise<T | null>;\n  restore(id: string, orgId: string, userId: string): Promise<T | null>;\n}\n\n/**\n * Shared skeleton for a step-up-gated entity restore route: extract `:id`, load\n * the own-org tombstone, gate a PUBLIC entity on `publishPermission` (parity with\n * delete), restore, and 404 on miss. Returns `{ existing, restored }` on success,\n * or `null` when it has ALREADY sent a response (400/404/403) — the caller then\n * does the entity-specific audit + response. DRYs the near-identical\n * pipeline / plugin / pipeline_template restore routes (which differ only in\n * service, audit action, and response shaping).\n */\nexport async function loadAndRestore<T extends RestorableEntity>(\n  req: Request,\n  res: Response,\n  orgId: string,\n  userId: string,\n  service: RestorableService<T>,\n  label: string,\n  publishPermission: Permission,\n): Promise<{ existing: T; restored: T } | null> {\n  const id = getParam(req.params, 'id');\n  if (!id) {\n    sendBadRequest(res, `${label} ID is required.`, ErrorCode.MISSING_REQUIRED_FIELD);\n    return null;\n  }\n\n  // Load the TOMBSTONE (own-org). A live row / unknown id / already-purged → 404.\n  const existing = await service.findDeletedById(id, orgId);\n  if (!existing) {\n    sendEntityNotFound(res, label);\n    return null;\n  }\n\n  // Public (shared) entities: same publish gate as delete.\n  if (!requirePublicAccess(req, res, existing, publishPermission)) return null;\n\n  const restored = await service.restore(id, orgId, userId || 'system');\n  if (!restored) {\n    sendEntityNotFound(res, label);\n    return null;\n  }\n\n  return { existing, restored };\n}\n\n/** The slice of a service a purge route uses (satisfied by any CrudService). */\nexport interface PurgeableService<T extends RestorableEntity> {\n  findDeletedById(id: string, orgId?: string): Promise<T | null>;\n  purgeById(id: string, orgId?: string): Promise<string | null>;\n}\n\n/**\n * Shared skeleton for an entity PURGE route: extract `:id`, load the own-org\n * tombstone, gate a PUBLIC entity on `publishPermission` (parity with\n * delete/restore), then permanently hard-delete it — but ONLY when it is a\n * genuine tombstone (a live/active row loads as `null` here and 404s, so purge\n * can never hard-delete a live row). Returns `{ existing, purgedId }` on success\n * (the caller emits the entity-specific audit off `existing`), or `null` when it\n * has ALREADY sent a response (400/404/403). Purge is intentionally NOT step-up\n * gated: it only finalizes what the retention sweep would remove anyway, and the\n * frontend gates it with an explicit confirm dialog. DRYs the near-identical\n * pipeline / pipeline_template purge routes.\n */\nexport async function loadAndPurge<T extends RestorableEntity>(\n  req: Request,\n  res: Response,\n  orgId: string,\n  service: PurgeableService<T>,\n  label: string,\n  publishPermission: Permission,\n): Promise<{ existing: T; purgedId: string } | null> {\n  const id = getParam(req.params, 'id');\n  if (!id) {\n    sendBadRequest(res, `${label} ID is required.`, ErrorCode.MISSING_REQUIRED_FIELD);\n    return null;\n  }\n\n  // Load the TOMBSTONE (own-org). A live row / unknown id / already-purged → 404,\n  // so a currently-active entity is never hard-deleted through this path.\n  const existing = await service.findDeletedById(id, orgId);\n  if (!existing) {\n    sendEntityNotFound(res, label);\n    return null;\n  }\n\n  // Public (shared) entities: same publish gate as delete/restore.\n  if (!requirePublicAccess(req, res, existing, publishPermission)) return null;\n\n  // Reuse the retention sweep's single-id hard-delete (same tombstone match +\n  // dependent-teardown hooks). Returns null on a race (already purged) → 404.\n  const purgedId = await service.purgeById(id, orgId);\n  if (!purgedId) {\n    sendEntityNotFound(res, label);\n    return null;\n  }\n\n  return { existing, purgedId };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"restore-helpers.js","sourceRoot":"","sources":["../../src/helpers/restore-helpers.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAGtC,OAAO,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAiBtD;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,GAAY,EACZ,GAAa,EACb,KAAa,EACb,MAAc,EACd,OAA6B,EAC7B,KAAa,EACb,iBAA6B;IAE7B,MAAM,EAAE,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACtC,IAAI,CAAC,EAAE,EAAE,CAAC;QACR,cAAc,CAAC,GAAG,EAAE,GAAG,KAAK,kBAAkB,EAAE,SAAS,CAAC,sBAAsB,CAAC,CAAC;QAClF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gFAAgF;IAChF,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,eAAe,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAC1D,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,kBAAkB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,+EAA+E;IAC/E,2EAA2E;IAC3E,6EAA6E;IAC7E,IAAI,CAAC,4BAA4B,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,IAAI,EAAE,EAAE,iBAAiB,CAAC;QAAE,OAAO,IAAI,CAAC;IAEpG,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,IAAI,QAAQ,CAAC,CAAC;IACtE,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,kBAAkB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAChC,CAAC;AAQD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,GAAY,EACZ,GAAa,EACb,KAAa,EACb,OAA4B,EAC5B,KAAa,EACb,iBAA6B,EAC7B,MAAc;IAEd,MAAM,EAAE,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACtC,IAAI,CAAC,EAAE,EAAE,CAAC;QACR,cAAc,CAAC,GAAG,EAAE,GAAG,KAAK,kBAAkB,EAAE,SAAS,CAAC,sBAAsB,CAAC,CAAC;QAClF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gFAAgF;IAChF,wEAAwE;IACxE,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,eAAe,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAC1D,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,kBAAkB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gEAAgE;IAChE,IAAI,CAAC,4BAA4B,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,IAAI,EAAE,EAAE,iBAAiB,CAAC;QAAE,OAAO,IAAI,CAAC;IAEpG,4EAA4E;IAC5E,4EAA4E;IAC5E,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IACpD,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,kBAAkB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAChC,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Request, Response } from 'express';\nimport { requireVisibilityWriteAccess } from './access-helpers.js';\nimport { sendEntityNotFound } from './crud-helpers.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport type { Permission } from '../types/permissions.js';\nimport { getParam } from '../utils/params.js';\nimport { sendBadRequest } from '../utils/response.js';\n\n/** Minimal shape a restore route needs from the entity it restores. */\nexport interface RestorableEntity {\n  orgId: string;\n  /** Rung the tombstone sat at — drives the restore/purge authority check. */\n  visibility?: string;\n  /** Author — the only non-admin who may restore/purge a `private` row. */\n  createdBy?: string;\n}\n\n/** The slice of a service a restore route uses (satisfied by any CrudService). */\nexport interface RestorableService<T extends RestorableEntity> {\n  findDeletedById(id: string, orgId?: string): Promise<T | null>;\n  restore(id: string, orgId: string, userId: string): Promise<T | null>;\n}\n\n/**\n * Shared skeleton for a step-up-gated entity restore route: extract `:id`, load\n * the own-org tombstone, gate it on the visibility ladder (parity with delete),\n * restore, and 404 on miss. Returns `{ existing, restored }` on success,\n * or `null` when it has ALREADY sent a response (400/404/403) — the caller then\n * does the entity-specific audit + response. DRYs the near-identical\n * pipeline / plugin / pipeline_template restore routes (which differ only in\n * service, audit action, and response shaping).\n */\nexport async function loadAndRestore<T extends RestorableEntity>(\n  req: Request,\n  res: Response,\n  orgId: string,\n  userId: string,\n  service: RestorableService<T>,\n  label: string,\n  publishPermission: Permission,\n): Promise<{ existing: T; restored: T } | null> {\n  const id = getParam(req.params, 'id');\n  if (!id) {\n    sendBadRequest(res, `${label} ID is required.`, ErrorCode.MISSING_REQUIRED_FIELD);\n    return null;\n  }\n\n  // Load the TOMBSTONE (own-org). A live row / unknown id / already-purged → 404.\n  const existing = await service.findDeletedById(id, orgId);\n  if (!existing) {\n    sendEntityNotFound(res, label);\n    return null;\n  }\n\n  // Same ladder authority as delete: `:publish` for a public row, authorship for\n  // a private one. Load-bearing here — the tombstone load is org-scoped, not\n  // visibility-scoped, so this is what stops a colleague resurrecting a draft.\n  if (!requireVisibilityWriteAccess(req, res, existing, userId || '', publishPermission)) return null;\n\n  const restored = await service.restore(id, orgId, userId || 'system');\n  if (!restored) {\n    sendEntityNotFound(res, label);\n    return null;\n  }\n\n  return { existing, restored };\n}\n\n/** The slice of a service a purge route uses (satisfied by any CrudService). */\nexport interface PurgeableService<T extends RestorableEntity> {\n  findDeletedById(id: string, orgId?: string): Promise<T | null>;\n  purgeById(id: string, orgId?: string): Promise<string | null>;\n}\n\n/**\n * Shared skeleton for an entity PURGE route: extract `:id`, load the own-org\n * tombstone, gate it on the visibility ladder (parity with\n * delete/restore), then permanently hard-delete it — but ONLY when it is a\n * genuine tombstone (a live/active row loads as `null` here and 404s, so purge\n * can never hard-delete a live row). Returns `{ existing, purgedId }` on success\n * (the caller emits the entity-specific audit off `existing`), or `null` when it\n * has ALREADY sent a response (400/404/403). Purge is intentionally NOT step-up\n * gated: it only finalizes what the retention sweep would remove anyway, and the\n * frontend gates it with an explicit confirm dialog. DRYs the near-identical\n * pipeline / pipeline_template purge routes.\n */\nexport async function loadAndPurge<T extends RestorableEntity>(\n  req: Request,\n  res: Response,\n  orgId: string,\n  service: PurgeableService<T>,\n  label: string,\n  publishPermission: Permission,\n  userId: string,\n): Promise<{ existing: T; purgedId: string } | null> {\n  const id = getParam(req.params, 'id');\n  if (!id) {\n    sendBadRequest(res, `${label} ID is required.`, ErrorCode.MISSING_REQUIRED_FIELD);\n    return null;\n  }\n\n  // Load the TOMBSTONE (own-org). A live row / unknown id / already-purged → 404,\n  // so a currently-active entity is never hard-deleted through this path.\n  const existing = await service.findDeletedById(id, orgId);\n  if (!existing) {\n    sendEntityNotFound(res, label);\n    return null;\n  }\n\n  // Same ladder authority as delete/restore (see loadAndRestore).\n  if (!requireVisibilityWriteAccess(req, res, existing, userId || '', publishPermission)) return null;\n\n  // Reuse the retention sweep's single-id hard-delete (same tombstone match +\n  // dependent-teardown hooks). Returns null on a race (already purged) → 404.\n  const purgedId = await service.purgeById(id, orgId);\n  if (!purgedId) {\n    sendEntityNotFound(res, label);\n    return null;\n  }\n\n  return { existing, purgedId };\n}\n"]}

package/lib/index.d.ts

@@ -13,7 +13,7 @@
  * - RequestIdentity — parsed JWT identity
  * - ServiceConfig, RequestOptions — HTTP client types
  * - QuotaType, QuotaCheckResult — quota service types
- * - PipelineType, ComputeType, AccessModifier — pipeline domain types
+ * - PipelineType, ComputeType, Visibility — pipeline domain types
  * - FeatureFlags — feature flag types
  *
  * **Utilities**

package/lib/index.js

@@ -15,7 +15,7 @@
  * - RequestIdentity — parsed JWT identity
  * - ServiceConfig, RequestOptions — HTTP client types
  * - QuotaType, QuotaCheckResult — quota service types
- * - PipelineType, ComputeType, AccessModifier — pipeline domain types
+ * - PipelineType, ComputeType, Visibility — pipeline domain types
  * - FeatureFlags — feature flag types
  *
  * **Utilities**
@@ -68,4 +68,4 @@ export * from './errors/index.js';
 export * from './validation/index.js';
 // OpenAPI
 export * from './openapi/index.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/middleware/auth.d.ts

@@ -156,19 +156,10 @@ export declare function requireSystemAdmin(req: Request, res: Response, next: Ne
  * Sysadmins (isSuperAdmin) bypass — they always have every feature.
  */
 export declare function requireFeature(feature: string): (req: Request, res: Response, next: NextFunction) => void;
-/**
- * Resolve the effective access modifier for an entity being created/updated.
- * 'public' is permitted only for a caller holding the relevant publish
- * capability (`pipelines:publish` / `plugins:publish`) — superadmins pass via
- * implicit-all. Everyone else (including callers who requested 'public' without
- * the permission, and service principals) gets 'private'.
- *
- * Permission-based (not coarse-role-based): a bespoke custom Role can be granted
- * publish rights and is no longer forced private by its `member` label. Built-in
- * Admin/Owner bundles carry the publish permissions, so their behavior is
- * unchanged; the built-in Member bundle does not, so members stay private-only.
- */
-export declare function resolveAccessModifier(req: Request, requested: string | undefined, publishPermission: Permission): 'public' | 'private';
+/** Replace the service-token denylist (service names). Empty ⇒ kill-switch off. */
+export declare function setServiceTokenDenylist(names: Iterable<string>): void;
+/** True when `sub` is `service:<name>` and `<name>` is on the denylist. */
+export declare function isServiceTokenDenied(sub: string): boolean;
 export interface ServiceTokenOptions {
     /** Calling service identifier (e.g. 'billing', 'platform'). Embedded as `sub: service:<name>`. */
     serviceName: string;
@@ -187,6 +178,13 @@ export interface ServiceTokenOptions {
      * `isAdmin` is derived from this (admin|owner → true).
      */
     role: 'owner' | 'admin' | 'member';
+    /**
+     * Optional fine-grained permission claim. Prefer this + `role: 'member'` over a
+     * high role when a call needs ONE specific capability (e.g. `['plugins:write']`
+     * to push a plugin image) — the token then satisfies that permission gate
+     * WITHOUT carrying `isAdmin`, so a leaked token can't perform admin actions.
+     */
+    permissions?: Permission[];
 }
 /**
  * Mint a JWT identifying the calling service. Used for inter-service HTTP calls.