@pipeline-builder/pipeline-data 4.1.1 → 4.1.2

package/lib/api/reporting/caches.d.ts

@@ -0,0 +1,2 @@
+export declare const inventoryCache: import("@pipeline-builder/api-core").CacheService;
+export declare const timeseriesCache: import("@pipeline-builder/api-core").CacheService;

package/lib/api/reporting/caches.js

@@ -0,0 +1,14 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The two report caches. A separate module because both the service (for
+ * invalidation) and the extracted query modules (via runReport) need them, and a
+ * shared singleton must have exactly one definition site.
+ *
+ * Inventory reads (plugin summary/distribution/versions) change rarely — 5 min.
+ * Timeseries reads (execution/build metrics over a range) — 2 min.
+ */
+import { createCacheService } from '@pipeline-builder/api-core';
+export const inventoryCache = createCacheService('report:inv:', parseInt(process.env.CACHE_TTL_REPORT_INVENTORY || '300', 10));
+export const timeseriesCache = createCacheService('report:ts:', parseInt(process.env.CACHE_TTL_REPORT_TIMESERIES || '120', 10));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwaS9yZXBvcnRpbmcvY2FjaGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFFdEM7Ozs7Ozs7R0FPRztBQUVILE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRWhFLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxrQkFBa0IsQ0FBQyxhQUFhLEVBQUUsUUFBUSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsMEJBQTBCLElBQUksS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUM7QUFDL0gsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLGtCQUFrQixDQUFDLFlBQVksRUFBRSxRQUFRLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQywyQkFBMkIsSUFBSSxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKipcbiAqIFRoZSB0d28gcmVwb3J0IGNhY2hlcy4gQSBzZXBhcmF0ZSBtb2R1bGUgYmVjYXVzZSBib3RoIHRoZSBzZXJ2aWNlIChmb3JcbiAqIGludmFsaWRhdGlvbikgYW5kIHRoZSBleHRyYWN0ZWQgcXVlcnkgbW9kdWxlcyAodmlhIHJ1blJlcG9ydCkgbmVlZCB0aGVtLCBhbmQgYVxuICogc2hhcmVkIHNpbmdsZXRvbiBtdXN0IGhhdmUgZXhhY3RseSBvbmUgZGVmaW5pdGlvbiBzaXRlLlxuICpcbiAqIEludmVudG9yeSByZWFkcyAocGx1Z2luIHN1bW1hcnkvZGlzdHJpYnV0aW9uL3ZlcnNpb25zKSBjaGFuZ2UgcmFyZWx5IOKAlCA1IG1pbi5cbiAqIFRpbWVzZXJpZXMgcmVhZHMgKGV4ZWN1dGlvbi9idWlsZCBtZXRyaWNzIG92ZXIgYSByYW5nZSkg4oCUIDIgbWluLlxuICovXG5cbmltcG9ydCB7IGNyZWF0ZUNhY2hlU2VydmljZSB9IGZyb20gJ0BwaXBlbGluZS1idWlsZGVyL2FwaS1jb3JlJztcblxuZXhwb3J0IGNvbnN0IGludmVudG9yeUNhY2hlID0gY3JlYXRlQ2FjaGVTZXJ2aWNlKCdyZXBvcnQ6aW52OicsIHBhcnNlSW50KHByb2Nlc3MuZW52LkNBQ0hFX1RUTF9SRVBPUlRfSU5WRU5UT1JZIHx8ICczMDAnLCAxMCkpO1xuZXhwb3J0IGNvbnN0IHRpbWVzZXJpZXNDYWNoZSA9IGNyZWF0ZUNhY2hlU2VydmljZSgncmVwb3J0OnRzOicsIHBhcnNlSW50KHByb2Nlc3MuZW52LkNBQ0hFX1RUTF9SRVBPUlRfVElNRVNFUklFUyB8fCAnMTIwJywgMTApKTtcbiJdfQ==

package/lib/api/reporting/dora-scoring.d.ts

