@clipin/convex-wearables 0.0.3 → 0.1.1

package/dist/component/timeSeriesPolicyUtils.d.ts

@@ -0,0 +1,97 @@
+import type { Doc } from "./_generated/dataModel";
+export declare const DEFAULT_POLICY_SET_KEY = "__default__";
+export declare const DEFAULT_MAINTENANCE_INTERVAL_MS: number;
+export declare const DEFAULT_TIME_SERIES_AGGREGATIONS: readonly ["avg", "min", "max", "last", "count"];
+export type DurationInput = string | number;
+export type TimeSeriesAggregation = Doc<"timeSeriesPolicyRules">["tiers"][number] extends infer Tier ? Tier extends {
+    aggregations: infer Aggregations;
+} ? Aggregations extends Array<infer Aggregation> ? Aggregation : never : never : never;
+export type TimeSeriesTierInput = {
+    kind: "raw";
+    fromAge: DurationInput;
+    toAge: DurationInput | null;
+} | {
+    kind: "rollup";
+    fromAge: DurationInput;
+    toAge: DurationInput | null;
+    bucket: DurationInput;
+    aggregations?: TimeSeriesAggregation[];
+};
+export type NormalizedTimeSeriesTier = Doc<"timeSeriesPolicyRules">["tiers"][number];
+export type TimeSeriesPolicyRuleInput = {
+    provider?: Doc<"timeSeriesPolicyRules">["provider"];
+    seriesType?: string;
+    tiers: TimeSeriesTierInput[];
+};
+export declare function parseDurationInput(input: DurationInput, label: string): number;
+export declare function createTimeSeriesPolicyScopeKey(provider?: string, seriesType?: string): string;
+export declare function inferTimeSeriesPolicyScope(provider?: string, seriesType?: string): "provider" | "provider_series" | "series" | "global";
+export declare function normalizeAggregations(aggregations?: readonly TimeSeriesAggregation[]): TimeSeriesAggregation[];
+export declare function normalizeTimeSeriesTierInputs(tiers: TimeSeriesTierInput[]): ({
+    kind: "raw";
+    fromAgeMs: number;
+    toAgeMs: number | null;
+    bucketMs?: undefined;
+    aggregations?: undefined;
+} | {
+    kind: "rollup";
+    fromAgeMs: number;
+    toAgeMs: number | null;
+    bucketMs: number;
+    aggregations: ("avg" | "min" | "max" | "last" | "count")[];
+})[];
+export declare function normalizeTimeSeriesPolicyRuleInputs(rules: TimeSeriesPolicyRuleInput[]): {
+    provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google" | undefined;
+    seriesType: string | undefined;
+    tiers: ({
+        kind: "raw";
+        fromAgeMs: number;
+        toAgeMs: number | null;
+        bucketMs?: undefined;
+        aggregations?: undefined;
+    } | {
+        kind: "rollup";
+        fromAgeMs: number;
+        toAgeMs: number | null;
+        bucketMs: number;
+        aggregations: ("avg" | "min" | "max" | "last" | "count")[];
+    })[];
+}[];
+export declare function findTierForAge(tiers: NormalizedTimeSeriesTier[], ageMs: number): {
+    kind: "raw";
+    fromAgeMs: number;
+    toAgeMs: number | null;
+} | {
+    kind: "rollup";
+    bucketMs: number;
+    fromAgeMs: number;
+    toAgeMs: number | null;
+    aggregations: ("avg" | "min" | "max" | "last" | "count")[];
+} | null;
+export declare function getRawTier(tiers: NormalizedTimeSeriesTier[]): {
+    kind: "raw";
+    fromAgeMs: number;
+    toAgeMs: number | null;
+} | null;
+export declare function getRollupTiers(tiers: NormalizedTimeSeriesTier[]): {
+    kind: "rollup";
+    bucketMs: number;
+    fromAgeMs: number;
+    toAgeMs: number | null;
+    aggregations: ("avg" | "min" | "max" | "last" | "count")[];
+}[];
+export declare function buildBuiltinFullTiers(): NormalizedTimeSeriesTier[];
+export declare function resolveScopedPolicyRule<Rule extends {
+    provider?: string;
+    seriesType?: string;
+}>(rules: Rule[], provider: string, seriesType: string): Rule | null;
+export declare function comparePolicyScopes(a: {
+    provider?: string;
+    seriesType?: string;
+}, b: {
+    provider?: string;
+    seriesType?: string;
+}): number;
+export declare function getBucketStart(recordedAt: number, bucketMs: number): number;
+export declare function getBucketEnd(bucketStart: number, bucketMs: number): number;
+//# sourceMappingURL=timeSeriesPolicyUtils.d.ts.map

