@osdk/react-devtools 0.5.0

package/build/types/utils/EventTimeline.d.ts

@@ -0,0 +1,102 @@
+/**
+* Union type for all monitoring events.
+* Each event type has a timestamp for temporal correlation.
+*/
+export type MonitorEvent = RenderEvent | EmissionEvent | ActionStartEvent | ActionCompleteEvent | PropertyAccessEvent | LinkTraversalEvent | ObjectModifiedEvent | MockHitEvent | OsdkPauseBlockEvent;
+export interface RenderEvent {
+	type: "RENDER";
+	componentId: string;
+	componentName: string;
+	duration: number;
+	timestamp: number;
+	renderCycle?: number;
+}
+export interface EmissionEvent {
+	type: "EMISSION";
+	subscriptionId: string;
+	objectKey?: string;
+	timestamp: number;
+	isOptimistic?: boolean;
+}
+export interface ActionStartEvent {
+	type: "ACTION_START";
+	actionId: string;
+	actionName: string;
+	timestamp: number;
+	componentId?: string;
+}
+export interface ActionCompleteEvent {
+	type: "ACTION_COMPLETE";
+	actionId: string;
+	timestamp: number;
+	success: boolean;
+	error?: string;
+}
+export interface PropertyAccessEvent {
+	type: "PROPERTY_ACCESS";
+	componentId: string;
+	objectKey: string;
+	property: string;
+	timestamp: number;
+	renderCycle?: number;
+}
+export interface LinkTraversalEvent {
+	type: "LINK_TRAVERSAL";
+	sourceKey: string;
+	linkName: string;
+	timestamp: number;
+	componentId?: string;
+}
+export interface ObjectModifiedEvent {
+	type: "OBJECT_MODIFIED";
+	actionId: string;
+	objectType: string;
+	primaryKey: string;
+	modifiedBy: "optimistic" | "server";
+	timestamp: number;
+}
+export interface MockHitEvent {
+	type: "MOCK_HIT";
+	subscriptionId: string;
+	timestamp: number;
+	mockId?: string;
+}
+export interface OsdkPauseBlockEvent {
+	type: "OSDK_PAUSE_BLOCK";
+	pathname: string;
+	timestamp: number;
+}
+export interface ActionCausality {
+	start: ActionStartEvent;
+	complete: ActionCompleteEvent;
+	optimisticUpdates: EmissionEvent[];
+	refetches: EmissionEvent[];
+	renders: RenderEvent[];
+	duration: number;
+}
+export declare class EventTimeline {
+	private events;
+	private eventCounts;
+	private subscribers;
+	constructor(maxEvents?: number);
+	record(event: MonitorEvent): void;
+	findEventsInWindow(timestamp: number, windowMs: number, eventType?: MonitorEvent["type"]): MonitorEvent[];
+	findEventsBefore(timestamp: number, windowMs: number, eventType?: MonitorEvent["type"]): MonitorEvent[];
+	findRenderTrigger(renderEvent: RenderEvent): EmissionEvent | null;
+	buildActionCausality(actionId: string): ActionCausality;
+	subscribe(callback: (event: MonitorEvent) => void): () => void;
+	getEventsByType<T extends MonitorEvent["type"]>(type: T): Extract<MonitorEvent, {
+		type: T
+	}>[];
+	getAllEvents(): MonitorEvent[];
+	getEventCounts(): Map<MonitorEvent["type"], number>;
+	clear(): void;
+	getSize(): number;
+	private notifySubscribers;
+	findLast<T extends MonitorEvent["type"]>(type: T, predicate: (event: Extract<MonitorEvent, {
+		type: T
+	}>) => boolean): Extract<MonitorEvent, {
+		type: T
+	}> | null;
+	getLastEmission(subscriptionId: string): EmissionEvent | null;
+}

package/build/types/utils/EventTimeline.d.ts.map