@@ -0,0 +1,71 @@
+import type { DoraLevel } from './types.js';
+/**
+ * DORA performance banding plus the small statistics helpers it needs.
+ * Pure functions — no database access, no I/O — which is what lets the
+ * thresholds be unit-tested independently of the queries that feed them.
+ */
+/**
+ * The DORA headline environment. Deployment to this literal env name is the
+ * industry-standard DORA signal; MTTR is measured production-only, and this
+ * environment's card is the summary shown at the top of the panel.
+ */
+export declare const HEADLINE_ENV = "production";
+/**
+ * Incident→deploy correlation window (Phase 5). An incident is attributed to the
+ * most recent SUCCESSFUL deploy to its environment whose `completed_at` is within
+ * this many hours before the incident's `opened_at`. Default 24h; override via
+ * `DORA_INCIDENT_WINDOW_HOURS`. Guarded to a positive finite number.
+ */
+export declare const DORA_INCIDENT_WINDOW_HOURS: number;
+/**
+ * Resolve the effective incident→deploy correlation window (Phase 5b). A per-org
+ * override (from `dora_settings.incident_window_hours`, surfaced through the
+ * settings endpoint and threaded into {@link DoraOptions.incidentWindowHours})
+ * wins when it is a positive finite number; otherwise the global env default
+ * `DORA_INCIDENT_WINDOW_HOURS` applies. Centralized so the DORA correlation, the
+ * incidents list, and the wiring-test dry-run all agree on the same rule.
+ */
+export declare function resolveIncidentWindowHours(override?: number | null): number;
+/**
+ * Reporting retention windows (Phase 7). Records in `pipeline_events`,
+ * `deployment_outcomes`, and `incidents` grow unbounded without a sweep, so a
+ * split, per-org retention purge (see {@link ReportingService.purgeExpiredReportingData})
+ * hard-deletes rows older than these windows, by `created_at`:
+ *  - **Standard events** — `pipeline_events` with `environment IS NULL`
+ *    (non-deploy STAGE/ACTION/build). High volume → short default (30 days).
+ *  - **DORA source** — `pipeline_events` with `environment IS NOT NULL` (deploy
+ *    stages) plus all of `deployment_outcomes` and `incidents`. Low volume →
+ *    longer default (180 days). DORA history is therefore bounded by this window;
+ *    the report query still hard-caps at 365 days (a longer per-org override only
+ *    retains raw source rows, never widens a report).
+ * `ingest_health` and `dora_settings` are never purged. Env-overridable globals;
+ * a per-org override in `dora_settings` wins (see {@link resolveEventRetentionDays}).
+ */
+/** Deployment frequency by deploys/day: elite ≥1/day, high ≥1/week, medium ≥1/month. */
+export declare function doraLevelForFrequency(perDay: number, deployments: number): DoraLevel;
+/** Change failure rate by percent: elite ≤5%, high ≤10%, medium ≤15%. */
+export declare function doraLevelForChangeFailure(pct: number, total: number): DoraLevel;
+/** Time to restore by seconds: elite <1h, high <1 day, medium <1 week. */
+export declare function doraLevelForRestore(avgSeconds: number | null): DoraLevel;
+/** Lead time by seconds: elite <1 day, high <1 week, medium <1 month. */
+export declare function doraLevelForLeadTime(medianSeconds: number | null): DoraLevel;
+/**
+ * Round `value` to `digits` decimal places, returning a real number. Small
+ * module-private helper so the DORA shaping doesn't repeat the
+ * `Number(Number(x).toFixed(n))` pattern (toFixed alone yields a string).
+ */
+export declare function round(value: number, digits: number): number;
+/**
+ * Median of a numeric sample, or `null` when empty. Used for measured lead time
+ * and MTTR — both are cross-source gaps computed in JS from clamped deltas, so
+ * the median lives here rather than in SQL PERCENTILE_CONT (keeps the golden
+ * fixture tests able to prove the metric math without a live Postgres).
+ */
+export declare function median(values: number[]): number | null;
+/**
+ * Roll a group of deploy/stage events (grouped per execution) up to one terminal
+ * status: FAILED wins, then SUCCEEDED, else OTHER (still-running / non-terminal).
+ * Shared by the three per-(env|stage, execution) rollup CTEs — DORA metrics, DORA
+ * trend, and build health — so the precedence can't drift between them. Assumes the
+ * grouped event alias is `e`.
+ */

