@quotivity/cpq-inventory-core 0.1.0

package/lib/config/outbound.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The only two outbound requests the tool makes, both user-initiated, both HubSpot form
+ * submissions made from the browser. Portal ID and form GUIDs are public and compiled in.
+ */
+export declare const HUBSPOT_PORTAL_ID = "243933280";
+/** Email gate — email capture form. Carries name, email, plugin version, run id, lead source. */
+export declare const HUBSPOT_GATE_FORM_GUID = "78c7c119-3bf5-49d9-8c31-6122cfda26b3";
+/** Close screen — meeting request form. Carries the same plus the rendered report summary. */
+export declare const HUBSPOT_MEETING_FORM_GUID = "7a3e9649-209b-415d-81d0-bf6fe002e105";
+/** Internal name of the contact property on the meeting form that receives the report summary. */
+export declare const HUBSPOT_MEETING_SUMMARY_FIELD = "salesforce_cpq_migration_analysis_result";
+export declare const LEAD_SOURCE = "cpq-inventory-tool";
+export declare const SOURCE_URL = "https://github.com/quotivity/salesforce-cpq-migration-analysis";
+export declare const PRIVACY_POLICY_URL = "https://quotivity.com/privacy";
+export declare const LEARN_MORE_URL = "https://quotivity.com";
+/** HubSpot multi-line text fields hold at most 65,536 characters. */
+export declare const HUBSPOT_MULTILINE_LIMIT = 65536;
+export declare function hubspotFormUrl(formGuid: string): string;
+export interface OutboundConfig {
+    portalId: string;
+    gateFormGuid: string;
+    meetingFormGuid: string;
+    meetingSummaryField: string;
+    leadSource: string;
+    sourceUrl: string;
+    privacyPolicyUrl: string;
+    learnMoreUrl: string;
+    configured: boolean;
+}
+export declare function outboundConfig(): OutboundConfig;
+//# sourceMappingURL=outbound.d.ts.map

package/lib/config/outbound.js

@@ -0,0 +1,35 @@
+/**
+ * The only two outbound requests the tool makes, both user-initiated, both HubSpot form
+ * submissions made from the browser. Portal ID and form GUIDs are public and compiled in.
+ */
+export const HUBSPOT_PORTAL_ID = '243933280';
+/** Email gate — email capture form. Carries name, email, plugin version, run id, lead source. */
+export const HUBSPOT_GATE_FORM_GUID = '78c7c119-3bf5-49d9-8c31-6122cfda26b3';
+/** Close screen — meeting request form. Carries the same plus the rendered report summary. */
+export const HUBSPOT_MEETING_FORM_GUID = '7a3e9649-209b-415d-81d0-bf6fe002e105';
+/** Internal name of the contact property on the meeting form that receives the report summary. */
+export const HUBSPOT_MEETING_SUMMARY_FIELD = 'salesforce_cpq_migration_analysis_result';
+export const LEAD_SOURCE = 'cpq-inventory-tool';
+export const SOURCE_URL = 'https://github.com/quotivity/salesforce-cpq-migration-analysis';
+export const PRIVACY_POLICY_URL = 'https://quotivity.com/privacy';
+export const LEARN_MORE_URL = 'https://quotivity.com';
+/** HubSpot multi-line text fields hold at most 65,536 characters. */
+export const HUBSPOT_MULTILINE_LIMIT = 65_536;
+export function hubspotFormUrl(formGuid) {
+    return `https://api.hsforms.com/submissions/v3/integration/submit/${HUBSPOT_PORTAL_ID}/${formGuid}`;
+}
+export function outboundConfig() {
+    const configured = ![HUBSPOT_PORTAL_ID, HUBSPOT_GATE_FORM_GUID, HUBSPOT_MEETING_FORM_GUID].some((v) => v.startsWith('REPLACE_WITH_'));
+    return {
+        portalId: HUBSPOT_PORTAL_ID,
+        gateFormGuid: HUBSPOT_GATE_FORM_GUID,
+        meetingFormGuid: HUBSPOT_MEETING_FORM_GUID,
+        meetingSummaryField: HUBSPOT_MEETING_SUMMARY_FIELD,
+        leadSource: LEAD_SOURCE,
+        sourceUrl: SOURCE_URL,
+        privacyPolicyUrl: PRIVACY_POLICY_URL,
+        learnMoreUrl: LEARN_MORE_URL,
+        configured,
+    };
+}
+//# sourceMappingURL=outbound.js.map