@@ -0,0 +1 @@
+{"mappings":";;;;AAsBA,YAAY,eACR,cACA,gBACA,mBACA,sBACA,sBACA,qBACA,sBACA,eACA;AAEJ,iBAAiB,YAAY;CAC3B,MAAM;CACN;CACA;CACA;CACA;CACA;AACD;AAED,iBAAiB,cAAc;CAC7B,MAAM;CACN;CACA;CACA;CACA;AACD;AAED,iBAAiB,iBAAiB;CAChC,MAAM;CACN;CACA;CACA;CACA;AACD;AAED,iBAAiB,oBAAoB;CACnC,MAAM;CACN;CACA;CACA;CACA;AACD;AAED,iBAAiB,oBAAoB;CACnC,MAAM;CACN;CACA;CACA;CACA;CACA;AACD;AAED,iBAAiB,mBAAmB;CAClC,MAAM;CACN;CACA;CACA;CACA;AACD;AAED,iBAAiB,oBAAoB;CACnC,MAAM;CACN;CACA;CACA;CACA,YAAY,eAAe;CAC3B;AACD;AAED,iBAAiB,aAAa;CAC5B,MAAM;CACN;CACA;CACA;AACD;AAED,iBAAiB,oBAAoB;CACnC,MAAM;CACN;CACA;AACD;AAED,iBAAiB,gBAAgB;CAC/B,OAAO;CACP,UAAU;CACV,mBAAmB;CACnB,WAAW;CACX,SAAS;CACT;AACD;AAED,OAAO,cAAM,cAAc;CACzB,QAAQ;CACR,QAAQ;CACR,QAAQ;CAER,YAAYA;CAIZ,OAAOC,OAAO;CAad,mBACEC,mBACAC,kBACAC,YAAY,aAAa,UACxB;CAUH,iBACEF,mBACAC,kBACAC,YAAY,aAAa,UACxB;CAUH,kBAAkBC,aAAa,cAAc;CAmB7C,qBAAqBC,mBAAmB;CAiDxC,UAAUC,WAAWN,OAAO;CAK5B,gBAAgB,UAAU,aAAa,SACrCO,MAAM,IACL,QAAQ,cAAc;EAAE,MAAM;CAAG;CAMpC,gBAAgB;CAIhB,kBAAkB,IAAI,aAAa;CAInC;CAKA;CAIA,QAAQ;CAWR,SAAS,UAAU,aAAa,SAC9BA,MAAM,GACNC,YAAYC,OAAO,QAAQ,cAAc;EAAE,MAAM;CAAG,iBACnD,QAAQ,cAAc;EAAE,MAAM;CAAG;CAcpC,gBAAgBC,yBAAyB;AAM1C","names":["maxEvents: number","event: MonitorEvent","timestamp: number","windowMs: number","eventType?: MonitorEvent[\"type\"]","renderEvent: RenderEvent","actionId: string","callback: (event: MonitorEvent) => void","type: T","predicate: (event: Extract<MonitorEvent, { type: T }>) => boolean","event: Extract<MonitorEvent, { type: T }>","subscriptionId: string"],"sources":["../../../src/utils/EventTimeline.ts"],"version":3,"file":"EventTimeline.d.ts"}

package/build/types/utils/LinkTraversalTracker.d.ts

@@ -0,0 +1,43 @@
+import type { EventTimeline } from "./EventTimeline.js";
+export interface LinkTraversalEvent {
+	sourceObjectType: string;
+	sourceObjectKey: string;
+	linkName: string;
+	timestamp: number;
+	componentId?: string;
+	subscriptionId: string;
+}
+export interface LinkedObjectsEvent {
+	subscriptionId: string;
+	linkName: string;
+	objects: Array<{
+		objectType: string
+		primaryKey: string
+	}>;
+}
+export declare class LinkTraversalTracker {
+	private traversals;
+	private linkedObjects;
+	private maxTraversals;
+	private eventTimeline;
+	recordTraversal(event: LinkTraversalEvent): void;
+	setEventTimeline(timeline: EventTimeline | null): void;
+	recordLinkedObjects(event: LinkedObjectsEvent): void;
+	getTraversalChain(sourceObjectKey: string): LinkTraversalEvent[];
+	findRedundantTraversals(windowMs?: number): Array<{
+		linkKey: string
+		count: number
+		componentIds: Set<string>
+	}>;
+	getRecentTraversals(limit?: number): LinkTraversalEvent[];
+	getTraversalsByComponent(componentId: string): LinkTraversalEvent[];
+	getTraversalsByLink(linkName: string): LinkTraversalEvent[];
+	clear(): void;
+	getStats(): {
+		totalTraversals: number
+		uniqueLinks: number
+		uniqueComponents: number
+		mostUsedLinks: Array<[string, number]>
+		linkedObjectsTracked: number
+	};
+}

package/build/types/utils/LinkTraversalTracker.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc,qBAAqB,oBAAqB;AAExD,iBAAiB,mBAAmB;CAClC;CACA;CACA;CACA;CACA;CACA;AACD;AAED,iBAAiB,mBAAmB;CAClC;CACA;CACA,SAAS,MAAM;EAAE;EAAoB;CAAoB;AAC1D;AAED,OAAO,cAAM,qBAAqB;CAChC,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CAER,gBAAgBA,OAAO;CAmBvB,iBAAiBC,UAAU;CAI3B,oBAAoBC,OAAO;CAI3B,kBAAkBC,0BAA0B;CA4B5C,wBACEC,oBACC,MAAM;EACP;EACA;EACA,cAAc;CACf;CA8BD,oBAAoBC,iBAAqB;CAIzC,yBAAyBC,sBAAsB;CAI/C,oBAAoBC,mBAAmB;CAIvC;CAKA,YAAY;EACV;EACA;EACA;EACA,eAAe;EACf;CACD;AA4BF","names":["event: LinkTraversalEvent","timeline: EventTimeline | null","event: LinkedObjectsEvent","sourceObjectKey: string","windowMs: number","limit: number","componentId: string","linkName: string"],"sources":["../../../src/utils/LinkTraversalTracker.ts"],"version":3,"file":"LinkTraversalTracker.d.ts"}

package/build/types/utils/MockDataGenerator.d.ts