package/lib/api/reporting/dora-scoring.js

@@ -0,0 +1,126 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * DORA performance banding plus the small statistics helpers it needs.
+ * Pure functions — no database access, no I/O — which is what lets the
+ * thresholds be unit-tested independently of the queries that feed them.
+ */
+/**
+ * The DORA headline environment. Deployment to this literal env name is the
+ * industry-standard DORA signal; MTTR is measured production-only, and this
+ * environment's card is the summary shown at the top of the panel.
+ */
+export const HEADLINE_ENV = 'production';
+/**
+ * Incident→deploy correlation window (Phase 5). An incident is attributed to the
+ * most recent SUCCESSFUL deploy to its environment whose `completed_at` is within
+ * this many hours before the incident's `opened_at`. Default 24h; override via
+ * `DORA_INCIDENT_WINDOW_HOURS`. Guarded to a positive finite number.
+ */
+export const DORA_INCIDENT_WINDOW_HOURS = (() => {
+    const raw = Number(process.env.DORA_INCIDENT_WINDOW_HOURS);
+    return Number.isFinite(raw) && raw > 0 ? raw : 24;
+})();
+/**
+ * Resolve the effective incident→deploy correlation window (Phase 5b). A per-org
+ * override (from `dora_settings.incident_window_hours`, surfaced through the
+ * settings endpoint and threaded into {@link DoraOptions.incidentWindowHours})
+ * wins when it is a positive finite number; otherwise the global env default
+ * `DORA_INCIDENT_WINDOW_HOURS` applies. Centralized so the DORA correlation, the
+ * incidents list, and the wiring-test dry-run all agree on the same rule.
+ */
+export function resolveIncidentWindowHours(override) {
+    return override != null && Number.isFinite(override) && override > 0 ? override : DORA_INCIDENT_WINDOW_HOURS;
+}
+/**
+ * Reporting retention windows (Phase 7). Records in `pipeline_events`,
+ * `deployment_outcomes`, and `incidents` grow unbounded without a sweep, so a
+ * split, per-org retention purge (see {@link ReportingService.purgeExpiredReportingData})
+ * hard-deletes rows older than these windows, by `created_at`:
+ *  - **Standard events** — `pipeline_events` with `environment IS NULL`
+ *    (non-deploy STAGE/ACTION/build). High volume → short default (30 days).
+ *  - **DORA source** — `pipeline_events` with `environment IS NOT NULL` (deploy
+ *    stages) plus all of `deployment_outcomes` and `incidents`. Low volume →
+ *    longer default (180 days). DORA history is therefore bounded by this window;
+ *    the report query still hard-caps at 365 days (a longer per-org override only
+ *    retains raw source rows, never widens a report).
+ * `ingest_health` and `dora_settings` are never purged. Env-overridable globals;
+ * a per-org override in `dora_settings` wins (see {@link resolveEventRetentionDays}).
+ */
+/** Deployment frequency by deploys/day: elite ≥1/day, high ≥1/week, medium ≥1/month. */
+export function doraLevelForFrequency(perDay, deployments) {
+    if (deployments <= 0)
+        return null;
+    if (perDay >= 1)
+        return 'elite';
+    if (perDay >= 1 / 7)
+        return 'high';
+    if (perDay >= 1 / 30)
+        return 'medium';
+    return 'low';
+}
+/** Change failure rate by percent: elite ≤5%, high ≤10%, medium ≤15%. */
+export function doraLevelForChangeFailure(pct, total) {
+    if (total <= 0)
+        return null;
+    if (pct <= 5)
+        return 'elite';
+    if (pct <= 10)
+        return 'high';
+    if (pct <= 15)
+        return 'medium';
+    return 'low';
+}
+/** Time to restore by seconds: elite <1h, high <1 day, medium <1 week. */
+export function doraLevelForRestore(avgSeconds) {
+    if (avgSeconds == null)
+        return null;
+    if (avgSeconds < 3600)
+        return 'elite';
+    if (avgSeconds < 86400)
+        return 'high';
+    if (avgSeconds < 604800)
+        return 'medium';
+    return 'low';
+}
+/** Lead time by seconds: elite <1 day, high <1 week, medium <1 month. */
+export function doraLevelForLeadTime(medianSeconds) {
+    if (medianSeconds == null)
+        return null;
+    if (medianSeconds < 86400)
+        return 'elite';
+    if (medianSeconds < 604800)
+        return 'high';
+    if (medianSeconds < 2592000)
+        return 'medium';
+    return 'low';
+}
+/**
+ * Round `value` to `digits` decimal places, returning a real number. Small
+ * module-private helper so the DORA shaping doesn't repeat the
+ * `Number(Number(x).toFixed(n))` pattern (toFixed alone yields a string).
+ */
+export function round(value, digits) {
+    return Number(value.toFixed(digits));
+}
+/**
+ * Median of a numeric sample, or `null` when empty. Used for measured lead time
+ * and MTTR — both are cross-source gaps computed in JS from clamped deltas, so
+ * the median lives here rather than in SQL PERCENTILE_CONT (keeps the golden
+ * fixture tests able to prove the metric math without a live Postgres).
+ */
+export function median(values) {
+    if (values.length === 0)
+        return null;
+    const s = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(s.length / 2);
+    return s.length % 2 === 1 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+}
+/**
+ * Roll a group of deploy/stage events (grouped per execution) up to one terminal
+ * status: FAILED wins, then SUCCEEDED, else OTHER (still-running / non-terminal).
+ * Shared by the three per-(env|stage, execution) rollup CTEs — DORA metrics, DORA
+ * trend, and build health — so the precedence can't drift between them. Assumes the
+ * grouped event alias is `e`.
+ */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dora-scoring.js","sourceRoot":"","sources":["../../../src/api/reporting/dora-scoring.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { DoraLevel } from './types.js';\n\n/**\n * DORA performance banding plus the small statistics helpers it needs.\n * Pure functions — no database access, no I/O — which is what lets the\n * thresholds be unit-tested independently of the queries that feed them.\n */\n\n/**\n * The DORA headline environment. Deployment to this literal env name is the\n * industry-standard DORA signal; MTTR is measured production-only, and this\n * environment's card is the summary shown at the top of the panel.\n */\nexport const HEADLINE_ENV = 'production';\n\n/**\n * Incident→deploy correlation window (Phase 5). An incident is attributed to the\n * most recent SUCCESSFUL deploy to its environment whose `completed_at` is within\n * this many hours before the incident's `opened_at`. Default 24h; override via\n * `DORA_INCIDENT_WINDOW_HOURS`. Guarded to a positive finite number.\n */\nexport const DORA_INCIDENT_WINDOW_HOURS = (() => {\n  const raw = Number(process.env.DORA_INCIDENT_WINDOW_HOURS);\n  return Number.isFinite(raw) && raw > 0 ? raw : 24;\n})();\n\n/**\n * Resolve the effective incident→deploy correlation window (Phase 5b). A per-org\n * override (from `dora_settings.incident_window_hours`, surfaced through the\n * settings endpoint and threaded into {@link DoraOptions.incidentWindowHours})\n * wins when it is a positive finite number; otherwise the global env default\n * `DORA_INCIDENT_WINDOW_HOURS` applies. Centralized so the DORA correlation, the\n * incidents list, and the wiring-test dry-run all agree on the same rule.\n */\nexport function resolveIncidentWindowHours(override?: number | null): number {\n  return override != null && Number.isFinite(override) && override > 0 ? override : DORA_INCIDENT_WINDOW_HOURS;\n}\n\n/**\n * Reporting retention windows (Phase 7). Records in `pipeline_events`,\n * `deployment_outcomes`, and `incidents` grow unbounded without a sweep, so a\n * split, per-org retention purge (see {@link ReportingService.purgeExpiredReportingData})\n * hard-deletes rows older than these windows, by `created_at`:\n *  - **Standard events** — `pipeline_events` with `environment IS NULL`\n *    (non-deploy STAGE/ACTION/build). High volume → short default (30 days).\n *  - **DORA source** — `pipeline_events` with `environment IS NOT NULL` (deploy\n *    stages) plus all of `deployment_outcomes` and `incidents`. Low volume →\n *    longer default (180 days). DORA history is therefore bounded by this window;\n *    the report query still hard-caps at 365 days (a longer per-org override only\n *    retains raw source rows, never widens a report).\n * `ingest_health` and `dora_settings` are never purged. Env-overridable globals;\n * a per-org override in `dora_settings` wins (see {@link resolveEventRetentionDays}).\n */\n\n/** Deployment frequency by deploys/day: elite ≥1/day, high ≥1/week, medium ≥1/month. */\nexport function doraLevelForFrequency(perDay: number, deployments: number): DoraLevel {\n  if (deployments <= 0) return null;\n  if (perDay >= 1) return 'elite';\n  if (perDay >= 1 / 7) return 'high';\n  if (perDay >= 1 / 30) return 'medium';\n  return 'low';\n}\n/** Change failure rate by percent: elite ≤5%, high ≤10%, medium ≤15%. */\nexport function doraLevelForChangeFailure(pct: number, total: number): DoraLevel {\n  if (total <= 0) return null;\n  if (pct <= 5) return 'elite';\n  if (pct <= 10) return 'high';\n  if (pct <= 15) return 'medium';\n  return 'low';\n}\n/** Time to restore by seconds: elite <1h, high <1 day, medium <1 week. */\nexport function doraLevelForRestore(avgSeconds: number | null): DoraLevel {\n  if (avgSeconds == null) return null;\n  if (avgSeconds < 3600) return 'elite';\n  if (avgSeconds < 86400) return 'high';\n  if (avgSeconds < 604800) return 'medium';\n  return 'low';\n}\n/** Lead time by seconds: elite <1 day, high <1 week, medium <1 month. */\nexport function doraLevelForLeadTime(medianSeconds: number | null): DoraLevel {\n  if (medianSeconds == null) return null;\n  if (medianSeconds < 86400) return 'elite';\n  if (medianSeconds < 604800) return 'high';\n  if (medianSeconds < 2592000) return 'medium';\n  return 'low';\n}\n\n/**\n * Round `value` to `digits` decimal places, returning a real number. Small\n * module-private helper so the DORA shaping doesn't repeat the\n * `Number(Number(x).toFixed(n))` pattern (toFixed alone yields a string).\n */\nexport function round(value: number, digits: number): number {\n  return Number(value.toFixed(digits));\n}\n\n/**\n * Median of a numeric sample, or `null` when empty. Used for measured lead time\n * and MTTR — both are cross-source gaps computed in JS from clamped deltas, so\n * the median lives here rather than in SQL PERCENTILE_CONT (keeps the golden\n * fixture tests able to prove the metric math without a live Postgres).\n */\nexport function median(values: number[]): number | null {\n  if (values.length === 0) return null;\n  const s = [...values].sort((a, b) => a - b);\n  const mid = Math.floor(s.length / 2);\n  return s.length % 2 === 1 ? s[mid] : (s[mid - 1] + s[mid]) / 2;\n}\n\n/**\n * Roll a group of deploy/stage events (grouped per execution) up to one terminal\n * status: FAILED wins, then SUCCEEDED, else OTHER (still-running / non-terminal).\n * Shared by the three per-(env|stage, execution) rollup CTEs — DORA metrics, DORA\n * trend, and build health — so the precedence can't drift between them. Assumes the\n * grouped event alias is `e`.\n */\n"]}