package/lib/connection.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The connection contract both distributions implement. The plugin adapts the Salesforce CLI's
+ * connection; the standalone script implements it over fetch. Core never sees a credential.
+ */
+export interface QueryResult<T> {
+    /** Total matching records as reported by the API (exact, independent of what was retrieved). */
+    totalSize: number;
+    /** Every page of records, unless the SOQL carried a LIMIT. */
+    records: T[];
+}
+export interface QueryOptions {
+    /** Run against the Tooling API instead of the data API. */
+    tooling?: boolean;
+}
+export interface OrgConnection {
+    readonly instanceUrl: string;
+    readonly username: string;
+    readonly orgId: string;
+    /** Alias or display name for the org, used in the report header and the PDF filename. */
+    readonly orgName: string;
+    query<T extends object = Record<string, unknown>>(soql: string, opts?: QueryOptions): Promise<QueryResult<T>>;
+}
+export declare class ConnectionError extends Error {
+    readonly code: string | undefined;
+    readonly retryable: boolean;
+    constructor(message: string, code: string | undefined, retryable: boolean);
+}
+export declare function isMissingObjectError(err: unknown): boolean;
+export declare function isRetryable(err: unknown): boolean;
+export declare function errorText(err: unknown): string;
+export interface RetryOptions {
+    attempts?: number;
+    baseDelayMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+}
+/**
+ * Every request is a read, so every request is retryable. Three attempts with backoff; a
+ * non-retryable API error (bad object, bad field) fails immediately so the caller can mark the
+ * object absent rather than looping.
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;
+//# sourceMappingURL=connection.d.ts.map

package/lib/connection.js

@@ -0,0 +1,52 @@
+export class ConnectionError extends Error {
+    code;
+    retryable;
+    constructor(message, code, retryable) {
+        super(message);
+        this.code = code;
+        this.retryable = retryable;
+        this.name = 'ConnectionError';
+    }
+}
+const NON_RETRYABLE = /INVALID_TYPE|INVALID_FIELD|MALFORMED_QUERY|INVALID_QUERY_FILTER_OPERATOR|NO_SUCH_COLUMN|INVALID_LOGIN|INSUFFICIENT_ACCESS|FIELD_NOT_FOUND|sObject type .* is not supported|No such column/i;
+export function isMissingObjectError(err) {
+    const text = errorText(err);
+    return /INVALID_TYPE|sObject type .* is not supported|Object type .* is not supported/i.test(text);
+}
+export function isRetryable(err) {
+    if (err instanceof ConnectionError)
+        return err.retryable;
+    return !NON_RETRYABLE.test(errorText(err));
+}
+export function errorText(err) {
+    if (err instanceof Error) {
+        const withCode = err;
+        return [withCode.errorCode, withCode.code, err.message].filter(Boolean).join(' ');
+    }
+    return String(err);
+}
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Every request is a read, so every request is retryable. Three attempts with backoff; a
+ * non-retryable API error (bad object, bad field) fails immediately so the caller can mark the
+ * object absent rather than looping.
+ */
+export async function withRetry(fn, opts = {}) {
+    const attempts = opts.attempts ?? 3;
+    const base = opts.baseDelayMs ?? 500;
+    const sleep = opts.sleep ?? defaultSleep;
+    let lastErr;
+    for (let i = 0; i < attempts; i++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            if (!isRetryable(err) || i === attempts - 1)
+                throw err;
+            await sleep(base * 2 ** i);
+        }
+    }
+    throw lastErr;
+}
+//# sourceMappingURL=connection.js.map

package/lib/extract/index.d.ts

