@pipeline-builder/api-core 0.0.1

package/lib/types/feature-flags.js

@@ -0,0 +1,128 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/** All valid feature flags (order determines display order). */
+export const ALL_FEATURE_FLAGS = [
+    'priority_support',
+    'ai_generation',
+    'bulk_operations',
+    'custom_integrations',
+    'audit_log',
+    'sso',
+    'advanced_reporting',
+    'team_usage_analytics',
+    'compliance_standard',
+    'compliance_advanced',
+];
+/** Check whether a string is a valid FeatureFlag. */
+export function isValidFeatureFlag(value) {
+    return ALL_FEATURE_FLAGS.includes(value);
+}
+// Tier-to-feature mapping
+/** Features enabled by default for each tier. */
+export const TIER_FEATURES = {
+    developer: [],
+    pro: ['priority_support', 'ai_generation', 'bulk_operations'],
+    // Team adds audit_log (collaboration/governance) and sso (SSO/IdP is INCLUDED
+    // in Team, not an add-on). advanced_reporting (DORA) is NOT a Team tier feature —
+    // it's INCLUDED only in Enterprise and sold as an add-on bundle to every other
+    // tier (see billing-config `advanced_reporting`). Enterprise unlocks all.
+    team: ['priority_support', 'ai_generation', 'bulk_operations', 'audit_log', 'sso'],
+    enterprise: [...ALL_FEATURE_FLAGS],
+    // Unlimited includes every feature / add-on bundle (billing-disabled default).
+    unlimited: [...ALL_FEATURE_FLAGS],
+};
+// Feature metadata (for display)
+/** Human-readable metadata for each feature flag. */
+export const FEATURE_METADATA = {
+    priority_support: {
+        label: 'Priority Support',
+        description: 'Faster response times and dedicated support channels',
+    },
+    ai_generation: {
+        label: 'AI Generation',
+        description: 'AI-powered pipeline and plugin generation',
+    },
+    bulk_operations: {
+        label: 'Bulk Operations',
+        description: 'Batch create, update, and delete for pipelines and plugins',
+    },
+    custom_integrations: {
+        label: 'Custom Integrations',
+        description: 'Connect to external services and custom webhook endpoints',
+    },
+    audit_log: {
+        label: 'Audit Log',
+        description: 'Detailed audit trail of all user and system actions',
+    },
+    sso: {
+        label: 'SSO / IdP',
+        description: 'Single sign-on and external identity-provider configurations',
+    },
+    advanced_reporting: {
+        label: 'Advanced Reporting',
+        description: 'DORA / advanced delivery analytics',
+    },
+    team_usage_analytics: {
+        label: 'Team Usage Analytics',
+        description: 'Per-team usage breakdown across the org → team subtree',
+    },
+    compliance_standard: {
+        label: 'Standard Compliance',
+        description: 'Curated CI/CD best-practice compliance rule library',
+    },
+    compliance_advanced: {
+        label: 'Advanced Compliance',
+        description: 'Curated framework compliance libraries (SOC2 / PCI-DSS / CIS)',
+    },
+};
+// Resolution logic
+/**
+ * Resolve a user's effective feature set.
+ *
+ * 1. Sysadmins (isSuperAdmin) always get ALL features.
+ * 2. Start with the tier's default features.
+ * 3. Apply per-user overrides: `true` adds a feature, `false` removes it.
+ * 4. Invalid override keys are silently ignored.
+ *
+ * @param tier - The organization's quota tier
+ * @param opts - Resolution options:
+ *   - `overrides`: per-user overrides (key = feature flag, value = enabled)
+ *   - `isSuperAdmin`: whether the user has the global super-admin flag
+ *   - `accountFeatures`: account-level entitlements (e.g. purchased add-on
+ *     bundles). A NAMED field so it can never be silently dropped by a caller
+ *     that omits a trailing positional arg.
+ * @returns Sorted array of enabled feature flags
+ */
+export function resolveUserFeatures(tier, opts) {
+    const { overrides: featureOverrides, isSuperAdmin, accountFeatures } = opts ?? {};
+    // Sysadmins get everything regardless of tier.
+    if (isSuperAdmin)
+        return [...ALL_FEATURE_FLAGS];
+    // Start with tier defaults
+    const features = new Set(TIER_FEATURES[tier] ?? []);
+    // Account-level entitlements (purchased feature bundles — e.g. audit_log, sso,
+    // advanced_reporting, team_usage_analytics, compliance_standard/advanced).
+    // Applied before per-user overrides so an explicit user override still wins.
+    if (accountFeatures) {
+        for (const key of accountFeatures) {
+            if (isValidFeatureFlag(key))
+                features.add(key);
+        }
+    }
+    // Apply per-user overrides
+    if (featureOverrides) {
+        for (const [key, enabled] of Object.entries(featureOverrides)) {
+            if (!isValidFeatureFlag(key))
+                continue;
+            if (enabled) {
+                features.add(key);
+            }
+            else {
+                features.delete(key);
+            }
+        }
+    }
+    // Return in canonical order
+    return ALL_FEATURE_FLAGS.filter(f => features.has(f));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feature-flags.js","sourceRoot":"","sources":["../../src/types/feature-flags.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { QuotaTier } from './quota-tiers.js';\n\n// Feature flag identifiers\n\n/** Canonical feature flag identifiers. */\nexport type FeatureFlag =\n  // `priority_support` and `custom_integrations` are ENTERPRISE-EXCLUSIVE\n  // marketing/entitlement flags: granted only by the enterprise tier (no add-on\n  // bundle sells them to a lower tier — intentional, they anchor the Enterprise\n  // plan) and not currently `requireFeature`-gated on any route (they surface in\n  // plan marketing + the entitlement set; enforcement is a future hook). This is\n  // by design, not dead code — do not \"fix\" by wiring a bundle without a pricing\n  // decision. Contrast `audit_log`/`sso`/`advanced_reporting`, which ARE sold as\n  // add-on bundles and gated (see billing-config `loadBundles` + `requireFeature`).\n  | 'priority_support'\n  | 'custom_integrations'\n  | 'ai_generation'\n  | 'bulk_operations'\n  | 'audit_log'\n  | 'sso'\n  // DORA / advanced delivery analytics (paid tiers only).\n  | 'advanced_reporting'\n  // Per-team usage breakdown across the org→team subtree. INCLUDED in Enterprise;\n  // sold as an add-on bundle to Pro/Team (see billing-config `team_usage_analytics`).\n  | 'team_usage_analytics'\n  // Curated compliance rule libraries sold as add-on bundles. `compliance_standard`\n  // = CI/CD best-practice set; `compliance_advanced` = SOC2/PCI/CIS framework\n  // libraries (requires Standard). These gate SUBSCRIBING to the set's system-org\n  // published rules; INCLUDED in Enterprise/Unlimited (via ALL_FEATURE_FLAGS),\n  // sold to Developer/Pro/Team (see billing-config `compliance_standard/advanced`).\n  | 'compliance_standard'\n  | 'compliance_advanced';\n\n/** All valid feature flags (order determines display order). */\nexport const ALL_FEATURE_FLAGS: readonly FeatureFlag[] = [\n  'priority_support',\n  'ai_generation',\n  'bulk_operations',\n  'custom_integrations',\n  'audit_log',\n  'sso',\n  'advanced_reporting',\n  'team_usage_analytics',\n  'compliance_standard',\n  'compliance_advanced',\n];\n\n/** Check whether a string is a valid FeatureFlag. */\nexport function isValidFeatureFlag(value: string): value is FeatureFlag {\n  return (ALL_FEATURE_FLAGS as readonly string[]).includes(value);\n}\n\n// Tier-to-feature mapping\n\n/** Features enabled by default for each tier. */\nexport const TIER_FEATURES: Record<QuotaTier, readonly FeatureFlag[]> = {\n  developer: [],\n  pro: ['priority_support', 'ai_generation', 'bulk_operations'],\n  // Team adds audit_log (collaboration/governance) and sso (SSO/IdP is INCLUDED\n  // in Team, not an add-on). advanced_reporting (DORA) is NOT a Team tier feature —\n  // it's INCLUDED only in Enterprise and sold as an add-on bundle to every other\n  // tier (see billing-config `advanced_reporting`). Enterprise unlocks all.\n  team: ['priority_support', 'ai_generation', 'bulk_operations', 'audit_log', 'sso'],\n  enterprise: [...ALL_FEATURE_FLAGS],\n  // Unlimited includes every feature / add-on bundle (billing-disabled default).\n  unlimited: [...ALL_FEATURE_FLAGS],\n};\n\n// Feature metadata (for display)\n\n/** Human-readable metadata for each feature flag. */\nexport const FEATURE_METADATA: Record<FeatureFlag, { label: string; description: string }> = {\n  priority_support: {\n    label: 'Priority Support',\n    description: 'Faster response times and dedicated support channels',\n  },\n  ai_generation: {\n    label: 'AI Generation',\n    description: 'AI-powered pipeline and plugin generation',\n  },\n  bulk_operations: {\n    label: 'Bulk Operations',\n    description: 'Batch create, update, and delete for pipelines and plugins',\n  },\n  custom_integrations: {\n    label: 'Custom Integrations',\n    description: 'Connect to external services and custom webhook endpoints',\n  },\n  audit_log: {\n    label: 'Audit Log',\n    description: 'Detailed audit trail of all user and system actions',\n  },\n  sso: {\n    label: 'SSO / IdP',\n    description: 'Single sign-on and external identity-provider configurations',\n  },\n  advanced_reporting: {\n    label: 'Advanced Reporting',\n    description: 'DORA / advanced delivery analytics',\n  },\n  team_usage_analytics: {\n    label: 'Team Usage Analytics',\n    description: 'Per-team usage breakdown across the org → team subtree',\n  },\n  compliance_standard: {\n    label: 'Standard Compliance',\n    description: 'Curated CI/CD best-practice compliance rule library',\n  },\n  compliance_advanced: {\n    label: 'Advanced Compliance',\n    description: 'Curated framework compliance libraries (SOC2 / PCI-DSS / CIS)',\n  },\n};\n\n// Resolution logic\n\n/**\n * Resolve a user's effective feature set.\n *\n * 1. Sysadmins (isSuperAdmin) always get ALL features.\n * 2. Start with the tier's default features.\n * 3. Apply per-user overrides: `true` adds a feature, `false` removes it.\n * 4. Invalid override keys are silently ignored.\n *\n * @param tier - The organization's quota tier\n * @param opts - Resolution options:\n *   - `overrides`: per-user overrides (key = feature flag, value = enabled)\n *   - `isSuperAdmin`: whether the user has the global super-admin flag\n *   - `accountFeatures`: account-level entitlements (e.g. purchased add-on\n *     bundles). A NAMED field so it can never be silently dropped by a caller\n *     that omits a trailing positional arg.\n * @returns Sorted array of enabled feature flags\n */\nexport function resolveUserFeatures(\n  tier: QuotaTier,\n  opts?: {\n    overrides?: Record<string, boolean> | null;\n    isSuperAdmin?: boolean;\n    accountFeatures?: readonly string[] | null;\n  },\n): FeatureFlag[] {\n  const { overrides: featureOverrides, isSuperAdmin, accountFeatures } = opts ?? {};\n\n  // Sysadmins get everything regardless of tier.\n  if (isSuperAdmin) return [...ALL_FEATURE_FLAGS];\n\n  // Start with tier defaults\n  const features = new Set<FeatureFlag>(TIER_FEATURES[tier] ?? []);\n\n  // Account-level entitlements (purchased feature bundles — e.g. audit_log, sso,\n  // advanced_reporting, team_usage_analytics, compliance_standard/advanced).\n  // Applied before per-user overrides so an explicit user override still wins.\n  if (accountFeatures) {\n    for (const key of accountFeatures) {\n      if (isValidFeatureFlag(key)) features.add(key);\n    }\n  }\n\n  // Apply per-user overrides\n  if (featureOverrides) {\n    for (const [key, enabled] of Object.entries(featureOverrides)) {\n      if (!isValidFeatureFlag(key)) continue;\n      if (enabled) {\n        features.add(key);\n      } else {\n        features.delete(key);\n      }\n    }\n  }\n\n  // Return in canonical order\n  return ALL_FEATURE_FLAGS.filter(f => features.has(f));\n}\n"]}

package/lib/types/http.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Generic HTTP headers representation.
+ */
+export interface HttpHeaders {
+    [key: string]: string | string[] | undefined;
+}
+/**
+ * Generic HTTP request interface.
+ * Represents the minimal request shape needed by api-core utilities.
+ */
+export interface HttpRequest {
+    /** Request headers */
+    headers: HttpHeaders;
+    /** Route parameters */
+    params: Record<string, string | string[] | undefined>;
+    /** Query parameters */
+    query: Record<string, unknown>;
+    /** Authenticated user (if present). `sub` is the OIDC-standard subject
+     *  (= user id); higher-level layers may attach additional fields, hence
+     *  the index signature. */
+    user?: {
+        sub?: string;
+        organizationId?: string;
+        role?: string;
+        [key: string]: unknown;
+    };
+}

package/lib/types/http.js

@@ -0,0 +1,4 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9odHRwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0MiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuLyoqXG4gKiBHZW5lcmljIEhUVFAgaGVhZGVycyByZXByZXNlbnRhdGlvbi5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBIdHRwSGVhZGVycyB7XG4gIFtrZXk6IHN0cmluZ106IHN0cmluZyB8IHN0cmluZ1tdIHwgdW5kZWZpbmVkO1xufVxuXG4vKipcbiAqIEdlbmVyaWMgSFRUUCByZXF1ZXN0IGludGVyZmFjZS5cbiAqIFJlcHJlc2VudHMgdGhlIG1pbmltYWwgcmVxdWVzdCBzaGFwZSBuZWVkZWQgYnkgYXBpLWNvcmUgdXRpbGl0aWVzLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEh0dHBSZXF1ZXN0IHtcbiAgLyoqIFJlcXVlc3QgaGVhZGVycyAqL1xuICBoZWFkZXJzOiBIdHRwSGVhZGVycztcbiAgLyoqIFJvdXRlIHBhcmFtZXRlcnMgKi9cbiAgcGFyYW1zOiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmcgfCBzdHJpbmdbXSB8IHVuZGVmaW5lZD47XG4gIC8qKiBRdWVyeSBwYXJhbWV0ZXJzICovXG4gIHF1ZXJ5OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcbiAgLyoqIEF1dGhlbnRpY2F0ZWQgdXNlciAoaWYgcHJlc2VudCkuIGBzdWJgIGlzIHRoZSBPSURDLXN0YW5kYXJkIHN1YmplY3RcbiAgICogICg9IHVzZXIgaWQpOyBoaWdoZXItbGV2ZWwgbGF5ZXJzIG1heSBhdHRhY2ggYWRkaXRpb25hbCBmaWVsZHMsIGhlbmNlXG4gICAqICB0aGUgaW5kZXggc2lnbmF0dXJlLiAqL1xuICB1c2VyPzoge1xuICAgIHN1Yj86IHN0cmluZztcbiAgICBvcmdhbml6YXRpb25JZD86IHN0cmluZztcbiAgICByb2xlPzogc3RyaW5nO1xuICAgIFtrZXk6IHN0cmluZ106IHVua25vd247XG4gIH07XG59XG5cbiJdfQ==

package/lib/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from './error-codes.js';
+export * from './common.js';
+export * from './pipeline.js';
+export * from './catalog-metadata.js';
+export * from './pipeline-template.js';
+export * from './visibility.js';
+export * from './http.js';
+export * from './quota-tiers.js';
+export * from './feature-flags.js';
+export * from './permissions.js';
+export * from './audit-events.js';

package/lib/types/index.js

@@ -0,0 +1,14 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export * from './error-codes.js';
+export * from './common.js';
+export * from './pipeline.js';
+export * from './catalog-metadata.js';
+export * from './pipeline-template.js';
+export * from './visibility.js';
+export * from './http.js';
+export * from './quota-tiers.js';
+export * from './feature-flags.js';
+export * from './permissions.js';
+export * from './audit-events.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9lcnJvci1jb2Rlcy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbW1vbi5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3BpcGVsaW5lLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vY2F0YWxvZy1tZXRhZGF0YS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3BpcGVsaW5lLXRlbXBsYXRlLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vdmlzaWJpbGl0eS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2h0dHAuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9xdW90YS10aWVycy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2ZlYXR1cmUtZmxhZ3MuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9wZXJtaXNzaW9ucy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2F1ZGl0LWV2ZW50cy5qcyc7XG4iXX0=

package/lib/types/permissions.d.ts

@@ -0,0 +1,65 @@
+import type { OrgRole } from './common.js';
+/**
+ * Canonical fine-grained permission identifiers, in `resource:action` form.
+ *
+ * These are the ORG-SCOPED capabilities a Role can grant (RBAC). Coarse by
+ * design — `:write` covers create/update/delete for a resource — so the catalog
+ * and permission-picker UI stay small; split a `:write` into `:create`/`:delete`
+ * later if a resource needs it.
+ *
+ * NOT modeled here (intentionally): platform-operator actions (org delete, tier/
+ * quota override, user admin, impersonation, platform settings) stay behind the
+ * global `isSuperAdmin` flag, not a per-org permission; and `requireStepUp`
+ * (MFA) / `requireFeature` (plan entitlements) remain orthogonal gates.
+ */
+export type Permission = 'pipelines:read' | 'pipelines:write' | 'pipelines:publish' | 'templates:read' | 'templates:write' | 'templates:publish' | 'plugins:read' | 'plugins:write' | 'plugins:publish' | 'compliance:read' | 'compliance:write' | 'members:manage' | 'roles:manage' | 'invitations:manage' | 'dashboards:read' | 'dashboards:write' | 'observability:read' | 'observability:write' | 'reports:read' | 'reports:rollup' | 'messages:read' | 'messages:write' | 'billing:read' | 'billing:manage' | 'quotas:read' | 'registry:read' | 'registry:write' | 'org:settings' | 'org:idp' | 'org:kms';
+/** All valid permissions (order determines display order in the picker). */
+export declare const ALL_PERMISSIONS: readonly Permission[];
+/** Check whether a string is a valid Permission. */
+export declare function isValidPermission(value: string): value is Permission;
+/**
+ * Permissions that must NEVER be grantable through a user-authored CUSTOM Role —
+ * they gate platform-operator surfaces (the shared image registry), so allowing
+ * an org admin to mint a Role carrying them would be a latent privilege
+ * escalation. They are NOT seeded into ANY built-in Role bundle (neither
+ * `member` nor `admin`), so the only holder is a superadmin (implicit-all) —
+ * which is what makes the image-registry gates that require them effectively
+ * superadmin-only. This list ALSO blocks custom-Role authoring from requesting
+ * them (see platform `sanitizePermissions`).
+ */
+export declare const SUPERADMIN_ONLY_PERMISSIONS: readonly Permission[];
+/**
+ * Permissions an org may assign via a CUSTOM Role — every permission except the
+ * {@link SUPERADMIN_ONLY_PERMISSIONS}. Custom-Role create/update validates the
+ * requested permission set against this (see platform roles-service).
+ */
+export declare const ORG_ASSIGNABLE_PERMISSIONS: readonly Permission[];
+/** Whether `permission` may be granted through a user-authored custom Role. */
+export declare function isOrgAssignablePermission(permission: Permission): boolean;
+/**
+ * Seed bundle for each built-in Role, keyed by the coarse role it grants.
+ * Consumed by the Role seeder + the startup backfill to populate a built-in
+ * Role's `permissions[]`. NOT consulted at request time — see
+ * {@link resolveUserPermissions}.
+ */
+export declare const ROLE_PERMISSIONS: Record<OrgRole, readonly Permission[]>;
+/**
+ * Resolve a user's effective org permissions from the Roles assigned to them.
+ *
+ * Single-source model: a user's abilities are EXACTLY the union of the
+ * permissions carried by the Roles they hold (a Role = a named permission set;
+ * built-in Roles carry their bundle explicitly, seeded from
+ * {@link ROLE_PERMISSIONS}). There is no separate role-derived baseline — the
+ * coarse `role` label no longer grants anything on its own.
+ *
+ * 1. Platform superadmins (`isSuperAdmin`) always get ALL permissions.
+ * 2. Otherwise, union every permission granted by the user's assigned Roles.
+ * 3. Invalid/unknown permission strings are silently ignored.
+ *
+ * @param assignedPermissions - Flattened permissions from every Role the user holds
+ * @param isSuperAdmin - Whether the user has the global super-admin flag
+ * @returns Effective permissions in canonical order
+ */
+export declare function resolveUserPermissions(assignedPermissions?: readonly string[] | null, isSuperAdmin?: boolean): Permission[];
+/** Whether a resolved permission list grants `permission` (superadmin ⇒ always). */
+export declare function hasPermission(granted: readonly string[] | null | undefined, permission: Permission, isSuperAdmin?: boolean): boolean;

package/lib/types/permissions.js

@@ -0,0 +1,131 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/** All valid permissions (order determines display order in the picker). */
+export const ALL_PERMISSIONS = [
+    'pipelines:read', 'pipelines:write', 'pipelines:publish',
+    'templates:read', 'templates:write', 'templates:publish',
+    'plugins:read', 'plugins:write', 'plugins:publish',
+    'compliance:read', 'compliance:write',
+    'members:manage', 'roles:manage', 'invitations:manage',
+    'dashboards:read', 'dashboards:write',
+    'observability:read', 'observability:write',
+    'reports:read', 'reports:rollup',
+    'messages:read', 'messages:write',
+    'billing:read', 'billing:manage',
+    'quotas:read',
+    'registry:read', 'registry:write',
+    'org:settings', 'org:idp', 'org:kms',
+];
+/** Check whether a string is a valid Permission. */
+export function isValidPermission(value) {
+    return ALL_PERMISSIONS.includes(value);
+}
+/**
+ * Permissions that must NEVER be grantable through a user-authored CUSTOM Role —
+ * they gate platform-operator surfaces (the shared image registry), so allowing
+ * an org admin to mint a Role carrying them would be a latent privilege
+ * escalation. They are NOT seeded into ANY built-in Role bundle (neither
+ * `member` nor `admin`), so the only holder is a superadmin (implicit-all) —
+ * which is what makes the image-registry gates that require them effectively
+ * superadmin-only. This list ALSO blocks custom-Role authoring from requesting
+ * them (see platform `sanitizePermissions`).
+ */
+export const SUPERADMIN_ONLY_PERMISSIONS = [
+    'registry:read',
+    'registry:write',
+];
+/**
+ * Permissions an org may assign via a CUSTOM Role — every permission except the
+ * {@link SUPERADMIN_ONLY_PERMISSIONS}. Custom-Role create/update validates the
+ * requested permission set against this (see platform roles-service).
+ */
+export const ORG_ASSIGNABLE_PERMISSIONS = ALL_PERMISSIONS.filter((p) => !SUPERADMIN_ONLY_PERMISSIONS.includes(p));
+/** Whether `permission` may be granted through a user-authored custom Role. */
+export function isOrgAssignablePermission(permission) {
+    return !SUPERADMIN_ONLY_PERMISSIONS.includes(permission);
+}
+// =============================================================================
+// Built-in Role seed bundles
+// =============================================================================
+/**
+ * Permission bundles used to SEED the built-in Roles ("Admin", "Member").
+ *
+ * This is the single definition of what those built-in Roles grant — it is used
+ * when a Role record is created (and by the startup backfill) to populate that
+ * Role's own `permissions[]`. It is NOT a runtime permission source: a user's
+ * effective permissions come ONLY from the Roles assigned to them (see
+ * {@link resolveUserPermissions}). The coarse `role` label (owner/admin/member)
+ * survives only for `isAdmin`/ownership/display, never to grant permissions.
+ *
+ * - `member`  — day-to-day builder: read + write on pipelines/templates/plugins,
+ *   read elsewhere. No member/role/billing management, no compliance/alert
+ *   authoring, and no `:publish` on any catalog.
+ * - `admin`   — full org administration: every ORG-ASSIGNABLE permission (i.e.
+ *   ALL_PERMISSIONS minus the {@link SUPERADMIN_ONLY_PERMISSIONS}, so `registry:*`
+ *   stay superadmin-implicit-only and are NOT granted to org admins).
+ * - `owner`   — same as admin (ownership itself — transfer/delete — is gated
+ *   separately, not via a permission).
+ */
+const MEMBER_PERMISSIONS = [
+    'pipelines:read', 'pipelines:write',
+    'templates:read', 'templates:write',
+    'plugins:read', 'plugins:write',
+    'compliance:read',
+    'dashboards:read',
+    'observability:read',
+    'reports:read',
+    'messages:read', 'messages:write',
+    'billing:read',
+    'quotas:read',
+];
+const ADMIN_PERMISSIONS = [...ORG_ASSIGNABLE_PERMISSIONS];
+/**
+ * Seed bundle for each built-in Role, keyed by the coarse role it grants.
+ * Consumed by the Role seeder + the startup backfill to populate a built-in
+ * Role's `permissions[]`. NOT consulted at request time — see
+ * {@link resolveUserPermissions}.
+ */
+export const ROLE_PERMISSIONS = {
+    member: MEMBER_PERMISSIONS,
+    admin: ADMIN_PERMISSIONS,
+    owner: ADMIN_PERMISSIONS,
+};
+// =============================================================================
+// Resolution
+// =============================================================================
+/**
+ * Resolve a user's effective org permissions from the Roles assigned to them.
+ *
+ * Single-source model: a user's abilities are EXACTLY the union of the
+ * permissions carried by the Roles they hold (a Role = a named permission set;
+ * built-in Roles carry their bundle explicitly, seeded from
+ * {@link ROLE_PERMISSIONS}). There is no separate role-derived baseline — the
+ * coarse `role` label no longer grants anything on its own.
+ *
+ * 1. Platform superadmins (`isSuperAdmin`) always get ALL permissions.
+ * 2. Otherwise, union every permission granted by the user's assigned Roles.
+ * 3. Invalid/unknown permission strings are silently ignored.
+ *
+ * @param assignedPermissions - Flattened permissions from every Role the user holds
+ * @param isSuperAdmin - Whether the user has the global super-admin flag
+ * @returns Effective permissions in canonical order
+ */
+export function resolveUserPermissions(assignedPermissions, isSuperAdmin) {
+    if (isSuperAdmin)
+        return [...ALL_PERMISSIONS];
+    const perms = new Set();
+    if (assignedPermissions) {
+        for (const p of assignedPermissions) {
+            if (isValidPermission(p))
+                perms.add(p);
+        }
+    }
+    return ALL_PERMISSIONS.filter(p => perms.has(p));
+}
+/** Whether a resolved permission list grants `permission` (superadmin ⇒ always). */
+export function hasPermission(granted, permission, isSuperAdmin) {
+    if (isSuperAdmin)
+        return true;
+    return !!granted && granted.includes(permission);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissions.js","sourceRoot":"","sources":["../../src/types/permissions.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AA2EtC,4EAA4E;AAC5E,MAAM,CAAC,MAAM,eAAe,GAA0B;IACpD,gBAAgB,EAAE,iBAAiB,EAAE,mBAAmB;IACxD,gBAAgB,EAAE,iBAAiB,EAAE,mBAAmB;IACxD,cAAc,EAAE,eAAe,EAAE,iBAAiB;IAClD,iBAAiB,EAAE,kBAAkB;IACrC,gBAAgB,EAAE,cAAc,EAAE,oBAAoB;IACtD,iBAAiB,EAAE,kBAAkB;IACrC,oBAAoB,EAAE,qBAAqB;IAC3C,cAAc,EAAE,gBAAgB;IAChC,eAAe,EAAE,gBAAgB;IACjC,cAAc,EAAE,gBAAgB;IAChC,aAAa;IACb,eAAe,EAAE,gBAAgB;IACjC,cAAc,EAAE,SAAS,EAAE,SAAS;CACrC,CAAC;AAEF,oDAAoD;AACpD,MAAM,UAAU,iBAAiB,CAAC,KAAa;IAC7C,OAAQ,eAAqC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAA0B;IAChE,eAAe;IACf,gBAAgB;CACjB,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GACrC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,2BAA2B,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AAE1E,+EAA+E;AAC/E,MAAM,UAAU,yBAAyB,CAAC,UAAsB;IAC9D,OAAO,CAAC,2BAA2B,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AAC3D,CAAC;AAED,gFAAgF;AAChF,6BAA6B;AAC7B,gFAAgF;AAEhF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,kBAAkB,GAA0B;IAChD,gBAAgB,EAAE,iBAAiB;IACnC,gBAAgB,EAAE,iBAAiB;IACnC,cAAc,EAAE,eAAe;IAC/B,iBAAiB;IACjB,iBAAiB;IACjB,oBAAoB;IACpB,cAAc;IACd,eAAe,EAAE,gBAAgB;IACjC,cAAc;IACd,aAAa;CACd,CAAC;AAEF,MAAM,iBAAiB,GAA0B,CAAC,GAAG,0BAA0B,CAAC,CAAC;AAEjF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAA2C;IACtE,MAAM,EAAE,kBAAkB;IAC1B,KAAK,EAAE,iBAAiB;IACxB,KAAK,EAAE,iBAAiB;CACzB,CAAC;AAEF,gFAAgF;AAChF,aAAa;AACb,gFAAgF;AAEhF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,sBAAsB,CACpC,mBAA8C,EAC9C,YAAsB;IAEtB,IAAI,YAAY;QAAE,OAAO,CAAC,GAAG,eAAe,CAAC,CAAC;IAE9C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAc,CAAC;IACpC,IAAI,mBAAmB,EAAE,CAAC;QACxB,KAAK,MAAM,CAAC,IAAI,mBAAmB,EAAE,CAAC;YACpC,IAAI,iBAAiB,CAAC,CAAC,CAAC;gBAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IACD,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACnD,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,aAAa,CAC3B,OAA6C,EAC7C,UAAsB,EACtB,YAAsB;IAEtB,IAAI,YAAY;QAAE,OAAO,IAAI,CAAC;IAC9B,OAAO,CAAC,CAAC,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AACnD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { OrgRole } from './common.js';\n\n// =============================================================================\n// Permission identifiers\n// =============================================================================\n\n/**\n * Canonical fine-grained permission identifiers, in `resource:action` form.\n *\n * These are the ORG-SCOPED capabilities a Role can grant (RBAC). Coarse by\n * design — `:write` covers create/update/delete for a resource — so the catalog\n * and permission-picker UI stay small; split a `:write` into `:create`/`:delete`\n * later if a resource needs it.\n *\n * NOT modeled here (intentionally): platform-operator actions (org delete, tier/\n * quota override, user admin, impersonation, platform settings) stay behind the\n * global `isSuperAdmin` flag, not a per-org permission; and `requireStepUp`\n * (MFA) / `requireFeature` (plan entitlements) remain orthogonal gates.\n */\nexport type Permission =\n  // Pipelines\n  | 'pipelines:read'\n  | 'pipelines:write'\n  | 'pipelines:publish'\n  // Golden-path pipeline templates. Split out of `pipelines:*` so a platform\n  // team can curate the starter catalog WITHOUT write access to every pipeline\n  // (and vice versa) — the two used to share one gate. `:publish` maps to the\n  // template ladder's `public` rung; `org` and `private` need only `:write`.\n  | 'templates:read'\n  | 'templates:write'\n  | 'templates:publish'\n  // Plugins\n  | 'plugins:read'\n  | 'plugins:write'\n  | 'plugins:publish'\n  // Compliance\n  | 'compliance:read'\n  | 'compliance:write'\n  // Members & access\n  | 'members:manage'\n  | 'roles:manage'\n  | 'invitations:manage'\n  // Observability\n  | 'dashboards:read'\n  | 'dashboards:write'\n  | 'observability:read'\n  | 'observability:write'\n  // Insights\n  | 'reports:read'\n  | 'reports:rollup'\n  // Messaging\n  | 'messages:read'\n  | 'messages:write'\n  // Billing & quotas\n  | 'billing:read'\n  | 'billing:manage'\n  | 'quotas:read'\n  // Registry\n  | 'registry:read'\n  | 'registry:write'\n  // Organization settings.\n  //  - `org:settings` — general org settings + AI config.\n  //  - `org:idp`      — SSO / IdP configuration (sensitive: controls login).\n  //  - `org:kms`      — customer-managed KMS key configuration (sensitive:\n  //                     controls encryption of org data).\n  // `org:idp`/`org:kms` were split OUT of `org:settings` so a custom role can\n  // grant general settings WITHOUT the two sensitive surfaces. Both remain\n  // org-assignable and are seeded into the admin/owner bundles (via\n  // ORG_ASSIGNABLE_PERMISSIONS) so existing admins keep full access.\n  | 'org:settings'\n  | 'org:idp'\n  | 'org:kms';\n\n/** All valid permissions (order determines display order in the picker). */\nexport const ALL_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write', 'pipelines:publish',\n  'templates:read', 'templates:write', 'templates:publish',\n  'plugins:read', 'plugins:write', 'plugins:publish',\n  'compliance:read', 'compliance:write',\n  'members:manage', 'roles:manage', 'invitations:manage',\n  'dashboards:read', 'dashboards:write',\n  'observability:read', 'observability:write',\n  'reports:read', 'reports:rollup',\n  'messages:read', 'messages:write',\n  'billing:read', 'billing:manage',\n  'quotas:read',\n  'registry:read', 'registry:write',\n  'org:settings', 'org:idp', 'org:kms',\n];\n\n/** Check whether a string is a valid Permission. */\nexport function isValidPermission(value: string): value is Permission {\n  return (ALL_PERMISSIONS as readonly string[]).includes(value);\n}\n\n/**\n * Permissions that must NEVER be grantable through a user-authored CUSTOM Role —\n * they gate platform-operator surfaces (the shared image registry), so allowing\n * an org admin to mint a Role carrying them would be a latent privilege\n * escalation. They are NOT seeded into ANY built-in Role bundle (neither\n * `member` nor `admin`), so the only holder is a superadmin (implicit-all) —\n * which is what makes the image-registry gates that require them effectively\n * superadmin-only. This list ALSO blocks custom-Role authoring from requesting\n * them (see platform `sanitizePermissions`).\n */\nexport const SUPERADMIN_ONLY_PERMISSIONS: readonly Permission[] = [\n  'registry:read',\n  'registry:write',\n];\n\n/**\n * Permissions an org may assign via a CUSTOM Role — every permission except the\n * {@link SUPERADMIN_ONLY_PERMISSIONS}. Custom-Role create/update validates the\n * requested permission set against this (see platform roles-service).\n */\nexport const ORG_ASSIGNABLE_PERMISSIONS: readonly Permission[] =\n  ALL_PERMISSIONS.filter((p) => !SUPERADMIN_ONLY_PERMISSIONS.includes(p));\n\n/** Whether `permission` may be granted through a user-authored custom Role. */\nexport function isOrgAssignablePermission(permission: Permission): boolean {\n  return !SUPERADMIN_ONLY_PERMISSIONS.includes(permission);\n}\n\n// =============================================================================\n// Built-in Role seed bundles\n// =============================================================================\n\n/**\n * Permission bundles used to SEED the built-in Roles (\"Admin\", \"Member\").\n *\n * This is the single definition of what those built-in Roles grant — it is used\n * when a Role record is created (and by the startup backfill) to populate that\n * Role's own `permissions[]`. It is NOT a runtime permission source: a user's\n * effective permissions come ONLY from the Roles assigned to them (see\n * {@link resolveUserPermissions}). The coarse `role` label (owner/admin/member)\n * survives only for `isAdmin`/ownership/display, never to grant permissions.\n *\n * - `member`  — day-to-day builder: read + write on pipelines/templates/plugins,\n *   read elsewhere. No member/role/billing management, no compliance/alert\n *   authoring, and no `:publish` on any catalog.\n * - `admin`   — full org administration: every ORG-ASSIGNABLE permission (i.e.\n *   ALL_PERMISSIONS minus the {@link SUPERADMIN_ONLY_PERMISSIONS}, so `registry:*`\n *   stay superadmin-implicit-only and are NOT granted to org admins).\n * - `owner`   — same as admin (ownership itself — transfer/delete — is gated\n *   separately, not via a permission).\n */\nconst MEMBER_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write',\n  'templates:read', 'templates:write',\n  'plugins:read', 'plugins:write',\n  'compliance:read',\n  'dashboards:read',\n  'observability:read',\n  'reports:read',\n  'messages:read', 'messages:write',\n  'billing:read',\n  'quotas:read',\n];\n\nconst ADMIN_PERMISSIONS: readonly Permission[] = [...ORG_ASSIGNABLE_PERMISSIONS];\n\n/**\n * Seed bundle for each built-in Role, keyed by the coarse role it grants.\n * Consumed by the Role seeder + the startup backfill to populate a built-in\n * Role's `permissions[]`. NOT consulted at request time — see\n * {@link resolveUserPermissions}.\n */\nexport const ROLE_PERMISSIONS: Record<OrgRole, readonly Permission[]> = {\n  member: MEMBER_PERMISSIONS,\n  admin: ADMIN_PERMISSIONS,\n  owner: ADMIN_PERMISSIONS,\n};\n\n// =============================================================================\n// Resolution\n// =============================================================================\n\n/**\n * Resolve a user's effective org permissions from the Roles assigned to them.\n *\n * Single-source model: a user's abilities are EXACTLY the union of the\n * permissions carried by the Roles they hold (a Role = a named permission set;\n * built-in Roles carry their bundle explicitly, seeded from\n * {@link ROLE_PERMISSIONS}). There is no separate role-derived baseline — the\n * coarse `role` label no longer grants anything on its own.\n *\n * 1. Platform superadmins (`isSuperAdmin`) always get ALL permissions.\n * 2. Otherwise, union every permission granted by the user's assigned Roles.\n * 3. Invalid/unknown permission strings are silently ignored.\n *\n * @param assignedPermissions - Flattened permissions from every Role the user holds\n * @param isSuperAdmin - Whether the user has the global super-admin flag\n * @returns Effective permissions in canonical order\n */\nexport function resolveUserPermissions(\n  assignedPermissions?: readonly string[] | null,\n  isSuperAdmin?: boolean,\n): Permission[] {\n  if (isSuperAdmin) return [...ALL_PERMISSIONS];\n\n  const perms = new Set<Permission>();\n  if (assignedPermissions) {\n    for (const p of assignedPermissions) {\n      if (isValidPermission(p)) perms.add(p);\n    }\n  }\n  return ALL_PERMISSIONS.filter(p => perms.has(p));\n}\n\n/** Whether a resolved permission list grants `permission` (superadmin ⇒ always). */\nexport function hasPermission(\n  granted: readonly string[] | null | undefined,\n  permission: Permission,\n  isSuperAdmin?: boolean,\n): boolean {\n  if (isSuperAdmin) return true;\n  return !!granted && granted.includes(permission);\n}\n"]}

package/lib/types/pipeline-template.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Golden-path pipeline templates: a parameterized starter a developer
+ * instantiates (fills inputs) to create a new pipeline. The template body is a
+ * BuilderProps with `{{ vars.* }}` placeholders; each declared input maps to a
+ * `vars.<name>` value. Instantiation bakes the supplied inputs into the new
+ * pipeline's `props.vars` — the placeholders resolve at synth time like any
+ * other pipeline var (no separate template runtime).
+ */
+/** Scalar types a template input can carry. */
+export declare const TEMPLATE_INPUT_TYPES: readonly ['string', 'number', 'boolean'];
+export type TemplateInputType = (typeof TEMPLATE_INPUT_TYPES)[number];
+/**
+ * One declared input of a pipeline template. `name` is the `vars.<name>` key the
+ * template body references. This is the template's counterpart to a plugin's
+ * `requiredVars` contract.
+ */
+export interface TemplateInput {
+    /** Variable key — referenced in the template body as `{{ vars.<name> }}`. */
+    readonly name: string;
+    /** Human label for the instantiate form (falls back to `name`). */
+    readonly label?: string;
+    readonly description?: string;
+    readonly type: TemplateInputType;
+    /** When true, instantiation fails if no value (and no default) is supplied. */
+    readonly required?: boolean;
+    /** Default applied when the user leaves the input blank. */
+    readonly default?: string | number | boolean;
+    /** Optional fixed choice set (renders as a select in the UI). */
+    readonly options?: string[];
+}

package/lib/types/pipeline-template.js

@@ -0,0 +1,13 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Golden-path pipeline templates: a parameterized starter a developer
+ * instantiates (fills inputs) to create a new pipeline. The template body is a
+ * BuilderProps with `{{ vars.* }}` placeholders; each declared input maps to a
+ * `vars.<name>` value. Instantiation bakes the supplied inputs into the new
+ * pipeline's `props.vars` — the placeholders resolve at synth time like any
+ * other pipeline var (no separate template runtime).
+ */
+/** Scalar types a template input can carry. */
+export const TEMPLATE_INPUT_TYPES = ['string', 'number', 'boolean'];
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/pipeline.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Shared pipeline types used by both pipeline-core and pipeline-data
+ */
+/**
+ * Utility type to extract the union of all values from an object type
+ */
+type ValueOf<T> = T[keyof T];
+/**
+ * AWS CodeBuild compute resource sizes
+ *
+ * @property SMALL - 3 GB memory, 2 vCPUs
+ * @property MEDIUM - 7 GB memory, 4 vCPUs
+ * @property LARGE - 15 GB memory, 8 vCPUs
+ * @property X2_LARGE - 145 GB memory, 72 vCPUs
+ *
+ * @see https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html
+ */
+export declare const ComputeType: {
+    readonly SMALL: 'SMALL';
+    readonly MEDIUM: 'MEDIUM';
+    readonly LARGE: 'LARGE';
+    readonly X2_LARGE: 'X2_LARGE';
+};
+export type ComputeType = ValueOf<typeof ComputeType>;
+/**
+ * Types of pipeline steps that can be created by plugins
+ *
+ * @property CODE_BUILD_STEP - Full CodeBuild step with custom build environment
+ * @property SHELL_STEP - Simple shell step without custom build environment
+ * @property MANUAL_APPROVAL_STEP - Native CDK approval gate (no Docker image, no commands)
+ */
+export declare const PluginType: {
+    readonly CODE_BUILD_STEP: 'CodeBuildStep';
+    readonly SHELL_STEP: 'ShellStep';
+    readonly MANUAL_APPROVAL_STEP: 'ManualApprovalStep';
+};
+export type PluginType = ValueOf<typeof PluginType>;
+/**
+ * Metadata type for storing configuration and custom properties
+ *
+ * Supports:
+ * - Standard key-value pairs (string, boolean, number)
+ * - Custom AWS CDK keys with the pattern `aws:cdk:{namespace}:{key}`
+ *   (all lowercase — matches the format produced by `getCustomKey`)
+ *
+ * @example
+ * ```typescript
+ * const metadata: MetaDataType = {
+ *   BUILD_ENV: 'production',
+ *   NODE_VERSION: '18',
+ *   ENABLE_CACHE: true,
+ *   MAX_RETRIES: 3
+ * };
+ * ```
+ */
+export type MetaDataType = Record<string, string | boolean | number> & {
+    [K in `aws:cdk:${string}`]?: unknown;
+};
+export {};

package/lib/types/pipeline.js

@@ -0,0 +1,31 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * AWS CodeBuild compute resource sizes
+ *
+ * @property SMALL - 3 GB memory, 2 vCPUs
+ * @property MEDIUM - 7 GB memory, 4 vCPUs
+ * @property LARGE - 15 GB memory, 8 vCPUs
+ * @property X2_LARGE - 145 GB memory, 72 vCPUs
+ *
+ * @see https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html
+ */
+export const ComputeType = {
+    SMALL: 'SMALL',
+    MEDIUM: 'MEDIUM',
+    LARGE: 'LARGE',
+    X2_LARGE: 'X2_LARGE',
+};
+/**
+ * Types of pipeline steps that can be created by plugins
+ *
+ * @property CODE_BUILD_STEP - Full CodeBuild step with custom build environment
+ * @property SHELL_STEP - Simple shell step without custom build environment
+ * @property MANUAL_APPROVAL_STEP - Native CDK approval gate (no Docker image, no commands)
+ */
+export const PluginType = {
+    CODE_BUILD_STEP: 'CodeBuildStep',
+    SHELL_STEP: 'ShellStep',
+    MANUAL_APPROVAL_STEP: 'ManualApprovalStep',
+};
+//# sourceMappingURL=data:application/json;base64,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