package/lib/api/reporting/dora.d.ts

@@ -0,0 +1,47 @@
+import type { DoraOptions, DoraMetrics, DoraTrendPoint, BuildHealth } from './types.js';
+/**
+ * 1.9 DORA metrics over a [from,to] deploy-completion window, org-scoped +
+ * rollup-aware. DEPLOY-BASIS ONLY — every metric derives from real deploy-stage
+ * executions (`event_type='STAGE'` with a non-null `environment`, set by the
+ * forwarder for the stages a user declared in `pb.deploys`). No run-based
+ * fallback: a pipeline with no deploy stage produces no DORA data.
+ *
+ * Four scoped SQL scans run inside one tx (each org-gated by `p.org_id ${pred}`
+ * / `o.org_id ${pred}` so a rollup passes the org→team subtree and a foreign
+ * org's rows never enter): (1) terminal deploy rows PER (execution, env) — one
+ * "deployment" = one execution reaching an env (D1) — → DF / deploy-time CFR /
+ * measured lead time (lead time joins the execution's earliest commit, D2);
+ * the scan also reaches back `windowHours` before `from` so incidents opened
+ * near the window start can correlate to a just-prior deploy; (2) `deployment_outcomes`
+ * in-window → post-deploy CFR component; (3) production restored/failed
+ * outcomes joined to their deploy → MTTR; (4) registry vs deploying → coverage.
+ * The cross-source medians (lead time, MTTR) are computed in JS from clamped
+ * (≥0) deltas.
+ *
+ * @param opts.pipelineId    restrict to one pipeline (per-pipeline DORA)
+ * @param opts.environment   restrict to one deploy environment
+ */
+export declare function getDoraMetrics(orgId: string, from: string, to: string, orgIds?: string[], opts?: DoraOptions): Promise<DoraMetrics>;
+/**
+ * 1.9b DORA trend — deployment frequency + deploy-time change-failure rate
+ * bucketed by `interval` (day/week/month) for a sparkline. Deploy-basis like
+ * getDoraMetrics: buckets terminal deploy-stage executions on their
+ * `completed_at`. Shares the org/rollup + pipelineId/environment scoping. MTTR,
+ * lead time, and post-deploy CFR are intentionally omitted (too heavy to bucket).
+ */
+export declare function getDoraTrend(orgId: string, interval: string, from: string, to: string, orgIds?: string[], opts?: DoraOptions): Promise<DoraTrendPoint[]>;
+/**
+ * 1.10 Per-pipeline BUILD HEALTH (Phase 6) — a standard (NOT `advanced_reporting`)
+ * per-stage breakdown for one pipeline over a [from,to] window. Aggregates the
+ * existing `pipeline_events` STAGE rows: each stage is rolled up per execution
+ * to a terminal status (FAILED wins, then SUCCEEDED) + its max duration, then
+ * grouped per stage into run/success/failure counts, a success rate, and
+ * duration percentiles (p50/p90/p99). Totals sum across stages. Org-scoped via
+ * the pipeline join (`p.org_id ${pred}`) + rollup-aware like the sibling reports;
+ * a pipelineId owned by another org returns an empty breakdown.
+ */
+export declare function getBuildHealth(orgId: string, pipelineId: string, from: string, to: string, orgIds?: string[]): Promise<BuildHealth>;
+/** 2.1 Plugin summary — counts and breakdowns.
+ *  INTENTIONALLY SINGLE-ORG (no rollup): plugin inventory is an org-owned
+ *  asset count, not an execution/build activity report, so a parent's view is
+ *  its own plugins — teams manage their own inventory. Single `= $org` scope. */