@@ -0,0 +1,112 @@
+import type { OrgConnection } from '../connection.js';
+import { type ObjectRead, quote } from '../soql.js';
+import type { BucketId } from '../types.js';
+import * as R from './records.js';
+export interface ExtractOptions {
+    /** Dead-configuration window in months. Defaults to 24. */
+    windowMonths?: number;
+    /** Injectable clock for tests. */
+    now?: Date;
+    onProgress?: (event: ProgressEvent) => void;
+}
+export type ProgressStep = BucketId | 'seed' | 'classify';
+export interface ProgressEvent {
+    step: ProgressStep;
+    status: 'start' | 'done' | 'error';
+    detail?: string;
+}
+export interface YearCount {
+    year: number;
+    type: string;
+    count: number;
+}
+export interface Extraction {
+    windowMonths: number;
+    since: string;
+    approvalSince: string;
+    now: string;
+    product2: ObjectRead<R.Product2Rec>;
+    pricebook2: ObjectRead<R.Pricebook2Rec>;
+    currencyType: ObjectRead<R.CurrencyTypeRec>;
+    datedConversionRate: ObjectRead<R.DatedConversionRateRec>;
+    productFeature: ObjectRead<R.ProductFeatureRec>;
+    productOption: ObjectRead<R.ProductOptionRec>;
+    optionConstraint: ObjectRead<R.OptionConstraintRec>;
+    configurationRule: ObjectRead<R.ConfigurationRuleRec>;
+    configurationAttribute: ObjectRead<R.ConfigurationAttributeRec>;
+    productRule: ObjectRead<R.ProductRuleRec>;
+    errorCondition: ObjectRead<R.ErrorConditionRec>;
+    productAction: ObjectRead<R.ProductActionRec>;
+    quoteProcess: ObjectRead<R.QuoteProcessRec>;
+    processInput: ObjectRead<R.ProcessInputRec>;
+    processInputCondition: ObjectRead<R.ProcessInputConditionRec>;
+    priceRule: ObjectRead<R.PriceRuleRec>;
+    priceCondition: ObjectRead<R.PriceConditionRec>;
+    priceAction: ObjectRead<R.PriceActionRec>;
+    summaryVariable: ObjectRead<R.SummaryVariableRec>;
+    lookupQuery: ObjectRead<R.LookupQueryRec>;
+    blockPrice: ObjectRead<R.BlockPriceRec>;
+    dimension: ObjectRead<R.DimensionRec>;
+    segmentedLines: ObjectRead<R.SegmentedLineRec>;
+    discountSchedule: ObjectRead<R.DiscountScheduleRec>;
+    discountTier: ObjectRead<R.DiscountTierRec>;
+    contractedPrice: ObjectRead<R.ContractedPriceRec>;
+    approvalRule: ObjectRead<R.ApprovalRuleRec>;
+    approvalCondition: ObjectRead<R.ApprovalConditionRec>;
+    approvalChain: ObjectRead<R.NamedRec>;
+    approver: ObjectRead<R.ApproverRec>;
+    approvalVariable: ObjectRead<R.NamedRec>;
+    trackedField: ObjectRead<R.NamedRec>;
+    approvalHistory: ObjectRead<R.ApprovalHistoryRec>;
+    processDefinition: ObjectRead<R.ProcessDefinitionRec>;
+    processInstance: ObjectRead<R.ProcessInstanceRec>;
+    quoteTemplate: ObjectRead<R.NamedRec>;
+    templateSection: ObjectRead<R.TemplateSectionRec>;
+    templateContent: ObjectRead<R.TemplateContentRec>;
+    lineColumn: ObjectRead<R.LineColumnRec>;
+    quoteTerm: ObjectRead<R.NamedRec>;
+    termCondition: ObjectRead<R.TermConditionRec>;
+    quoteLineGroupCount: number;
+    quoteLineGroupAlive: number;
+    contractActive: number;
+    contractAlive: number;
+    subscriptionCount: number;
+    orderCount: number;
+    assetCount: number;
+    quotesByYear: YearCount[];
+    quoteDateField: string;
+    quotesInWindow: number;
+    quoteLinesInWindow: number;
+    distinctProductsQuoted: number;
+    customScript: ObjectRead<R.CustomScriptRec>;
+    customAction: ObjectRead<R.CustomActionRec>;
+    apexTrigger: ObjectRead<R.ApexTriggerRec>;
+    webLink: ObjectRead<R.WebLinkRec>;
+    layout: ObjectRead<R.LayoutRec>;
+    flexiPage: ObjectRead<R.FlexiPageRec>;
+    validationRule: ObjectRead<R.ValidationRuleRec>;
+    quoteFields: ObjectRead<R.FieldDefinitionRec>;
+    quoteLineFields: ObjectRead<R.FieldDefinitionRec>;
+    /** Creator ids that resolve to no User record — the package install signature. */
+    seedCreators: Set<string>;
+    /** Records per object created by a seed creator (removed from every count). */
+    seeded: Record<string, number>;
+    /** Objects that could not be read after retries, with the reason. */
+    unread: {
+        object: string;
+        reason: string;
+    }[];
+}
+export declare function extractAll(conn: OrgConnection, opts?: ExtractOptions): Promise<Extraction>;
+/** Business date for quote volume: StartDate, then ExpirationDate, then CreatedDate. Prints which. */
+export declare function pickQuoteDateField(conn: OrgConnection): Promise<string>;
+/**
+ * For each configuration object, group by CreatedById. A creator that resolves to no User record is
+ * the package install user; its records are seed data, reported separately and never given a verdict.
+ */
+export declare function detectSeeds(conn: OrgConnection, ex: Omit<Extraction, 'seedCreators' | 'seeded'>): Promise<{
+    seedCreators: Set<string>;
+    seeded: Record<string, number>;
+}>;
+export { quote };
+//# sourceMappingURL=index.d.ts.map