@@ -0,0 +1,23 @@
+import type { SelectedPrimitive } from "../components/PrimitiveSelectionPanel.js";
+export declare class MockDataGenerator {
+	static generatePayload(primitive: SelectedPrimitive): string;
+	static generateStaticData(primitive: SelectedPrimitive): string;
+	static generateFunctionCode(primitive: SelectedPrimitive): string;
+	private static generateActionMockData;
+	private static generateObjectMockData;
+	private static generateObjectSetMockData;
+	private static generateLinksMockData;
+	private static generateQueryMockData;
+	private static generateActionFunctionCode;
+	private static generateObjectFunctionCode;
+	private static generateObjectSetFunctionCode;
+	private static generateLinksFunctionCode;
+	private static generateQueryFunctionCode;
+	private static generateFieldsForObjectType;
+	private static generateDynamicFieldsForObjectType;
+	private static extractObjectTypeFromAction;
+	private static inferLinkedTypeFromLinkName;
+	private static generateCreateParameters;
+	private static generateUpdateParameters;
+	private static generateDeleteParameters;
+}

package/build/types/utils/MockDataGenerator.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc,yBAAyB,0CAA2C;AASlF,OAAO,cAAM,kBAAkB;CAC7B,OAAO,gBAAgBA,WAAW;CA4ClC,OAAO,mBAAmBA,WAAW;CAiBrC,OAAO,qBAAqBA,WAAW;CAiBvC,eAAe;CAgCf,eAAe;CAef,eAAe;CA4Bf,eAAe;CAyBf,eAAe;CAuBf,eAAe;CAyCf,eAAe;CA0Bf,eAAe;CAkCf,eAAe;CAqCf,eAAe;CAgCf,eAAe;CAsCf,eAAe;CAsBf,eAAe;CAoBf,eAAe;CA6Bf,eAAe;CA2Bf,eAAe;CA0Bf,eAAe;AAQhB","names":["primitive: SelectedPrimitive"],"sources":["../../../src/utils/MockDataGenerator.ts"],"version":3,"file":"MockDataGenerator.d.ts"}

package/build/types/utils/ObservableClientMonitor.d.ts

@@ -0,0 +1,62 @@
+import type { CacheSnapshot, ObservableClient } from "@osdk/client/observable";
+import type { MockManager } from "../mocking/MockManager.js";
+import { MetricsStore } from "../store/MetricsStore.js";
+import type { ComponentQueryRegistry } from "./ComponentQueryRegistry.js";
+import type { EventTimeline } from "./EventTimeline.js";
+import type { LinkTraversalTracker } from "./LinkTraversalTracker.js";
+import type { PropertyAccessTracker } from "./PropertyAccessTracker.js";
+export interface ObservableClientMonitorConfig {
+	metricsStore?: MetricsStore;
+	componentRegistry: ComponentQueryRegistry;
+	linkTraversalTracker: LinkTraversalTracker;
+	propertyAccessTracker: PropertyAccessTracker;
+	eventTimeline?: EventTimeline;
+	captureComponentContext?: boolean;
+	captureQueryParams?: boolean;
+	cleanupIntervalMs?: number;
+	cacheThresholdMs?: number;
+	mockManager?: MockManager;
+}
+export declare class ObservableClientMonitor {
+	private readonly metricsStore;
+	private readonly subscriptionTracker;
+	private readonly signatureLastRecorded;
+	private readonly subscriptionHasLoaded;
+	private readonly DEDUP_WINDOW_MS;
+	private readonly actionTracker;
+	private readonly cleanupIntervalMs;
+	private cleanupIntervalId;
+	private componentRegistry;
+	private linkTraversalTracker;
+	private propertyAccessTracker;
+	private eventTimeline;
+	private captureComponentContext;
+	private captureQueryParams;
+	private mockManager;
+	private wrappedClient;
+	constructor(config: ObservableClientMonitorConfig);
+	wrapClient(client: ObservableClient): ObservableClient;
+	private recordMockHitIfNeeded;
+	private recordEmissionEvent;
+	private classifyCacheEvent;
+	private processEmission;
+	private cleanupSubscription;
+	private createCleanupUnsubscribable;
+	private setupObservation;
+	private createCleanupObserverCallbacks;
+	private wrapObserveObject;
+	private wrapObserveList;
+	private wrapObserveAggregation;
+	private wrapObserveLinks;
+	private wrapApplyAction;
+	private wrapValidateAction;
+	private captureActionError;
+	private injectMockedObjectsFromActionResult;
+	private extractObjectsFromMockResult;
+	getCacheSnapshot(): Promise<CacheSnapshot>;
+	invalidateObjects(objects: unknown): Promise<void>;
+	invalidateObjectType(objectType: string): Promise<void>;
+	invalidateAll(): Promise<void>;
+	private pruneSignatureLastRecorded;
+	dispose(): void;
+}