package/dist/component/timeSeriesPolicyUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeSeriesPolicyUtils.d.ts","sourceRoot":"","sources":["../../src/component/timeSeriesPolicyUtils.ts"],"names":[],"mappings":"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"}

package/dist/component/timeSeriesPolicyUtils.js

@@ -0,0 +1,163 @@
+export const DEFAULT_POLICY_SET_KEY = "__default__";
+export const DEFAULT_MAINTENANCE_INTERVAL_MS = 60 * 60 * 1000;
+export const DEFAULT_TIME_SERIES_AGGREGATIONS = ["avg", "min", "max", "last", "count"];
+const DURATION_UNITS = {
+    ms: 1,
+    s: 1000,
+    m: 60 * 1000,
+    h: 60 * 60 * 1000,
+    d: 24 * 60 * 60 * 1000,
+    w: 7 * 24 * 60 * 60 * 1000,
+};
+export function parseDurationInput(input, label) {
+    if (typeof input === "number") {
+        if (!Number.isFinite(input) || input < 0) {
+            throw new Error(`${label} must be a non-negative duration`);
+        }
+        return Math.floor(input);
+    }
+    const trimmed = input.trim().toLowerCase();
+    const match = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)$/.exec(trimmed);
+    if (!match) {
+        throw new Error(`${label} must be a duration like "30m", "24h", "7d", or a numeric millisecond value`);
+    }
+    const value = Number(match[1]);
+    const unit = match[2];
+    return Math.floor(value * DURATION_UNITS[unit]);
+}
+export function createTimeSeriesPolicyScopeKey(provider, seriesType) {
+    return `${provider ?? "*"}::${seriesType ?? "*"}`;
+}
+export function inferTimeSeriesPolicyScope(provider, seriesType) {
+    if (provider && seriesType) {
+        return "provider_series";
+    }
+    if (seriesType) {
+        return "series";
+    }
+    if (provider) {
+        return "provider";
+    }
+    return "global";
+}
+export function normalizeAggregations(aggregations) {
+    const unique = new Set(aggregations ?? DEFAULT_TIME_SERIES_AGGREGATIONS);
+    if (unique.size === 0) {
+        throw new Error("Rollup tiers must include at least one aggregation");
+    }
+    return Array.from(unique);
+}
+export function normalizeTimeSeriesTierInputs(tiers) {
+    if (tiers.length === 0) {
+        throw new Error("A time-series policy rule must include at least one tier");
+    }
+    let rawTierCount = 0;
+    const normalized = tiers.map((tier, index) => {
+        const fromAgeMs = parseDurationInput(tier.fromAge, `tiers[${index}].fromAge`);
+        const toAgeMs = tier.toAge === null ? null : parseDurationInput(tier.toAge, `tiers[${index}].toAge`);
+        if (toAgeMs !== null && toAgeMs <= fromAgeMs) {
+            throw new Error(`tiers[${index}] must have toAge greater than fromAge`);
+        }
+        if (tier.kind === "raw") {
+            rawTierCount += 1;
+            return {
+                kind: "raw",
+                fromAgeMs,
+                toAgeMs,
+            };
+        }
+        const bucketMs = parseDurationInput(tier.bucket, `tiers[${index}].bucket`);
+        if (bucketMs <= 0 || bucketMs % (60 * 1000) !== 0) {
+            throw new Error(`tiers[${index}].bucket must be a positive whole-minute duration`);
+        }
+        return {
+            kind: "rollup",
+            fromAgeMs,
+            toAgeMs,
+            bucketMs,
+            aggregations: normalizeAggregations(tier.aggregations),
+        };
+    });
+    if (normalized[0].fromAgeMs !== 0) {
+        throw new Error("The first tier must start at age 0");
+    }
+    if (rawTierCount > 1) {
+        throw new Error("Only one raw tier is supported in a single policy rule");
+    }
+    for (let index = 0; index < normalized.length - 1; index += 1) {
+        const current = normalized[index];
+        const next = normalized[index + 1];
+        if (current.toAgeMs === null) {
+            throw new Error("Open-ended tiers must be the final tier");
+        }
+        if (next.fromAgeMs !== current.toAgeMs) {
+            throw new Error("Policy tiers must be contiguous without gaps or overlap");
+        }
+    }
+    return normalized;
+}
+export function normalizeTimeSeriesPolicyRuleInputs(rules) {
+    const seenScopes = new Set();
+    return rules.map((rule, index) => {
+        const scopeKey = createTimeSeriesPolicyScopeKey(rule.provider, rule.seriesType);
+        if (seenScopes.has(scopeKey)) {
+            throw new Error(`Duplicate time-series policy rule scope "${scopeKey}" at index ${index}`);
+        }
+        seenScopes.add(scopeKey);
+        return {
+            provider: rule.provider,
+            seriesType: rule.seriesType,
+            tiers: normalizeTimeSeriesTierInputs(rule.tiers),
+        };
+    });
+}
+export function findTierForAge(tiers, ageMs) {
+    return (tiers.find((tier) => ageMs >= tier.fromAgeMs && (tier.toAgeMs === null || ageMs < tier.toAgeMs)) ?? null);
+}
+export function getRawTier(tiers) {
+    return tiers.find((tier) => tier.kind === "raw") ?? null;
+}
+export function getRollupTiers(tiers) {
+    return tiers.filter((tier) => tier.kind === "rollup");
+}
+export function buildBuiltinFullTiers() {
+    return [
+        {
+            kind: "raw",
+            fromAgeMs: 0,
+            toAgeMs: null,
+        },
+    ];
+}
+export function resolveScopedPolicyRule(rules, provider, seriesType) {
+    return (rules.find((rule) => rule.provider === provider && rule.seriesType === seriesType) ??
+        rules.find((rule) => rule.provider === undefined && rule.seriesType === seriesType) ??
+        rules.find((rule) => rule.provider === provider && rule.seriesType === undefined) ??
+        rules.find((rule) => rule.provider === undefined && rule.seriesType === undefined) ??
+        null);
+}
+export function comparePolicyScopes(a, b) {
+    const weight = (item) => {
+        const scope = inferTimeSeriesPolicyScope(item.provider, item.seriesType);
+        switch (scope) {
+            case "global":
+                return 0;
+            case "provider":
+                return 1;
+            case "series":
+                return 2;
+            case "provider_series":
+                return 3;
+        }
+    };
+    return (weight(a) - weight(b) ||
+        (a.provider ?? "").localeCompare(b.provider ?? "") ||
+        (a.seriesType ?? "").localeCompare(b.seriesType ?? ""));
+}
+export function getBucketStart(recordedAt, bucketMs) {
+    return Math.floor(recordedAt / bucketMs) * bucketMs;
+}
+export function getBucketEnd(bucketStart, bucketMs) {
+    return bucketStart + bucketMs - 1;
+}
+//# sourceMappingURL=timeSeriesPolicyUtils.js.map