package/lib/extract/index.js

@@ -0,0 +1,373 @@
+import { aggregate, count, inList, quote, readObject, soqlDate } from '../soql.js';
+import * as R from './records.js';
+const monthsAgo = (now, months) => {
+    const d = new Date(now);
+    d.setUTCMonth(d.getUTCMonth() - months);
+    return d;
+};
+/** Objects CPQ seeds through its post-install process. Checked on every configuration object read. */
+const SEED_CHECKED = [
+    'Product2',
+    'Pricebook2',
+    'SBQQ__ProductFeature__c',
+    'SBQQ__ProductOption__c',
+    'SBQQ__OptionConstraint__c',
+    'SBQQ__ConfigurationRule__c',
+    'SBQQ__ConfigurationAttribute__c',
+    'SBQQ__ProductRule__c',
+    'SBQQ__QuoteProcess__c',
+    'SBQQ__ProcessInput__c',
+    'SBQQ__PriceRule__c',
+    'SBQQ__SummaryVariable__c',
+    'SBQQ__LookupQuery__c',
+    'SBQQ__DiscountSchedule__c',
+    'SBQQ__ContractedPrice__c',
+    'SBQQ__Dimension__c',
+    'SBQQ__BlockPrice__c',
+    'sbaa__ApprovalRule__c',
+    'sbaa__ApprovalChain__c',
+    'sbaa__Approver__c',
+    'sbaa__ApprovalVariable__c',
+    'sbaa__TrackedField__c',
+    'SBQQ__QuoteTemplate__c',
+    'SBQQ__TemplateContent__c',
+    'SBQQ__LineColumn__c',
+    'SBQQ__QuoteTerm__c',
+    'SBQQ__CustomScript__c',
+    'SBQQ__CustomAction__c',
+];
+export async function extractAll(conn, opts = {}) {
+    const now = opts.now ?? new Date();
+    const windowMonths = opts.windowMonths ?? 24;
+    const since = soqlDate(monthsAgo(now, windowMonths));
+    const approvalSince = soqlDate(monthsAgo(now, 12));
+    const progress = opts.onProgress ?? (() => { });
+    const unread = [];
+    const track = (read) => {
+        if (read.status === 'unread')
+            unread.push({ object: read.object, reason: read.reason ?? 'unknown' });
+        return read;
+    };
+    const step = async (id, fn) => {
+        progress({ step: id, status: 'start' });
+        try {
+            const out = await fn();
+            progress({ step: id, status: 'done' });
+            return out;
+        }
+        catch (err) {
+            progress({
+                step: id,
+                status: 'error',
+                detail: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
+    };
+    const read = (object, fields, o = {}) => readObject(conn, object, fields, o).then(track);
+    // ── Catalog ──────────────────────────────────────────────────────────────
+    const catalog = await step('catalog', async () => ({
+        product2: await read('Product2', R.PRODUCT2_FIELDS, {
+            where: 'IsActive = true',
+        }),
+        pricebook2: await read('Pricebook2', R.PRICEBOOK2_FIELDS),
+        currencyType: await read('CurrencyType', R.CURRENCY_FIELDS, {
+            optional: true,
+        }),
+        datedConversionRate: await read('DatedConversionRate', R.DCR_FIELDS, {
+            optional: true,
+        }),
+    }));
+    // ── Configuration (bundles + product rules, the first classifier input set) ──
+    const configuration = await step('configuration', async () => ({
+        productFeature: await read('SBQQ__ProductFeature__c', R.FEATURE_FIELDS),
+        productOption: await read('SBQQ__ProductOption__c', R.OPTION_FIELDS),
+        optionConstraint: await read('SBQQ__OptionConstraint__c', R.CONSTRAINT_FIELDS),
+        configurationRule: await read('SBQQ__ConfigurationRule__c', R.CONFIG_RULE_FIELDS),
+        configurationAttribute: await read('SBQQ__ConfigurationAttribute__c', R.ATTRIBUTE_FIELDS),
+        productRule: await read('SBQQ__ProductRule__c', R.PRODUCT_RULE_FIELDS, {
+            classifierInput: true,
+        }),
+        errorCondition: await read('SBQQ__ErrorCondition__c', R.ERROR_CONDITION_FIELDS, {
+            classifierInput: true,
+            orderBy: 'SBQQ__Rule__c, SBQQ__Index__c',
+        }),
+        productAction: await read('SBQQ__ProductAction__c', R.PRODUCT_ACTION_FIELDS, {
+            classifierInput: true,
+        }),
+    }));
+    // ── Discovery & capture ──────────────────────────────────────────────────
+    const discovery = await step('discovery', async () => ({
+        quoteProcess: await read('SBQQ__QuoteProcess__c', R.QUOTE_PROCESS_FIELDS),
+        processInput: await read('SBQQ__ProcessInput__c', R.PROCESS_INPUT_FIELDS),
+        processInputCondition: await read('SBQQ__ProcessInputCondition__c', R.PROCESS_INPUT_CONDITION_FIELDS),
+    }));
+    // ── Price determination (price rules, the second classifier input set) ──
+    const price = await step('price', async () => ({
+        priceRule: await read('SBQQ__PriceRule__c', R.PRICE_RULE_FIELDS, {
+            classifierInput: true,
+        }),
+        priceCondition: await read('SBQQ__PriceCondition__c', R.PRICE_CONDITION_FIELDS, {
+            classifierInput: true,
+            orderBy: 'SBQQ__Rule__c, SBQQ__Index__c',
+        }),
+        priceAction: await read('SBQQ__PriceAction__c', R.PRICE_ACTION_FIELDS, {
+            classifierInput: true,
+            orderBy: 'SBQQ__Rule__c, SBQQ__Order__c',
+        }),
+        summaryVariable: await read('SBQQ__SummaryVariable__c', R.SUMMARY_VARIABLE_FIELDS),
+        lookupQuery: await read('SBQQ__LookupQuery__c', R.LOOKUP_QUERY_FIELDS),
+        blockPrice: await read('SBQQ__BlockPrice__c', R.BLOCK_PRICE_FIELDS),
+        dimension: await read('SBQQ__Dimension__c', R.DIMENSION_FIELDS),
+        segmentedLines: await read('SBQQ__QuoteLine__c', R.SEGMENTED_LINE_FIELDS, {
+            where: `SBQQ__Dimension__c != null AND LastModifiedDate >= ${since}`,
+            orderBy: 'SBQQ__SegmentKey__c, SBQQ__SegmentIndex__c',
+        }),
+    }));
+    // ── Discounting ─────────────────────────────────────────────────────────
+    const discounting = await step('discounting', async () => ({
+        discountSchedule: await read('SBQQ__DiscountSchedule__c', R.DISCOUNT_SCHEDULE_FIELDS),
+        discountTier: await read('SBQQ__DiscountTier__c', R.DISCOUNT_TIER_FIELDS, {
+            orderBy: 'SBQQ__Schedule__c, SBQQ__Number__c',
+        }),
+        contractedPrice: await read('SBQQ__ContractedPrice__c', R.CONTRACTED_PRICE_FIELDS),
+    }));
+    // ── Guardrails (platform validation rules; product rules already read) ──
+    const guardrails = await step('guardrails', async () => {
+        const validationRule = await read('ValidationRule', R.VALIDATION_RULE_FIELDS, {
+            where: 'NamespacePrefix = null',
+            tooling: true,
+        });
+        validationRule.records = validationRule.records.filter((v) => R.isCpqObject(v.EntityDefinition?.QualifiedApiName ?? undefined));
+        validationRule.count = validationRule.records.length;
+        return { validationRule };
+    });
+    // ── Approvals: Advanced Approvals (sbaa) and native processes ───────────
+    const approvals = await step('approvals', async () => ({
+        approvalRule: await read('sbaa__ApprovalRule__c', R.APPROVAL_RULE_FIELDS, {
+            optional: true,
+        }),
+        approvalCondition: await read('sbaa__ApprovalCondition__c', R.APPROVAL_CONDITION_FIELDS, {
+            optional: true,
+        }),
+        approvalChain: await read('sbaa__ApprovalChain__c', R.NAMED_FIELDS, {
+            optional: true,
+        }),
+        approver: await read('sbaa__Approver__c', R.APPROVER_FIELDS, { optional: true }),
+        approvalVariable: await read('sbaa__ApprovalVariable__c', R.NAMED_FIELDS, {
+            optional: true,
+        }),
+        trackedField: await read('sbaa__TrackedField__c', R.NAMED_FIELDS, {
+            optional: true,
+        }),
+        approvalHistory: await read('sbaa__Approval__c', R.APPROVAL_HISTORY_FIELDS, {
+            optional: true,
+            where: `CreatedDate >= ${approvalSince}`,
+        }),
+        processDefinition: await read('ProcessDefinition', R.PROCESS_DEFINITION_FIELDS, {
+            where: "Type = 'Approval' AND TableEnumOrId IN ('SBQQ__Quote__c', 'Opportunity')",
+        }),
+        processInstance: await read('ProcessInstance', R.PROCESS_INSTANCE_FIELDS, {
+            where: `CreatedDate >= ${approvalSince} AND ProcessDefinition.TableEnumOrId IN ('SBQQ__Quote__c', 'Opportunity')`,
+        }),
+    }));
+    // ── Quote output ────────────────────────────────────────────────────────
+    const output = await step('output', async () => ({
+        quoteTemplate: await read('SBQQ__QuoteTemplate__c', R.NAMED_FIELDS),
+        templateSection: await read('SBQQ__TemplateSection__c', R.TEMPLATE_SECTION_FIELDS),
+        templateContent: await read('SBQQ__TemplateContent__c', R.TEMPLATE_CONTENT_FIELDS),
+        lineColumn: await read('SBQQ__LineColumn__c', R.LINE_COLUMN_FIELDS),
+        quoteTerm: await read('SBQQ__QuoteTerm__c', R.NAMED_FIELDS),
+        termCondition: await read('SBQQ__TermCondition__c', R.TERM_CONDITION_FIELDS),
+        quoteLineGroupCount: await safeCount(conn, 'SBQQ__QuoteLineGroup__c'),
+        quoteLineGroupAlive: await safeCount(conn, 'SBQQ__QuoteLineGroup__c', `LastModifiedDate >= ${since}`),
+    }));
+    // ── Contract lifecycle + volume ─────────────────────────────────────────
+    const lifecycle = await step('lifecycle', async () => {
+        const quoteDateField = await pickQuoteDateField(conn);
+        const dateExpr = quoteDateField === 'CreatedDate' ? 'CreatedDate' : quoteDateField;
+        const byYear = await aggregate(conn, `SELECT CALENDAR_YEAR(${dateExpr}) y, SBQQ__Type__c t, COUNT(Id) c FROM SBQQ__Quote__c GROUP BY CALENDAR_YEAR(${dateExpr}), SBQQ__Type__c`);
+        const sinceDate = since.slice(0, 10);
+        const windowWhere = quoteDateField === 'CreatedDate'
+            ? `CreatedDate >= ${since}`
+            : `${quoteDateField} >= ${sinceDate}`;
+        const distinct = await aggregate(conn, `SELECT COUNT_DISTINCT(SBQQ__Product__c) n FROM SBQQ__QuoteLine__c WHERE SBQQ__Quote__r.${windowWhere}`);
+        return {
+            contractActive: await safeCount(conn, 'Contract', "Status = 'Activated'"),
+            contractAlive: await safeCount(conn, 'Contract', `Status = 'Activated' AND LastModifiedDate >= ${since}`),
+            subscriptionCount: await safeCount(conn, 'SBQQ__Subscription__c'),
+            orderCount: await safeCount(conn, 'Order', 'SBQQ__Quote__c != null'),
+            assetCount: await safeCount(conn, 'Asset'),
+            quotesByYear: byYear.rows
+                .filter((r) => r.y != null)
+                .map((r) => ({ year: Number(r.y), type: r.t ?? 'Quote', count: Number(r.c) })),
+            quoteDateField,
+            quotesInWindow: await safeCount(conn, 'SBQQ__Quote__c', windowWhere),
+            quoteLinesInWindow: await safeCount(conn, 'SBQQ__QuoteLine__c', `SBQQ__Quote__r.${windowWhere}`),
+            distinctProductsQuoted: Number(distinct.rows[0]?.n ?? 0),
+        };
+    });
+    // ── Custom code & UI ────────────────────────────────────────────────────
+    const code = await step('code', async () => {
+        const apexTrigger = await read('ApexTrigger', R.APEX_TRIGGER_FIELDS, {
+            where: 'NamespacePrefix = null',
+        });
+        apexTrigger.records = apexTrigger.records.filter((t) => R.isCpqObject(t.TableEnumOrId));
+        apexTrigger.count = apexTrigger.records.length;
+        const webLink = await read('WebLink', R.WEBLINK_FIELDS, {
+            where: 'NamespacePrefix = null',
+            tooling: true,
+        });
+        webLink.records = webLink.records.filter((w) => R.isCpqObject(w.PageOrSobjectType ?? undefined));
+        webLink.count = webLink.records.length;
+        const layout = await read('Layout', R.LAYOUT_FIELDS, {
+            where: 'NamespacePrefix = null',
+            tooling: true,
+        });
+        layout.records = layout.records.filter((l) => R.isCpqObject(l.TableEnumOrId ?? undefined));
+        layout.count = layout.records.length;
+        const flexiPage = await read('FlexiPage', R.FLEXIPAGE_FIELDS, {
+            where: "NamespacePrefix = null AND Type = 'RecordPage'",
+            tooling: true,
+        });
+        flexiPage.records = flexiPage.records.filter((f) => R.isCpqObject(f.EntityDefinitionId ?? undefined));
+        flexiPage.count = flexiPage.records.length;
+        return {
+            customScript: await read('SBQQ__CustomScript__c', R.CUSTOM_SCRIPT_FIELDS),
+            customAction: await read('SBQQ__CustomAction__c', R.CUSTOM_ACTION_FIELDS),
+            apexTrigger,
+            webLink,
+            layout,
+            flexiPage,
+            quoteFields: await read('FieldDefinition', R.FIELD_DEFINITION_FIELDS, {
+                where: "EntityDefinition.QualifiedApiName = 'SBQQ__Quote__c'",
+            }),
+            quoteLineFields: await read('FieldDefinition', R.FIELD_DEFINITION_FIELDS, {
+                where: "EntityDefinition.QualifiedApiName = 'SBQQ__QuoteLine__c'",
+            }),
+        };
+    });
+    const partial = {
+        windowMonths,
+        since,
+        approvalSince,
+        now: now.toISOString(),
+        ...catalog,
+        ...configuration,
+        ...discovery,
+        ...price,
+        ...discounting,
+        ...guardrails,
+        ...approvals,
+        ...output,
+        ...lifecycle,
+        ...code,
+        unread,
+    };
+    // ── Package seed detection, applied to every configuration object ───────
+    const { seedCreators, seeded } = await step('seed', () => detectSeeds(conn, partial));
+    return { ...partial, seedCreators, seeded };
+}
+async function safeCount(conn, object, where) {
+    try {
+        return await count(conn, object, where);
+    }
+    catch {
+        return 0;
+    }
+}
+/** Business date for quote volume: StartDate, then ExpirationDate, then CreatedDate. Prints which. */
+export async function pickQuoteDateField(conn) {
+    const total = await safeCount(conn, 'SBQQ__Quote__c');
+    if (total === 0)
+        return 'CreatedDate';
+    for (const field of ['SBQQ__StartDate__c', 'SBQQ__ExpirationDate__c']) {
+        const populated = await safeCount(conn, 'SBQQ__Quote__c', `${field} != null`);
+        if (populated / total >= 0.5)
+            return field;
+    }
+    return 'CreatedDate';
+}
+/**
+ * For each configuration object, group by CreatedById. A creator that resolves to no User record is
+ * the package install user; its records are seed data, reported separately and never given a verdict.
+ */
+export async function detectSeeds(conn, ex) {
+    const groups = new Map();
+    const creators = new Set();
+    for (const object of SEED_CHECKED) {
+        const read = readFor(ex, object);
+        if (read?.status !== 'ok' || read.count === 0)
+            continue;
+        const res = await aggregate(conn, `SELECT CreatedById, COUNT(Id) n FROM ${object} GROUP BY CreatedById`);
+        const rows = res.rows
+            .filter((r) => r.CreatedById)
+            .map((r) => ({ creator: r.CreatedById, n: Number(r.n) }));
+        groups.set(object, rows);
+        for (const r of rows)
+            creators.add(r.creator);
+    }
+    const seedCreators = new Set();
+    if (creators.size) {
+        const resolved = new Set();
+        const ids = [...creators];
+        for (let i = 0; i < ids.length; i += 200) {
+            const chunk = ids.slice(i, i + 200);
+            const users = await aggregate(conn, `SELECT Id FROM User WHERE Id IN ${inList(chunk)}`);
+            if (users.status !== 'ok')
+                return { seedCreators, seeded: {} };
+            for (const u of users.rows)
+                resolved.add(u.Id);
+        }
+        for (const id of creators)
+            if (!resolved.has(id))
+                seedCreators.add(id);
+    }
+    const seeded = {};
+    for (const [object, rows] of groups) {
+        const n = rows.filter((r) => seedCreators.has(r.creator)).reduce((a, r) => a + r.n, 0);
+        if (n > 0)
+            seeded[object] = n;
+        const read = readFor(ex, object);
+        if (read && n > 0) {
+            read.records = read.records.filter((rec) => !seedCreators.has(String(rec.CreatedById ?? '')));
+            read.count = Math.max(0, read.count - n);
+        }
+    }
+    return { seedCreators, seeded };
+}
+function readFor(ex, object) {
+    const map = {
+        Product2: ex.product2,
+        Pricebook2: ex.pricebook2,
+        SBQQ__ProductFeature__c: ex.productFeature,
+        SBQQ__ProductOption__c: ex.productOption,
+        SBQQ__OptionConstraint__c: ex.optionConstraint,
+        SBQQ__ConfigurationRule__c: ex.configurationRule,
+        SBQQ__ConfigurationAttribute__c: ex.configurationAttribute,
+        SBQQ__ProductRule__c: ex.productRule,
+        SBQQ__QuoteProcess__c: ex.quoteProcess,
+        SBQQ__ProcessInput__c: ex.processInput,
+        SBQQ__PriceRule__c: ex.priceRule,
+        SBQQ__SummaryVariable__c: ex.summaryVariable,
+        SBQQ__LookupQuery__c: ex.lookupQuery,
+        SBQQ__DiscountSchedule__c: ex.discountSchedule,
+        SBQQ__ContractedPrice__c: ex.contractedPrice,
+        SBQQ__Dimension__c: ex.dimension,
+        SBQQ__BlockPrice__c: ex.blockPrice,
+        sbaa__ApprovalRule__c: ex.approvalRule,
+        sbaa__ApprovalChain__c: ex.approvalChain,
+        sbaa__Approver__c: ex.approver,
+        sbaa__ApprovalVariable__c: ex.approvalVariable,
+        sbaa__TrackedField__c: ex.trackedField,
+        SBQQ__QuoteTemplate__c: ex.quoteTemplate,
+        SBQQ__TemplateContent__c: ex.templateContent,
+        SBQQ__LineColumn__c: ex.lineColumn,
+        SBQQ__QuoteTerm__c: ex.quoteTerm,
+        SBQQ__CustomScript__c: ex.customScript,
+        SBQQ__CustomAction__c: ex.customAction,
+    };
+    return map[object];
+}
+export { quote };
+//# sourceMappingURL=index.js.map