package/build/types/utils/ObservableClientMonitor.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAqBA,cACE,eACA,wBAIK,yBAA0B;AACjC,cAAc,mBAAmB,2BAA4B;AAC7D,SAAS,oBAAoB,0BAA2B;AASxD,cAEE,8BAEK,6BAA8B;AACrC,cAAc,qBAAqB,oBAAqB;AACxD,cAAc,4BAA4B,2BAA4B;AACtE,cAAc,6BAA6B,4BAA6B;AA6FxE,iBAAiB,8BAA8B;CAC7C,eAAe;CACf,mBAAmB;CACnB,sBAAsB;CACtB,uBAAuB;CACvB,gBAAgB;CAChB;CACA;CACA;CACA;CACA,cAAc;AACf;AAED,OAAO,cAAM,wBAAwB;CACnC,iBAAiB;CACjB,iBAAiB;CACjB,iBAAiB;CACjB,iBAAiB;CACjB,iBAAiB;CACjB,iBAAiB;CACjB,iBAAiB;CACjB,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CAER,YAAYA,QAAQ;CA2BpB,WAAWC,QAAQ,mBAAmB;CAgEtC,QAAQ;CAYR,QAAQ;CAeR,QAAQ;CAuBR,QAAQ;CAkFR,QAAQ;CAMR,QAAQ;CAeR,QAAQ;CAsCR,QAAQ;CA0BR,QAAQ;CAwGR,QAAQ;CAsIR,QAAQ;CA6GR,QAAQ;CAsFR,QAAQ;CAkMR,QAAQ;CAwBR,QAAQ;CAiBR,QAAQ;CA4BR,QAAQ;CA8CR,oBAAoB,QAAQ;CAa5B,kBAAkBC,mBAAmB;CAarC,qBAAqBC,qBAAqB;CAa1C,iBAAiB;CAajB,QAAQ;CASR;AAmBD","names":["config: ObservableClientMonitorConfig","client: ObservableClient","objects: unknown","objectType: string"],"sources":["../../../src/utils/ObservableClientMonitor.ts"],"version":3,"file":"ObservableClientMonitor.d.ts"}

package/build/types/utils/PerformanceRecommendationEngine.d.ts

@@ -0,0 +1,67 @@
+import type { CacheSnapshot } from "@osdk/client/observable";
+import type { MetricsStore } from "../store/MetricsStore.js";
+import type { ComponentQueryRegistry } from "./ComponentQueryRegistry.js";
+import type { EventTimeline } from "./EventTimeline.js";
+export type RecommendationLevel = "critical" | "high" | "medium" | "low" | "info";
+export type RecommendationCategory = "Performance" | "Bandwidth" | "Code Quality" | "Cache" | "Queries";
+export interface Recommendation {
+	id: string;
+	level: RecommendationLevel;
+	category: RecommendationCategory;
+	title: string;
+	description: string;
+	impact: string;
+	effort: "Low" | "Medium" | "High";
+	suggestion: string;
+	code?: string;
+	dismissible: boolean;
+}
+export interface PerformanceScore {
+	overall: number;
+	grade: "A" | "B" | "C" | "D" | "F";
+	categories: {
+		cache: number
+		queries: number
+		bandwidth: number
+		codeQuality: number
+	};
+	breakdown: {
+		waterfalls: {
+			penalty: number
+			count: number
+		}
+		fieldEfficiency: {
+			penalty: number
+			rate: number
+		}
+		cacheHitRate: {
+			penalty: number
+			rate: number
+		}
+		wastedBandwidth: {
+			penalty: number
+			bytes: number
+		}
+	};
+}
+export declare class PerformanceRecommendationEngine {
+	private metricsStore;
+	private registry;
+	private timeline;
+	private cacheAnalyzer;
+	private fieldAnalyzer;
+	private waterfallDetector;
+	private dismissedRecommendations;
+	constructor(metricsStore: MetricsStore, registry: ComponentQueryRegistry, timeline: EventTimeline);
+	generateRecommendations(cacheSnapshot: CacheSnapshot): Recommendation[];
+	calculatePerformanceScore(cacheSnapshot: CacheSnapshot): PerformanceScore;
+	private scoreToGrade;
+	dismissRecommendation(id: string): void;
+	clearDismissed(): void;
+	getSummary(cacheSnapshot: CacheSnapshot): {
+		issueCount: number
+		criticalCount: number
+		timeToFix: string
+		estimatedImprovement: string
+	};
+}