package/dist/component/timeSeriesPolicyUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeSeriesPolicyUtils.js","sourceRoot":"","sources":["../../src/component/timeSeriesPolicyUtils.ts"],"names":[],"mappings":"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"}

package/dist/test.d.ts

@@ -76,6 +76,38 @@ declare const _default: {
             by_source_type_time: ["dataSourceId", "seriesType", "recordedAt", "_creationTime"];
             by_type_time: ["seriesType", "recordedAt", "_creationTime"];
         }, {}, {}>;
+        timeSeriesRollups: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            avg: number;
+            min: number;
+            max: number;
+            last: number;
+            count: number;
+            dataSourceId: import("convex/values").GenericId<"dataSources">;
+            seriesType: string;
+            bucketMs: number;
+            bucketStart: number;
+            bucketEnd: number;
+            lastRecordedAt: number;
+            updatedAt: number;
+        }, {
+            dataSourceId: import("convex/values").VId<import("convex/values").GenericId<"dataSources">, "required">;
+            seriesType: import("convex/values").VString<string, "required">;
+            bucketMs: import("convex/values").VFloat64<number, "required">;
+            bucketStart: import("convex/values").VFloat64<number, "required">;
+            bucketEnd: import("convex/values").VFloat64<number, "required">;
+            avg: import("convex/values").VFloat64<number, "required">;
+            min: import("convex/values").VFloat64<number, "required">;
+            max: import("convex/values").VFloat64<number, "required">;
+            last: import("convex/values").VFloat64<number, "required">;
+            lastRecordedAt: import("convex/values").VFloat64<number, "required">;
+            count: import("convex/values").VFloat64<number, "required">;
+            updatedAt: import("convex/values").VFloat64<number, "required">;
+        }, "required", "avg" | "min" | "max" | "last" | "count" | "dataSourceId" | "seriesType" | "bucketMs" | "bucketStart" | "bucketEnd" | "lastRecordedAt" | "updatedAt">, {
+            by_source_type_bucket: ["dataSourceId", "seriesType", "bucketStart", "_creationTime"];
+            by_source_type_bucket_size: ["dataSourceId", "seriesType", "bucketMs", "bucketStart", "_creationTime"];
+            by_source_bucket: ["dataSourceId", "bucketStart", "_creationTime"];
+            by_type_bucket: ["seriesType", "bucketStart", "_creationTime"];
+        }, {}, {}>;
         events: import("convex/server").TableDefinition<import("convex/values").VObject<{
             type?: string | undefined;
             externalId?: string | undefined;
@@ -297,10 +329,10 @@ declare const _default: {
             by_state: ["state", "_creationTime"];
         }, {}, {}>;
         providerSettings: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            updatedAt?: number | undefined;
             clientId?: string | undefined;
             clientSecret?: string | undefined;
             subscriptionKey?: string | undefined;
-            updatedAt?: number | undefined;
             provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
             isEnabled: boolean;
         }, {
@@ -310,9 +342,137 @@ declare const _default: {
             clientSecret: import("convex/values").VString<string | undefined, "optional">;
             subscriptionKey: import("convex/values").VString<string | undefined, "optional">;
             updatedAt: import("convex/values").VFloat64<number | undefined, "optional">;
-        }, "required", "provider" | "isEnabled" | "clientId" | "clientSecret" | "subscriptionKey" | "updatedAt">, {
+        }, "required", "provider" | "updatedAt" | "isEnabled" | "clientId" | "clientSecret" | "subscriptionKey">, {
             by_provider: ["provider", "_creationTime"];
         }, {}, {}>;
+        timeSeriesPolicyRules: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            provider?: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google" | undefined;
+            seriesType?: string | undefined;
+            updatedAt: number;
+            policySetKind: "default" | "preset";
+            policySetKey: string;
+            scopeKey: string;
+            tiers: ({
+                kind: "raw";
+                fromAgeMs: number;
+                toAgeMs: number | null;
+            } | {
+                kind: "rollup";
+                bucketMs: number;
+                fromAgeMs: number;
+                toAgeMs: number | null;
+                aggregations: ("avg" | "min" | "max" | "last" | "count")[];
+            })[];
+        }, {
+            policySetKind: import("convex/values").VUnion<"default" | "preset", [import("convex/values").VLiteral<"default", "required">, import("convex/values").VLiteral<"preset", "required">], "required", never>;
+            policySetKey: import("convex/values").VString<string, "required">;
+            scopeKey: import("convex/values").VString<string, "required">;
+            provider: import("convex/values").VUnion<"garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google" | undefined, [import("convex/values").VLiteral<"garmin", "required">, import("convex/values").VLiteral<"suunto", "required">, import("convex/values").VLiteral<"polar", "required">, import("convex/values").VLiteral<"whoop", "required">, import("convex/values").VLiteral<"strava", "required">, import("convex/values").VLiteral<"apple", "required">, import("convex/values").VLiteral<"samsung", "required">, import("convex/values").VLiteral<"google", "required">], "optional", never>;
+            seriesType: import("convex/values").VString<string | undefined, "optional">;
+            tiers: import("convex/values").VArray<({
+                kind: "raw";
+                fromAgeMs: number;
+                toAgeMs: number | null;
+            } | {
+                kind: "rollup";
+                bucketMs: number;
+                fromAgeMs: number;
+                toAgeMs: number | null;
+                aggregations: ("avg" | "min" | "max" | "last" | "count")[];
+            })[], import("convex/values").VUnion<{
+                kind: "raw";
+                fromAgeMs: number;
+                toAgeMs: number | null;
+            } | {
+                kind: "rollup";
+                bucketMs: number;
+                fromAgeMs: number;
+                toAgeMs: number | null;
+                aggregations: ("avg" | "min" | "max" | "last" | "count")[];
+            }, [import("convex/values").VObject<{
+                kind: "raw";
+                fromAgeMs: number;
+                toAgeMs: number | null;
+            }, {
+                kind: import("convex/values").VLiteral<"raw", "required">;
+                fromAgeMs: import("convex/values").VFloat64<number, "required">;
+                toAgeMs: import("convex/values").VUnion<number | null, [import("convex/values").VFloat64<number, "required">, import("convex/values").VNull<null, "required">], "required", never>;
+            }, "required", "kind" | "fromAgeMs" | "toAgeMs">, import("convex/values").VObject<{
+                kind: "rollup";
+                bucketMs: number;
+                fromAgeMs: number;
+                toAgeMs: number | null;
+                aggregations: ("avg" | "min" | "max" | "last" | "count")[];
+            }, {
+                kind: import("convex/values").VLiteral<"rollup", "required">;
+                fromAgeMs: import("convex/values").VFloat64<number, "required">;
+                toAgeMs: import("convex/values").VUnion<number | null, [import("convex/values").VFloat64<number, "required">, import("convex/values").VNull<null, "required">], "required", never>;
+                bucketMs: import("convex/values").VFloat64<number, "required">;
+                aggregations: import("convex/values").VArray<("avg" | "min" | "max" | "last" | "count")[], import("convex/values").VUnion<"avg" | "min" | "max" | "last" | "count", [import("convex/values").VLiteral<"avg", "required">, import("convex/values").VLiteral<"min", "required">, import("convex/values").VLiteral<"max", "required">, import("convex/values").VLiteral<"last", "required">, import("convex/values").VLiteral<"count", "required">], "required", never>, "required">;
+            }, "required", "kind" | "bucketMs" | "fromAgeMs" | "toAgeMs" | "aggregations">], "required", "kind" | "bucketMs" | "fromAgeMs" | "toAgeMs" | "aggregations">, "required">;
+            updatedAt: import("convex/values").VFloat64<number, "required">;
+        }, "required", "provider" | "seriesType" | "updatedAt" | "policySetKind" | "policySetKey" | "scopeKey" | "tiers">, {
+            by_set: ["policySetKind", "policySetKey", "_creationTime"];
+            by_set_scope: ["policySetKind", "policySetKey", "provider", "seriesType", "_creationTime"];
+        }, {}, {}>;
+        timeSeriesPolicyAssignments: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            userId: string;
+            updatedAt: number;
+            presetKey: string;
+        }, {
+            userId: import("convex/values").VString<string, "required">;
+            presetKey: import("convex/values").VString<string, "required">;
+            updatedAt: import("convex/values").VFloat64<number, "required">;
+        }, "required", "userId" | "updatedAt" | "presetKey">, {
+            by_user: ["userId", "_creationTime"];
+            by_preset: ["presetKey", "_creationTime"];
+        }, {}, {}>;
+        timeSeriesPolicySettings: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            scheduledAt?: number | undefined;
+            lastRunAt?: number | undefined;
+            lastError?: string | undefined;
+            updatedAt: number;
+            key: string;
+            maintenanceEnabled: boolean;
+            maintenanceIntervalMs: number;
+        }, {
+            key: import("convex/values").VString<string, "required">;
+            maintenanceEnabled: import("convex/values").VBoolean<boolean, "required">;
+            maintenanceIntervalMs: import("convex/values").VFloat64<number, "required">;
+            scheduledAt: import("convex/values").VFloat64<number | undefined, "optional">;
+            lastRunAt: import("convex/values").VFloat64<number | undefined, "optional">;
+            lastError: import("convex/values").VString<string | undefined, "optional">;
+            updatedAt: import("convex/values").VFloat64<number, "required">;
+        }, "required", "updatedAt" | "key" | "maintenanceEnabled" | "maintenanceIntervalMs" | "scheduledAt" | "lastRunAt" | "lastError">, {
+            by_key: ["key", "_creationTime"];
+        }, {}, {}>;
+        timeSeriesSeriesState: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            connectionId?: import("convex/values").GenericId<"connections"> | undefined;
+            lastMaintenanceAt?: number | undefined;
+            provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
+            userId: string;
+            dataSourceId: import("convex/values").GenericId<"dataSources">;
+            seriesType: string;
+            updatedAt: number;
+            latestRecordedAt: number;
+            lastIngestedAt: number;
+            nextMaintenanceAt: number;
+        }, {
+            dataSourceId: import("convex/values").VId<import("convex/values").GenericId<"dataSources">, "required">;
+            connectionId: import("convex/values").VId<import("convex/values").GenericId<"connections"> | undefined, "optional">;
+            userId: import("convex/values").VString<string, "required">;
+            provider: import("convex/values").VUnion<"garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google", [import("convex/values").VLiteral<"garmin", "required">, import("convex/values").VLiteral<"suunto", "required">, import("convex/values").VLiteral<"polar", "required">, import("convex/values").VLiteral<"whoop", "required">, import("convex/values").VLiteral<"strava", "required">, import("convex/values").VLiteral<"apple", "required">, import("convex/values").VLiteral<"samsung", "required">, import("convex/values").VLiteral<"google", "required">], "required", never>;
+            seriesType: import("convex/values").VString<string, "required">;
+            latestRecordedAt: import("convex/values").VFloat64<number, "required">;
+            lastIngestedAt: import("convex/values").VFloat64<number, "required">;
+            nextMaintenanceAt: import("convex/values").VFloat64<number, "required">;
+            lastMaintenanceAt: import("convex/values").VFloat64<number | undefined, "optional">;
+            updatedAt: import("convex/values").VFloat64<number, "required">;
+        }, "required", "provider" | "userId" | "connectionId" | "dataSourceId" | "seriesType" | "updatedAt" | "latestRecordedAt" | "lastIngestedAt" | "nextMaintenanceAt" | "lastMaintenanceAt">, {
+            by_source_series: ["dataSourceId", "seriesType", "_creationTime"];
+            by_next_maintenance: ["nextMaintenanceAt", "_creationTime"];
+            by_user: ["userId", "_creationTime"];
+        }, {}, {}>;
         providerPriorities: import("convex/server").TableDefinition<import("convex/values").VObject<{
             provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
             priority: number;

package/dist/test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../src/test.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK9C;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,UAAU,CAAC,gBAAgB,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,EACvD,IAAI,GAAE,MAAoB,QAK3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,wBAA6C"}
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../src/test.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK9C;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,UAAU,CAAC,gBAAgB,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,EACvD,IAAI,GAAE,MAAoB,QAK3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,wBAA6C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clipin/convex-wearables",
-  "version": "0.0.3",
+  "version": "0.1.1",
   "description": "Convex component for wearable device integrations — sync health data from Garmin, Strava, Whoop, Polar, Suunto, Apple HealthKit, Samsung Health, and Google Health Connect.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/clipinfit/convex-wearables#readme",