Software/platform
1
1
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity

More models organization

Browse Source
This commit is contained in:
Dominic Ferrando
2026-07-04 15:57:20 -04:00
parent a7b8dd0bea
commit 28c5b3df18
9 changed files with 148 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/api/src/database/migrations/2026-06-03.ts
+1 -1
View File
@@ -38,7 +38,7 @@ export async function up(db: Kysely<any>): Promise<void> {
await db.schema.createTable("standards_configs") await db.schema.createTable("standards_configs")
.$call(addDefaultColumns) .$call(addDefaultColumns)
.addColumn("name", "text", (cb) => cb.notNull().defaultTo("")) .addColumn("name", "text", (cb) => cb.notNull().defaultTo(""))
.addColumn("parameters", "jsonb", (cb) => cb.notNull()) .addColumn("params", "jsonb", (cb) => cb.notNull())
.addColumn("is_selected", "boolean", (cb) => cb.notNull().defaultTo(false)) .addColumn("is_selected", "boolean", (cb) => cb.notNull().defaultTo(false))
.addColumn("dataset_id", "bigint", (cb) => cb.notNull()) .addColumn("dataset_id", "bigint", (cb) => cb.notNull())
.addForeignKeyConstraint( .addForeignKeyConstraint(
apps/api/src/scripts/analyze.ts
+2 -2
View File
@@ -1,6 +1,6 @@
import { import {
type Levels, type Levels,
DEFAULT_STANDARDS_DATASET, DEFAULT_STANDARDS_DATA,
} from "@blade-and-brawn/calculator"; } from "@blade-and-brawn/calculator";
import { Activity, clamp, Gender, range } from "@blade-and-brawn/domain"; import { Activity, clamp, Gender, range } from "@blade-and-brawn/domain";
import { levenbergMarquardt as LM } from "ml-levenberg-marquardt"; import { levenbergMarquardt as LM } from "ml-levenberg-marquardt";
@@ -15,7 +15,7 @@ for (const activity of Object.values(Activity)) {
} }
for (const gender of Object.values(Gender)) { for (const gender of Object.values(Gender)) {
const standardsByGender = DEFAULT_STANDARDS_DATASET[ const standardsByGender = DEFAULT_STANDARDS_DATA[
activity activity
].standards.filter((s) => s["metrics"].gender === gender); ].standards.filter((s) => s["metrics"].gender === gender);
const ages = [...new Set(standardsByGender.map((s) => s.metrics.age))]; const ages = [...new Set(standardsByGender.map((s) => s.metrics.age))];
apps/api/src/server.ts
+6 -6
View File
@@ -18,7 +18,7 @@ import { CommerceService } from "./services/commerce";
import cluster from "node:cluster"; import cluster from "node:cluster";
import { randomUUIDv7 } from "bun"; import { randomUUIDv7 } from "bun";
import { CalculatorService } from "./services/calculator"; import { CalculatorService } from "./services/calculator";
import { StandardsParametersSchema } from "@blade-and-brawn/calculator"; import { StandardsParamsSchema } from "@blade-and-brawn/calculator";
// SERVICES // SERVICES
// ----------- // -----------
@@ -117,16 +117,16 @@ export const app = new Elysia()
if (!token || !token.sessionId) throw status(401, "Unauthorized"); if (!token || !token.sessionId) throw status(401, "Unauthorized");
return { sessionId: token.sessionId.toString() }; return { sessionId: token.sessionId.toString() };
}) })
.put("/config/:id", async ({ params: { id }, body: { datasetId, parameters } }) => { .put("/config/:id", async ({ params: { id }, body: { datasetId, params: parameters } }) => {
await s.Calculator.Standards.Config.update(id, datasetId, parameters); await s.Calculator.Standards.Config.update(id, datasetId, parameters);
}, { }, {
params: t.Object({ id: t.String() }), params: t.Object({ id: t.String() }),
body: t.Object({ datasetId: t.String(), parameters: StandardsParametersSchema }) body: t.Object({ datasetId: t.String(), params: StandardsParamsSchema })
}) })
.post("/config", async ({ body: { datasetId, parameters } }) => { .post("/config", async ({ body: { datasetId, params } }) => {
await s.Calculator.Standards.Config.create(datasetId, parameters); await s.Calculator.Standards.Config.create(datasetId, params);
}, { }, {
body: t.Object({ datasetId: t.String(), parameters: StandardsParametersSchema }) body: t.Object({ datasetId: t.String(), params: StandardsParamsSchema })
}) })
.post("/config/:id/switch", async ({ params: { id } }) => { .post("/config/:id/switch", async ({ params: { id } }) => {
await s.Calculator.Standards.Config.switch(id); await s.Calculator.Standards.Config.switch(id);
apps/api/src/services/calculator.ts
+13 -13
View File
@@ -1,11 +1,11 @@
import { LevelCalculator, Standards, DEFAULT_STANDARDS_DATASET, type StandardsParameters, StandardsParametersSchema, StandardsDatasetSchema } from "@blade-and-brawn/calculator"; import { LevelCalculator, Standards, DEFAULT_STANDARDS_DATA, type StandardsParams, StandardsParamsSchema, StandardsDataSchema } from "@blade-and-brawn/calculator";
import type { ActivityPerformance, Player } from "@blade-and-brawn/domain"; import type { ActivityPerformance, Player } from "@blade-and-brawn/domain";
import { db } from "../database/db"; import { db } from "../database/db";
import { Value } from "@sinclair/typebox/value"; import { Value } from "@sinclair/typebox/value";
import { log } from "../util"; import { log } from "../util";
export class CalculatorService { export class CalculatorService {
private Calculator = new LevelCalculator(new Standards(DEFAULT_STANDARDS_DATASET)); private Calculator = new LevelCalculator(new Standards(DEFAULT_STANDARDS_DATA));
Standards: StandardsService = new StandardsService(this.Calculator); Standards: StandardsService = new StandardsService(this.Calculator);
calculate(player: Player, activityPerformances: ActivityPerformance[]) { calculate(player: Player, activityPerformances: ActivityPerformance[]) {
@@ -30,23 +30,23 @@ class StandardsConfigService {
constructor(private Calculator: LevelCalculator) { } constructor(private Calculator: LevelCalculator) { }
async create(datasetId: string, parameters: StandardsParameters) { async create(datasetId: string, params: StandardsParams) {
await db.insertInto("standards_configs") await db.insertInto("standards_configs")
.values({ parameters, dataset_id: datasetId }) .values({ params, dataset_id: datasetId })
.execute(); .execute();
} }
/** Retrieves the currently selected configuration */ /** Retrieves the currently selected configuration */
async get(opt: { skipCache?: boolean } = {}): Promise<StandardsParameters> { async get(opt: { skipCache?: boolean } = {}): Promise<StandardsParams> {
if (!opt.skipCache) return this.Calculator.Standards.params; if (!opt.skipCache) return this.Calculator.Standards.params;
await this.refresh(); await this.refresh();
return this.Calculator.Standards.params; return this.Calculator.Standards.params;
} }
async update(id: string, datasetId: string, parameters: StandardsParameters) { async update(id: string, datasetId: string, params: StandardsParams) {
const result = await db.updateTable("standards_configs") const result = await db.updateTable("standards_configs")
.set({ parameters, dataset_id: datasetId }) .set({ params, dataset_id: datasetId })
.where("id", "=", id) .where("id", "=", id)
.execute(); .execute();
if (result[0]?.numUpdatedRows === 0n) throw new Error(`No config with id "${id}"`); if (result[0]?.numUpdatedRows === 0n) throw new Error(`No config with id "${id}"`);
@@ -62,19 +62,19 @@ class StandardsConfigService {
.innerJoin("standards_datasets", "standards_datasets.id", "standards_configs.dataset_id") .innerJoin("standards_datasets", "standards_datasets.id", "standards_configs.dataset_id")
.select([ .select([
"standards_configs.dataset_id as datasetId", "standards_configs.dataset_id as datasetId",
"standards_configs.parameters as parameters", "standards_configs.params as params",
"standards_datasets.data as dataset", "standards_datasets.data as data",
]) ])
.where("standards_configs.is_selected", "=", true) .where("standards_configs.is_selected", "=", true)
.limit(1) .limit(1)
.executeTakeFirstOrThrow({ errorConstructor: () => new Error("No standards config selected") }); .executeTakeFirstOrThrow({ errorConstructor: () => new Error("No standards config selected") });
Value.Assert(StandardsParametersSchema, config.parameters); Value.Assert(StandardsParamsSchema, config.params);
Value.Assert(StandardsDatasetSchema, config.dataset); Value.Assert(StandardsDataSchema, config.data);
const parametersStringified = JSON.stringify(config.parameters); const parametersStringified = JSON.stringify(config.params);
if (parametersStringified === this.cachedParametersStringified && config.datasetId === this.cachedDatasetId) return; if (parametersStringified === this.cachedParametersStringified && config.datasetId === this.cachedDatasetId) return;
this.Calculator.Standards = new Standards(config.dataset, config.parameters); this.Calculator.Standards = new Standards(config.data, config.params);
this.cachedParametersStringified = parametersStringified; this.cachedParametersStringified = parametersStringified;
this.cachedDatasetId = config.datasetId; this.cachedDatasetId = config.datasetId;
} }
apps/portal/src/lib/components/StandardsTable.svelte
+2 -2
View File
@@ -2,7 +2,7 @@
import { import {
Standards, Standards,
type Standard, type Standard,
type StandardsParameters, type StandardsParams,
} from "@blade-and-brawn/calculator"; } from "@blade-and-brawn/calculator";
import { import {
Activity, Activity,
@@ -17,7 +17,7 @@
selected: { selected: {
activity: Activity; activity: Activity;
metrics: Metrics; metrics: Metrics;
params: StandardsParameters; params: StandardsParams;
}; };
} }
apps/portal/src/routes/(app)/calculator/+page.svelte
+17 -13
View File
@@ -1,8 +1,8 @@
<script lang="ts"> <script lang="ts">
import { import {
DEFAULT_STANDARDS_DATASET, DEFAULT_STANDARDS_DATA,
Standards, Standards,
type StandardsParameters, type StandardsParams,
} from "@blade-and-brawn/calculator"; } from "@blade-and-brawn/calculator";
import { import {
Activity, Activity,
@@ -15,7 +15,7 @@
let activeTab = $state("standards"); let activeTab = $state("standards");
const defaultStandards = new Standards(DEFAULT_STANDARDS_DATASET); const defaultStandards = new Standards(DEFAULT_STANDARDS_DATA);
let input = $state({ let input = $state({
activity: Activity.BenchPress, activity: Activity.BenchPress,
@@ -24,7 +24,7 @@
age: null as number | null, age: null as number | null,
weight: null as number | null, // lb weight: null as number | null, // lb
}, },
params: structuredClone(defaultStandards.params) as StandardsParameters, params: structuredClone(defaultStandards.params) as StandardsParams,
}); });
const selected = $derived({ const selected = $derived({
@@ -38,7 +38,7 @@
}); });
const allStandards = $derived( const allStandards = $derived(
new Standards(DEFAULT_STANDARDS_DATASET, selected.params), new Standards(DEFAULT_STANDARDS_DATA, selected.params),
); );
$effect(() => { $effect(() => {
@@ -124,8 +124,9 @@
input.params.activity[selected.activity] input.params.activity[selected.activity]
.weightModifier .weightModifier
} }
disabled={!selected.params.activity[selected.activity] disabled={!selected.params.activity[
.enableGeneration} selected.activity
].enableGeneration}
/> />
</label> </label>
<!-- <label> --> <!-- <label> -->
@@ -156,8 +157,9 @@
input.params.activity[selected.activity] input.params.activity[selected.activity]
.difficultyModifier .difficultyModifier
} }
disabled={!selected.params.activity[selected.activity] disabled={!selected.params.activity[
.enableGeneration} selected.activity
].enableGeneration}
/> />
</label> </label>
<label> <label>
@@ -172,8 +174,9 @@
input.params.activity[selected.activity] input.params.activity[selected.activity]
.ageModifier .ageModifier
} }
disabled={!selected.params.activity[selected.activity] disabled={!selected.params.activity[
.enableGeneration} selected.activity
].enableGeneration}
/> />
</label> </label>
<label> <label>
@@ -187,8 +190,9 @@
bind:value={ bind:value={
input.params.activity[selected.activity].peakAge input.params.activity[selected.activity].peakAge
} }
disabled={!selected.params.activity[selected.activity] disabled={!selected.params.activity[
.enableGeneration} selected.activity
].enableGeneration}
/> />
</label> </label>
packages/calculator/src/index.ts
+22 -80
View File
@@ -5,17 +5,16 @@ import {
kgToLb, kgToLb,
lbToKg, lbToKg,
range, range,
MetricsSchema,
type Metrics, type Metrics,
type ActivityPerformance, type ActivityPerformance,
type Player, type Player,
} from "@blade-and-brawn/domain"; } from "@blade-and-brawn/domain";
import { levenbergMarquardt as LM } from "ml-levenberg-marquardt"; import { levenbergMarquardt as LM } from "ml-levenberg-marquardt";
import { Type, type Static } from "@sinclair/typebox";
import defaultConfig from "./default-config.json" with { type: "json" }; import defaultConfig from "./default-config.json" with { type: "json" };
import defaultStandardsDataset from "./data/default-standards.json" with { type: "json" }; import defaultStandardsData from "./data/default-standards.json" with { type: "json" };
import { getAvgWeight } from "./avg-weights"; import { getAvgWeight } from "./avg-weights";
import { Value } from "@sinclair/typebox/value"; import { Value } from "@sinclair/typebox/value";
import { StandardsParamsSchema, type LevelCalculatorOutput, type Levels, type NumberMetric, type Standard, type StandardsData, type StandardsParams } from "./models";
// SOURCES // SOURCES
// Squat, Bench, Dead Lift: // Squat, Bench, Dead Lift:
@@ -27,42 +26,7 @@ import { Value } from "@sinclair/typebox/value";
// 3 Cone drill: // 3 Cone drill:
// https://nflsavant.com/combine.php?utm_source=chatgpt.com // https://nflsavant.com/combine.php?utm_source=chatgpt.com
export type LevelCalculatorOutput = { export * from "./models";
player: number;
attributes: Record<Attribute, number>;
};
export const LevelsSchema = Type.Record(Type.String(), Type.Number());
export type Levels = Static<typeof LevelsSchema>;
type NumberMetric = Extract<keyof Metrics, "age" | "weight">;
export const StandardSchema = Type.Object({
metrics: MetricsSchema,
levels: LevelsSchema,
});
export type Standard = Static<typeof StandardSchema>;
const GeneratorSchema = Type.Object({
metric: Type.Union([Type.Literal("age"), Type.Literal("weight")]),
});
type Generator = Static<typeof GeneratorSchema>;
const StandardUnitSchema = Type.Union([Type.Literal("ms"), Type.Literal("cm"), Type.Literal("kg")]);
export const StandardsDatasetSchema = Type.Record(
Type.Enum(Activity),
Type.Object({
metadata: Type.Object({
attribute: Type.Enum(Attribute),
generators: Type.Array(GeneratorSchema),
unit: StandardUnitSchema,
name: Type.String(),
}),
standards: Type.Array(StandardSchema),
}),
);
export type StandardsDataset = Static<typeof StandardsDatasetSchema>;
const metricPriority = (m: NumberMetric) => { const metricPriority = (m: NumberMetric) => {
if (m === "age") return 0; if (m === "age") return 0;
@@ -70,7 +34,7 @@ const metricPriority = (m: NumberMetric) => {
return 2; return 2;
}; };
export const DEFAULT_STANDARDS_DATASET = defaultStandardsDataset as StandardsDataset; export const DEFAULT_STANDARDS_DATA = defaultStandardsData as StandardsData;
export class LevelCalculator { export class LevelCalculator {
Standards: Standards; Standards: Standards;
@@ -219,38 +183,16 @@ export class LevelCalculator {
} }
} }
const StandardsActivityParametersSchema = Type.Object({
weightModifier: Type.Number(),
weightSkew: Type.Number(),
ageModifier: Type.Number(),
enableGeneration: Type.Boolean(),
difficultyModifier: Type.Number(),
peakAge: Type.Number(),
stretch: Type.Object({
upper: Type.Number(),
lower: Type.Number(),
}),
});
export const StandardsParametersSchema = Type.Object({
global: Type.Object({
maxLevel: Type.Number(),
}),
activity: Type.Record(Type.Enum(Activity), StandardsActivityParametersSchema),
});
export type StandardsParameters = Static<typeof StandardsParametersSchema>;
export class Standards { export class Standards {
readonly params: StandardsParameters; readonly params: StandardsParams;
private standardsData: StandardsDataset; private data: StandardsData;
constructor(dataset: StandardsDataset, params?: Partial<StandardsParameters>) { constructor(data: StandardsData, params?: Partial<StandardsParams>) {
Value.Assert(StandardsParametersSchema, defaultConfig); Value.Assert(StandardsParamsSchema, defaultConfig);
this.params = Object.assign({}, defaultConfig, params); this.params = Object.assign({}, defaultConfig, params);
// prepare data // prepare data
this.standardsData = structuredClone(dataset); this.data = structuredClone(data);
// STRETCH // STRETCH
for (const activity of Object.values(Activity)) { for (const activity of Object.values(Activity)) {
@@ -265,7 +207,7 @@ export class Standards {
} }
for (const gender of Object.values(Gender)) { for (const gender of Object.values(Gender)) {
const standardsByGender = this.standardsData[ const standardsByGender = this.data[
activity activity
].standards.filter((s) => s["metrics"].gender === gender); ].standards.filter((s) => s["metrics"].gender === gender);
const ages = [ const ages = [
@@ -363,7 +305,7 @@ export class Standards {
// EXPAND, COMPRESS, SKEW // EXPAND, COMPRESS, SKEW
for (const activity of Object.values(Activity)) { for (const activity of Object.values(Activity)) {
for (const standard of this.standardsData[activity].standards) { for (const standard of this.data[activity].standards) {
// expand // expand
let i = 1; let i = 1;
while ( while (
@@ -394,7 +336,7 @@ export class Standards {
// generate data // generate data
const allGenerators = this.params.activity[activity].enableGeneration const allGenerators = this.params.activity[activity].enableGeneration
? this.standardsData[activity].metadata.generators.sort( ? this.data[activity].metadata.generators.sort(
(a, b) => (a, b) =>
metricPriority(a.metric) - metricPriority(b.metric), metricPriority(a.metric) - metricPriority(b.metric),
) )
@@ -472,7 +414,7 @@ export class Standards {
.byMetrics(newStandard.metrics) .byMetrics(newStandard.metrics)
.getOne(); .getOne();
if (!overlappingStandard) if (!overlappingStandard)
this.standardsData[activity].standards.push( this.data[activity].standards.push(
newStandard, newStandard,
); );
@@ -481,7 +423,7 @@ export class Standards {
} }
// now that we generated metric data, remove the old data // now that we generated metric data, remove the old data
this.standardsData[activity].standards = this.standardsData[ this.data[activity].standards = this.data[
activity activity
].standards.filter((s) => s.metrics.age != null); ].standards.filter((s) => s.metrics.age != null);
} else if (generator.metric === "weight") { } else if (generator.metric === "weight") {
@@ -538,7 +480,7 @@ export class Standards {
.byMetrics(newStandard.metrics) .byMetrics(newStandard.metrics)
.getOne(); .getOne();
if (!overlappingStandard) if (!overlappingStandard)
this.standardsData[activity].standards.push( this.data[activity].standards.push(
newStandard, newStandard,
); );
@@ -548,13 +490,13 @@ export class Standards {
} }
// now that we generated metric data, remove the old data // now that we generated metric data, remove the old data
this.standardsData[activity].standards = this.standardsData[ this.data[activity].standards = this.data[
activity activity
].standards.filter((s) => s.metrics.weight); ].standards.filter((s) => s.metrics.weight);
} }
} }
this.standardsData[activity].standards = this.standardsData[ this.data[activity].standards = this.data[
activity activity
].standards.sort((a, b) => { ].standards.sort((a, b) => {
const genderOrder: Record<Gender, number> = { const genderOrder: Record<Gender, number> = {
@@ -581,7 +523,7 @@ export class Standards {
exact: { exact: {
// these will get EXACT matches // these will get EXACT matches
getAll(): Standard[] { getAll(): Standard[] {
const src = self.standardsData[activity].standards; const src = self.data[activity].standards;
const out: Standard[] = []; const out: Standard[] = [];
for (let i = 0; i < src.length; i++) { for (let i = 0; i < src.length; i++) {
@@ -733,7 +675,7 @@ export class Standards {
return interpolateByAgeAndWeight(metrics); return interpolateByAgeAndWeight(metrics);
}; };
const getMetadata = () => this.standardsData[activity].metadata; const getMetadata = () => this.data[activity].metadata;
// QUERY METHODS // QUERY METHODS
@@ -768,10 +710,10 @@ export class Standards {
public getAttributeActivities(attribute: Attribute): Activity[] { public getAttributeActivities(attribute: Attribute): Activity[] {
const activities: Activity[] = []; const activities: Activity[] = [];
for (const activity of Object.keys(this.standardsData) as Activity[]) { for (const activity of Object.keys(this.data) as Activity[]) {
const standardData = this.standardsData[ const standardData = this.data[
activity activity
] as StandardsDataset[Activity]; ] as StandardsData[Activity];
if (standardData.metadata.attribute === attribute) { if (standardData.metadata.attribute === attribute) {
activities.push(activity as Activity); activities.push(activity as Activity);
} }
packages/calculator/src/models.ts
+69
View File
@@ -0,0 +1,69 @@
import {
Activity,
Attribute,
MetricsSchema,
type Metrics,
} from "@blade-and-brawn/domain";
import { Type as t, type Static } from "@sinclair/typebox";
// ================
// CALCULATOR
// ================
export type LevelCalculatorOutput = {
player: number;
attributes: Record<Attribute, number>;
};
export type NumberMetric = Extract<keyof Metrics, "age" | "weight">;
export const LevelsSchema = t.Record(t.String(), t.Number());
export type Levels = Static<typeof LevelsSchema>;
// ================
// STANDARDS
// ================
export const StandardSchema = t.Object({
metrics: MetricsSchema,
levels: LevelsSchema,
});
export type Standard = Static<typeof StandardSchema>;
export const GeneratorSchema = t.Object({
metric: t.Union([t.Literal("age"), t.Literal("weight")]),
});
export type Generator = Static<typeof GeneratorSchema>;
export const StandardsDataSchema = t.Record(
t.Enum(Activity),
t.Object({
metadata: t.Object({
attribute: t.Enum(Attribute),
generators: t.Array(GeneratorSchema),
unit: t.Union([t.Literal("ms"), t.Literal("cm"), t.Literal("kg")]),
name: t.String(),
}),
standards: t.Array(StandardSchema),
}),
);
export type StandardsData = Static<typeof StandardsDataSchema>;
export const StandardsParamsSchema = t.Object({
global: t.Object({
maxLevel: t.Number(),
}),
activity: t.Record(t.Enum(Activity), t.Object({
weightModifier: t.Number(),
weightSkew: t.Number(),
ageModifier: t.Number(),
enableGeneration: t.Boolean(),
difficultyModifier: t.Number(),
peakAge: t.Number(),
stretch: t.Object({
upper: t.Number(),
lower: t.Number(),
}),
}))
});
export type StandardsParams = Static<typeof StandardsParamsSchema>;
packages/domain/src/models.ts
+16 -17
View File
@@ -1,4 +1,4 @@
import { Type } from "@sinclair/typebox"; import { Type as t } from "@sinclair/typebox";
import type { Static } from "@sinclair/typebox"; import type { Static } from "@sinclair/typebox";
export enum Attribute { export enum Attribute {
@@ -22,24 +22,23 @@ export enum Gender {
Female = "Female", Female = "Female",
} }
export const MetricsSchema = Type.Object({
age: Type.Number(),
weight: Type.Number(),
gender: Type.Enum(Gender),
});
export const PlayerSchema = Type.Object({
name: Type.Optional(Type.String()),
metrics: MetricsSchema,
});
export const ActivityPerformanceSchema = Type.Object({
activity: Type.Enum(Activity),
performance: Type.Number(),
});
export type StandardUnit = "ms" | "cm" | "kg"; export type StandardUnit = "ms" | "cm" | "kg";
export const MetricsSchema = t.Object({
age: t.Number(),
weight: t.Number(),
gender: t.Enum(Gender),
});
export type Metrics = Static<typeof MetricsSchema>; export type Metrics = Static<typeof MetricsSchema>;
export const PlayerSchema = t.Object({
name: t.Optional(t.String()),
metrics: MetricsSchema,
});
export type Player = Static<typeof PlayerSchema>; export type Player = Static<typeof PlayerSchema>;
export const ActivityPerformanceSchema = t.Object({
activity: t.Enum(Activity),
performance: t.Number(),
});
export type ActivityPerformance = Static<typeof ActivityPerformanceSchema>; export type ActivityPerformance = Static<typeof ActivityPerformanceSchema>;