package/build/types/utils/PerformanceRecommendationEngine.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc,qBAAqB,yBAA0B;AAC7D,cAAc,oBAAoB,0BAA2B;AAE7D,cAAc,8BAA8B,6BAA8B;AAC1E,cAAc,qBAAqB,oBAAqB;AAIxD,YAAY,sBACR,aACA,SACA,WACA,QACA;AACJ,YAAY,yBACR,gBACA,cACA,iBACA,UACA;AAEJ,iBAAiB,eAAe;CAC9B;CACA,OAAO;CACP,UAAU;CACV;CACA;CACA;CACA,QAAQ,QAAQ,WAAW;CAC3B;CACA;CACA;AACD;AAED,iBAAiB,iBAAiB;CAChC;CACA,OAAO,MAAM,MAAM,MAAM,MAAM;CAC/B,YAAY;EACV;EACA;EACA;EACA;CACD;CACD,WAAW;EACT,YAAY;GAAE;GAAiB;EAAe;EAC9C,iBAAiB;GAAE;GAAiB;EAAc;EAClD,cAAc;GAAE;GAAiB;EAAc;EAC/C,iBAAiB;GAAE;GAAiB;EAAe;CACpD;AACF;AAED,OAAO,cAAM,gCAAgC;CAOzC;CACA;CACA;CARF,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CAER,YACUA,cAAc,cACdC,UAAU,wBACVC,UAAU;CAOpB,wBAAwBC,eAAe,gBAAgB;CAwFvD,0BAA0BA,eAAe,gBAAgB;CAuDzD,QAAQ;CAgBR,sBAAsBC;CAItB;CAIA,WAAWD,eAAe,gBAAgB;EACxC;EACA;EACA;EACA;CACD;AA8CF","names":["metricsStore: MetricsStore","registry: ComponentQueryRegistry","timeline: EventTimeline","cacheSnapshot: CacheSnapshot","id: string"],"sources":["../../../src/utils/PerformanceRecommendationEngine.ts"],"version":3,"file":"PerformanceRecommendationEngine.d.ts"}

package/build/types/utils/PropertyAccessTracker.d.ts

@@ -0,0 +1,50 @@
+import type { UnusedProperty, WastedRender } from "../types/index.js";
+import type { EventTimeline } from "./EventTimeline.js";
+export interface PropertyAccessEvent {
+	componentId: string;
+	objectKey: string;
+	property: string;
+	timestamp: number;
+	renderCycle?: number;
+}
+export declare class PropertyAccessTracker {
+	private accesses;
+	private componentRenderCycles;
+	private wrappedObjects;
+	private maxAccesses;
+	private maxProxyDepth;
+	private eventTimeline;
+	private componentNames;
+	private componentRenders;
+	private componentAccessesPerRender;
+	constructor();
+	wrapObject<T extends object>(obj: T, objectKey: string, componentId: string, depth?: number): T;
+	recordAccess(event: PropertyAccessEvent): void;
+	setEventTimeline(timeline: EventTimeline | null): void;
+	incrementRenderCycle(componentId: string): void;
+	registerComponent(componentId: string, componentName: string): void;
+	getAccessedProperties(componentId: string, objectKey: string): Set<string>;
+	getUnusedPropertiesForObject(componentId: string, objectKey: string, availableProperties: string[]): string[];
+	findWastedRenders(componentId: string): Array<{
+		objectKey: string
+		accessedProperties: Set<string>
+		renderCycles: Set<number>
+		wastedRenders: number
+	}>;
+	getRecentAccesses(limit?: number): PropertyAccessEvent[];
+	getAccessesByComponent(componentId: string): PropertyAccessEvent[];
+	getAccessesByObject(objectKey: string): PropertyAccessEvent[];
+	getAccessFrequency(componentId: string, objectKey: string): Map<string, number>;
+	clear(): void;
+	clearComponent(componentId: string): void;
+	getStats(): {
+		totalAccesses: number
+		uniqueComponents: number
+		uniqueObjects: number
+		uniqueProperties: number
+		mostAccessedProperties: Array<[string, number]>
+		trackedComponents: number
+	};
+	getWastedRenders(): WastedRender[];
+	getUnusedProperties(): UnusedProperty[];
+}

package/build/types/utils/PropertyAccessTracker.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc,gBAAgB,oBAAoB,mBAAoB;AAEtE,cAAc,qBAAqB,oBAAqB;AAExD,iBAAiB,oBAAoB;CACnC;CACA;CACA;CACA;CACA;AACD;AAED,OAAO,cAAM,sBAAsB;CACjC,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CAER;CAIA,WAAW,kBACTA,KAAK,GACLC,mBACAC,qBACAC,iBACC;CAoDH,aAAaC,OAAO;CAepB,iBAAiBC,UAAU;CAI3B,qBAAqBH;CAQrB,kBAAkBA,qBAAqBI;CAIvC,sBACEJ,qBACAD,oBACC;CAeH,6BACEC,qBACAD,mBACAM;CAMF,kBAAkBL,sBAAsB,MAAM;EAC5C;EACA,oBAAoB;EACpB,cAAc;EACd;CACD;CA4CD,kBAAkBM,iBAAsB;CAIxC,uBAAuBN,sBAAsB;CAI7C,oBAAoBD,oBAAoB;CAIxC,mBACEC,qBACAD,oBACC;CAkBH;CAKA,eAAeC;CAWf,YAAY;EACV;EACA;EACA;EACA;EACA,wBAAwB;EACxB;CACD;CAgCD,oBAAoB;CAmCpB,uBAAuB;AAqCxB","names":["obj: T","objectKey: string","componentId: string","depth: number","event: PropertyAccessEvent","timeline: EventTimeline | null","componentName: string","availableProperties: string[]","limit: number"],"sources":["../../../src/utils/PropertyAccessTracker.ts"],"version":3,"file":"PropertyAccessTracker.d.ts"}

package/build/types/utils/RecommendationMatcher.d.ts

@@ -0,0 +1,5 @@
+import type { Operation } from "../types/index.js";
+import type { Recommendation } from "./PerformanceRecommendationEngine.js";
+export type RecommendationMap = Map<string, Recommendation[]>;
+export declare function buildRecommendationMap(recommendations: Recommendation[]): RecommendationMap;
+export declare function getRecommendationsForOperation(operation: Operation, recommendationMap: RecommendationMap): Recommendation[];

package/build/types/utils/RecommendationMatcher.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc,iBAAiB,mBAAoB;AACnD,cAAc,sBAAsB,sCAAuC;AAE3E,YAAY,oBAAoB,YAAY;AAE5C,OAAO,iBAAS,uBACdA,iBAAiB,mBAChB;AAuCH,OAAO,iBAAS,+BACdC,WAAW,WACXC,mBAAmB,oBAClB","names":["recommendations: Recommendation[]","operation: Operation","recommendationMap: RecommendationMap"],"sources":["../../../src/utils/RecommendationMatcher.ts"],"version":3,"file":"RecommendationMatcher.d.ts"}

package/build/types/utils/SubscriptionTracker.d.ts

@@ -0,0 +1,17 @@
+import type { EmissionAnalysis, SubscriptionMetadata } from "../types/emissions.js";
+export declare class SubscriptionTracker {
+	private readonly cacheThresholdMs;
+	private subscriptions;
+	private signatureToSubscriptions;
+	private nextSubscriptionId;
+	constructor(cacheThresholdMs?: number);
+	startSubscription(signature: string): string;
+	recordEmission(subscriptionId: string, status: string, hasData: boolean, isOptimistic: boolean, optimisticId?: string | number, timestamp?: number): void;
+	private isValidStatus;
+	endSubscription(subscriptionId: string): void;
+	analyzeEmissions(subscriptionId: string): EmissionAnalysis | null;
+	getSharedSubscriptionCount(signature: string): number;
+	isDeduplicatedSubscription(signature: string): boolean;
+	getActiveSubscriptions(): SubscriptionMetadata[];
+	cleanup(maxAge?: number): void;
+}

package/build/types/utils/SubscriptionTracker.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cACE,kBAGA,4BACK,uBAAwB;AAE/B,OAAO,cAAM,oBAAoB;CAM7B;CALF,QAAQ;CACR,QAAQ;CACR,QAAQ;CAER,YACmBA;CAGnB,kBAAkBC;CAsBlB,eACEC,wBACAC,gBACAC,kBACAC,uBACAC,gCACAC;CAqBF,QAAQ;CASR,gBAAgBL;CAehB,iBAAiBA,yBAAyB;CAwD1C,2BAA2BD;CAI3B,2BAA2BA;CAI3B,0BAA0B;CAK1B,QAAQO;AAeT","names":["cacheThresholdMs: number","signature: string","subscriptionId: string","status: string","hasData: boolean","isOptimistic: boolean","optimisticId?: string | number","timestamp: number","maxAge: number"],"sources":["../../../src/utils/SubscriptionTracker.ts"],"version":3,"file":"SubscriptionTracker.d.ts"}

package/build/types/utils/UnusedFieldAnalyzer.d.ts

@@ -0,0 +1,46 @@
+import type { CacheSnapshot } from "@osdk/client/observable";
+import type { ComponentHookBinding, ComponentQueryRegistry } from "./ComponentQueryRegistry.js";
+import type { PropertyAccessTracker } from "./PropertyAccessTracker.js";
+export interface PropertyAccessTrackerWithAnalysis extends PropertyAccessTracker {
+	getAccessedProperties(componentId: string, querySignature: string): Set<string>;
+}
+export interface FieldUsageReport {
+	componentName: string;
+	querySignature: string;
+	fetched: string[];
+	accessed: string[];
+	unused: string[];
+	efficiency: number;
+	wastedBytes: number;
+	renderCount: number;
+	suggestion: string;
+}
+export interface CommonUnusedField {
+	field: string;
+	objectType?: string;
+	unusedCount: number;
+	totalQueries: number;
+	unusedRate: number;
+}
+export interface UnusedFieldReport {
+	totalComponents: number;
+	inefficientComponents: number;
+	totalWastedBytes: number;
+	topOffenders: FieldUsageReport[];
+	commonUnused: CommonUnusedField[];
+	averageEfficiency: number;
+	recommendation: string;
+}
+export declare class UnusedFieldAnalyzer {
+	private registry;
+	private propertyTracker;
+	private estimateCacheEntrySize;
+	constructor(registry: ComponentQueryRegistry, propertyTracker: PropertyAccessTrackerWithAnalysis | undefined, estimateCacheEntrySize?: (data: unknown) => number);
+	analyzeBinding(binding: ComponentHookBinding, cacheSnapshot: CacheSnapshot): FieldUsageReport;
+	generateGlobalReport(cacheSnapshot: CacheSnapshot): UnusedFieldReport;
+	private getAccessedProperties;
+	private findCommonUnusedFields;
+	private generateSuggestion;
+	private generateGlobalRecommendation;
+	private static defaultSizeEstimator;
+}

package/build/types/utils/UnusedFieldAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc,qBAAqB,yBAA0B;AAC7D,cACE,sBACA,8BACK,6BAA8B;AACrC,cAAc,6BAA6B,4BAA6B;AAExE,iBAAiB,0CACP,sBACV;CACE,sBACEA,qBACAC,yBACC;AACJ;AAED,iBAAiB,iBAAiB;CAChC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACD;AAED,iBAAiB,kBAAkB;CACjC;CACA;CACA;CACA;CACA;AACD;AAED,iBAAiB,kBAAkB;CACjC;CACA;CACA;CACA,cAAc;CACd,cAAc;CACd;CACA;AACD;AAID,OAAO,cAAM,oBAAoB;CAE7B;CACA;CACA;CAHF,YACUC,UAAU,wBACVC,iBAAiB,+CACjBC,0BAAyBC;CAInC,eACEC,SAAS,sBACTC,eAAe,gBACd;CA2CH,qBAAqBA,eAAe,gBAAgB;CAoCpD,QAAQ;CAaR,QAAQ;CAkCR,QAAQ;CA8CR,QAAQ;CAuCR,eAAe;AAmBhB","names":["componentId: string","querySignature: string","registry: ComponentQueryRegistry","propertyTracker: PropertyAccessTrackerWithAnalysis | undefined","estimateCacheEntrySize: (data: unknown) => number","data: unknown","binding: ComponentHookBinding","cacheSnapshot: CacheSnapshot"],"sources":["../../../src/utils/UnusedFieldAnalyzer.ts"],"version":3,"file":"UnusedFieldAnalyzer.d.ts"}

package/build/types/utils/WaterfallDetector.d.ts

@@ -0,0 +1,28 @@
+import type { ComponentQueryRegistry } from "./ComponentQueryRegistry.js";
+import type { EventTimeline } from "./EventTimeline.js";
+export type WaterfallType = "LINK_WATERFALL" | "MAP_WATERFALL" | "SEQUENTIAL_WATERFALL";
+export interface Waterfall {
+	type: WaterfallType;
+	priority: "high" | "medium" | "low";
+	timeSaved: number;
+	suggestion: string;
+	code: string;
+	details: {
+		parentQuery?: string
+		childQuery?: string
+		component?: string
+		count?: number
+		objectType?: string
+	};
+}
+export declare class WaterfallDetector {
+	private registry;
+	private timeline;
+	constructor(registry: ComponentQueryRegistry, timeline: EventTimeline);
+	detectWaterfalls(timingThresholdMs?: number): Waterfall[];
+	private detectLinkWaterfalls;
+	private detectMapWaterfalls;
+	private detectSequentialPatterns;
+	private generateLinkWaterfallCode;
+	private generateMapWaterfallCode;
+}

package/build/types/utils/WaterfallDetector.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAEE,8BACK,6BAA8B;AACrC,cAAc,qBAAqB,oBAAqB;AAExD,YAAY,gBACR,mBACA,kBACA;AAEJ,iBAAiB,UAAU;CACzB,MAAM;CACN,UAAU,SAAS,WAAW;CAC9B;CACA;CACA;CACA,SAAS;EACP;EACA;EACA;EACA;EACA;CACD;AACF;AAED,OAAO,cAAM,kBAAkB;CAE3B;CACA;CAFF,YACUA,UAAU,wBACVC,UAAU;CAGpB,iBAAiBC,6BAAiC;CAUlD,QAAQ;CA2CR,QAAQ;CAgDR,QAAQ;CAqCR,QAAQ;CAkCR,QAAQ;AA8CT","names":["registry: ComponentQueryRegistry","timeline: EventTimeline","timingThresholdMs: number"],"sources":["../../../src/utils/WaterfallDetector.ts"],"version":3,"file":"WaterfallDetector.d.ts"}

package/build/types/utils/computePayload.d.ts

@@ -0,0 +1,3 @@
+export declare function stringifyPayload(payload: unknown): string;
+export declare function truncatePayload(payload: string): string;
+export declare function hashPayload(payload: unknown): number;

package/build/types/utils/computePayload.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAkBA,OAAO,iBAAS,iBAAiBA;AAIjC,OAAO,iBAAS,gBAAgBC;AAOhC,OAAO,iBAAS,YAAYD","names":["payload: unknown","payload: string"],"sources":["../../../src/utils/computePayload.ts"],"version":3,"file":"computePayload.d.ts"}

package/build/types/utils/computeRequest.d.ts

@@ -0,0 +1,20 @@
+import type { ComputeRequest } from "../types/compute.js";
+type FulfilledComputeRequest = Extract<ComputeRequest, {
+	type: "fulfilled"
+}>;
+type FulfilledWithoutUsageComputeRequest = Extract<ComputeRequest, {
+	type: "fulfilled-without-usage"
+}>;
+type PendingComputeRequest = Extract<ComputeRequest, {
+	type: "pending"
+}>;
+type FailedComputeRequest = Extract<ComputeRequest, {
+	type: "failed"
+}>;
+export declare const visitComputeRequest: <T>(request: ComputeRequest, visitor: {
+	pending: (request: PendingComputeRequest) => T
+	failed: (request: FailedComputeRequest) => T
+	fulfilled: (request: FulfilledComputeRequest) => T
+	fulfilledWithoutUsage: (request: FulfilledWithoutUsageComputeRequest) => T
+}) => T;
+export {};

package/build/types/utils/computeRequest.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc,sBAAsB,qBAAsB;KAErD,0BAA0B,QAC7B,gBACA;CAAE,MAAM;AAAa;KAElB,sCAAsC,QACzC,gBACA;CAAE,MAAM;AAA2B;KAEhC,wBAAwB,QAC3B,gBACA;CAAE,MAAM;AAAW;KAEhB,uBAAuB,QAAQ,gBAAgB;CAAE,MAAM;AAAU;AAEtE,OAAO,cAAM,sBAAuB,GAClCA,SAAS,gBACTC,SAAS;CACP,UAAUC,SAAS,0BAA0B;CAC7C,SAASC,SAAS,yBAAyB;CAC3C,YAAYC,SAAS,4BAA4B;CACjD,wBAAwBC,SAAS,wCAAwC;AAC1E,MACA","names":["request: ComputeRequest","visitor: {\n    pending: (request: PendingComputeRequest) => T;\n    failed: (request: FailedComputeRequest) => T;\n    fulfilled: (request: FulfilledComputeRequest) => T;\n    fulfilledWithoutUsage: (request: FulfilledWithoutUsageComputeRequest) => T;\n  }","request: PendingComputeRequest","request: FailedComputeRequest","request: FulfilledComputeRequest","request: FulfilledWithoutUsageComputeRequest"],"sources":["../../../src/utils/computeRequest.ts"],"version":3,"file":"computeRequest.d.ts"}

package/build/types/utils/format.d.ts

@@ -0,0 +1,5 @@
+export declare function formatTime(ms: number): string;
+export declare function formatNumber(num: number): string;
+export declare function formatBytes(bytes: number): string;
+export declare function formatRelativeTime(timestamp: number): string;
+export declare const formatMilliseconds: (value: number, includeSpace: boolean) => string;

package/build/types/utils/format.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,OAAO,iBAAS,WAAWA;AAU3B,OAAO,iBAAS,aAAaC;AAU7B,OAAO,iBAAS,YAAYC;AAU5B,OAAO,iBAAS,mBAAmBC;AAcnC,OAAO,cAAM,qBACXC,eACAC","names":["ms: number","num: number","bytes: number","timestamp: number","value: number","includeSpace: boolean"],"sources":["../../../src/utils/format.ts"],"version":3,"file":"format.d.ts"}

package/build/types/utils/logger.d.ts

@@ -0,0 +1,2 @@
+import type { Logger } from "@osdk/api";
+export declare function createMonitorLogger(_prefix?: string): Logger;

package/build/types/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc,cAAc,WAAY;AAexC,OAAO,iBAAS,oBAAoBA,mBAAmB","names":["_prefix?: string"],"sources":["../../../src/utils/logger.ts"],"version":3,"file":"logger.d.ts"}

package/build/types/vite/constants.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_NAME = "osdk-devtools";

package/build/types/vite/constants.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,OAAO,cAAM,cAAc","names":[],"sources":["../../../src/vite/constants.ts"],"version":3,"file":"constants.d.ts"}

package/build/types/vite/hookInstaller.d.ts

@@ -0,0 +1 @@
+export declare function generateHookInstallationScript(verbose?: boolean): string;

package/build/types/vite/hookInstaller.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,OAAO,iBAAS,+BACdA","names":["verbose: boolean"],"sources":["../../../src/vite/hookInstaller.ts"],"version":3,"file":"hookInstaller.d.ts"}

package/build/types/vite/index.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from "vite";
+export interface OsdkDevToolsOptions {
+	/**
+	* Enable devtools.
+	* Default: true in development, false in production
+	*/
+	enabled?: boolean;
+	/**
+	* Enable verbose logging for debugging.
+	* Default: false
+	*/
+	verbose?: boolean;
+	/**
+	* Automatically inject CSS.
+	* Default: true
+	*/
+	injectCSS?: boolean;
+}
+export declare function osdkDevTools(options?: OsdkDevToolsOptions): Plugin;
+export default osdkDevTools;

package/build/types/vite/index.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAkBA,cAAc,cAAc,MAAO;AAOnC,iBAAiB,oBAAoB;;;;;CAKnC;;;;;CAMA;;;;;CAMA;AACD;AAED,OAAO,iBAAS,aAAaA,UAAS,sBAA2B;AAsEjE,eAAe","names":["options: OsdkDevToolsOptions"],"sources":["../../../src/vite/index.ts"],"version":3,"file":"index.d.ts"}