endurance-coach 0.1.0 → 1.0.0

package/dist/templates/template.schema.d.ts

@@ -0,0 +1,401 @@
+/**
+ * Workout Template Zod Schema
+ *
+ * Runtime validation for workout template definitions.
+ */
+import { z } from "zod";
+export declare const SportSchema: z.ZodEnum<{
+    swim: "swim";
+    bike: "bike";
+    run: "run";
+    strength: "strength";
+    brick: "brick";
+    race: "race";
+    rest: "rest";
+}>;
+export declare const ParamTypeSchema: z.ZodEnum<{
+    string: "string";
+    number: "number";
+    duration: "duration";
+    int: "int";
+    distance: "distance";
+}>;
+export declare const StepTypeSchema: z.ZodEnum<{
+    rest: "rest";
+    warmup: "warmup";
+    work: "work";
+    recovery: "recovery";
+    cooldown: "cooldown";
+}>;
+export declare const WorkoutCategorySchema: z.ZodEnum<{
+    strength: "strength";
+    race: "race";
+    rest: "rest";
+    recovery: "recovery";
+    threshold: "threshold";
+    endurance: "endurance";
+    tempo: "tempo";
+    intervals: "intervals";
+    technique: "technique";
+    hills: "hills";
+    speed: "speed";
+}>;
+export declare const TemplateParamSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        duration: "duration";
+        int: "int";
+        distance: "distance";
+    }>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const TemplateParamsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        duration: "duration";
+        int: "int";
+        distance: "distance";
+    }>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const TemplateStepSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        rest: "rest";
+        warmup: "warmup";
+        work: "work";
+        recovery: "recovery";
+        cooldown: "cooldown";
+    }>;
+    name: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodString>;
+    distance: z.ZodOptional<z.ZodString>;
+    pace: z.ZodOptional<z.ZodString>;
+    intensity: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const TemplateIntervalSetSchema: z.ZodObject<{
+    type: z.ZodLiteral<"intervals">;
+    repeats: z.ZodString;
+    work: z.ZodObject<{
+        type: z.ZodEnum<{
+            rest: "rest";
+            warmup: "warmup";
+            work: "work";
+            recovery: "recovery";
+            cooldown: "cooldown";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodString>;
+        distance: z.ZodOptional<z.ZodString>;
+        pace: z.ZodOptional<z.ZodString>;
+        intensity: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    recovery: z.ZodObject<{
+        type: z.ZodEnum<{
+            rest: "rest";
+            warmup: "warmup";
+            work: "work";
+            recovery: "recovery";
+            cooldown: "cooldown";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodString>;
+        distance: z.ZodOptional<z.ZodString>;
+        pace: z.ZodOptional<z.ZodString>;
+        intensity: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const MainSetElementSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<{
+        rest: "rest";
+        warmup: "warmup";
+        work: "work";
+        recovery: "recovery";
+        cooldown: "cooldown";
+    }>;
+    name: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodString>;
+    distance: z.ZodOptional<z.ZodString>;
+    pace: z.ZodOptional<z.ZodString>;
+    intensity: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"intervals">;
+    repeats: z.ZodString;
+    work: z.ZodObject<{
+        type: z.ZodEnum<{
+            rest: "rest";
+            warmup: "warmup";
+            work: "work";
+            recovery: "recovery";
+            cooldown: "cooldown";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodString>;
+        distance: z.ZodOptional<z.ZodString>;
+        pace: z.ZodOptional<z.ZodString>;
+        intensity: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    recovery: z.ZodObject<{
+        type: z.ZodEnum<{
+            rest: "rest";
+            warmup: "warmup";
+            work: "work";
+            recovery: "recovery";
+            cooldown: "cooldown";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodString>;
+        distance: z.ZodOptional<z.ZodString>;
+        pace: z.ZodOptional<z.ZodString>;
+        intensity: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>]>;
+export declare const TemplateStructureSchema: z.ZodObject<{
+    warmup: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            rest: "rest";
+            warmup: "warmup";
+            work: "work";
+            recovery: "recovery";
+            cooldown: "cooldown";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodString>;
+        distance: z.ZodOptional<z.ZodString>;
+        pace: z.ZodOptional<z.ZodString>;
+        intensity: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    main: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodEnum<{
+            rest: "rest";
+            warmup: "warmup";
+            work: "work";
+            recovery: "recovery";
+            cooldown: "cooldown";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodString>;
+        distance: z.ZodOptional<z.ZodString>;
+        pace: z.ZodOptional<z.ZodString>;
+        intensity: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"intervals">;
+        repeats: z.ZodString;
+        work: z.ZodObject<{
+            type: z.ZodEnum<{
+                rest: "rest";
+                warmup: "warmup";
+                work: "work";
+                recovery: "recovery";
+                cooldown: "cooldown";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            duration: z.ZodOptional<z.ZodString>;
+            distance: z.ZodOptional<z.ZodString>;
+            pace: z.ZodOptional<z.ZodString>;
+            intensity: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        recovery: z.ZodObject<{
+            type: z.ZodEnum<{
+                rest: "rest";
+                warmup: "warmup";
+                work: "work";
+                recovery: "recovery";
+                cooldown: "cooldown";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            duration: z.ZodOptional<z.ZodString>;
+            distance: z.ZodOptional<z.ZodString>;
+            pace: z.ZodOptional<z.ZodString>;
+            intensity: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>;
+    cooldown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            rest: "rest";
+            warmup: "warmup";
+            work: "work";
+            recovery: "recovery";
+            cooldown: "cooldown";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodString>;
+        distance: z.ZodOptional<z.ZodString>;
+        pace: z.ZodOptional<z.ZodString>;
+        intensity: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const WorkoutTemplateSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    sport: z.ZodEnum<{
+        swim: "swim";
+        bike: "bike";
+        run: "run";
+        strength: "strength";
+        brick: "brick";
+        race: "race";
+        rest: "rest";
+    }>;
+    type: z.ZodString;
+    category: z.ZodEnum<{
+        strength: "strength";
+        race: "race";
+        rest: "rest";
+        recovery: "recovery";
+        threshold: "threshold";
+        endurance: "endurance";
+        tempo: "tempo";
+        intervals: "intervals";
+        technique: "technique";
+        hills: "hills";
+        speed: "speed";
+    }>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            duration: "duration";
+            int: "int";
+            distance: "distance";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    structure: z.ZodOptional<z.ZodObject<{
+        warmup: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                rest: "rest";
+                warmup: "warmup";
+                work: "work";
+                recovery: "recovery";
+                cooldown: "cooldown";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            duration: z.ZodOptional<z.ZodString>;
+            distance: z.ZodOptional<z.ZodString>;
+            pace: z.ZodOptional<z.ZodString>;
+            intensity: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        main: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodEnum<{
+                rest: "rest";
+                warmup: "warmup";
+                work: "work";
+                recovery: "recovery";
+                cooldown: "cooldown";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            duration: z.ZodOptional<z.ZodString>;
+            distance: z.ZodOptional<z.ZodString>;
+            pace: z.ZodOptional<z.ZodString>;
+            intensity: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"intervals">;
+            repeats: z.ZodString;
+            work: z.ZodObject<{
+                type: z.ZodEnum<{
+                    rest: "rest";
+                    warmup: "warmup";
+                    work: "work";
+                    recovery: "recovery";
+                    cooldown: "cooldown";
+                }>;
+                name: z.ZodOptional<z.ZodString>;
+                duration: z.ZodOptional<z.ZodString>;
+                distance: z.ZodOptional<z.ZodString>;
+                pace: z.ZodOptional<z.ZodString>;
+                intensity: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            recovery: z.ZodObject<{
+                type: z.ZodEnum<{
+                    rest: "rest";
+                    warmup: "warmup";
+                    work: "work";
+                    recovery: "recovery";
+                    cooldown: "cooldown";
+                }>;
+                name: z.ZodOptional<z.ZodString>;
+                duration: z.ZodOptional<z.ZodString>;
+                distance: z.ZodOptional<z.ZodString>;
+                pace: z.ZodOptional<z.ZodString>;
+                intensity: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>]>>;
+        cooldown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                rest: "rest";
+                warmup: "warmup";
+                work: "work";
+                recovery: "recovery";
+                cooldown: "cooldown";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            duration: z.ZodOptional<z.ZodString>;
+            distance: z.ZodOptional<z.ZodString>;
+            pace: z.ZodOptional<z.ZodString>;
+            intensity: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    humanReadable: z.ZodString;
+    estimatedDuration: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    targetZone: z.ZodOptional<z.ZodString>;
+    rpe: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TemplateValidationResult = {
+    success: true;
+    data: z.infer<typeof WorkoutTemplateSchema>;
+} | {
+    success: false;
+    errors: TemplateValidationError[];
+};
+export interface TemplateValidationError {
+    path: string;
+    message: string;
+    code: string;
+}
+/**
+ * Validate a workout template against the schema.
+ */
+export declare function validateTemplate(data: unknown): TemplateValidationResult;
+/**
+ * Validate a template and throw an error if invalid.
+ */
+export declare function validateTemplateOrThrow(data: unknown): z.infer<typeof WorkoutTemplateSchema>;
+export type WorkoutTemplate = z.infer<typeof WorkoutTemplateSchema>;
+export type TemplateParam = z.infer<typeof TemplateParamSchema>;
+export type TemplateParams = z.infer<typeof TemplateParamsSchema>;
+export type TemplateStep = z.infer<typeof TemplateStepSchema>;
+export type TemplateIntervalSet = z.infer<typeof TemplateIntervalSetSchema>;
+export type TemplateStructure = z.infer<typeof TemplateStructureSchema>;
+export type Sport = z.infer<typeof SportSchema>;
+export type WorkoutCategory = z.infer<typeof WorkoutCategorySchema>;

package/dist/templates/template.schema.js

@@ -0,0 +1,101 @@
+/**
+ * Workout Template Zod Schema
+ *
+ * Runtime validation for workout template definitions.
+ */
+import { z } from "zod";
+// ============================================================================
+// Core Types
+// ============================================================================
+export const SportSchema = z.enum(["swim", "bike", "run", "strength", "brick", "race", "rest"]);
+export const ParamTypeSchema = z.enum(["int", "number", "duration", "distance", "string"]);
+export const StepTypeSchema = z.enum(["warmup", "work", "recovery", "rest", "cooldown"]);
+export const WorkoutCategorySchema = z.enum([
+    "rest",
+    "recovery",
+    "endurance",
+    "tempo",
+    "threshold",
+    "intervals",
+    "speed",
+    "hills",
+    "race",
+    "strength",
+    "technique",
+]);
+// ============================================================================
+// Template Parameters
+// ============================================================================
+export const TemplateParamSchema = z.object({
+    type: ParamTypeSchema,
+    required: z.boolean().optional(),
+    default: z.union([z.number(), z.string()]).optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    description: z.string().optional(),
+});
+export const TemplateParamsSchema = z.record(z.string(), TemplateParamSchema);
+// ============================================================================
+// Workout Structure
+// ============================================================================
+export const TemplateStepSchema = z.object({
+    type: StepTypeSchema,
+    name: z.string().optional(),
+    duration: z.string().optional(),
+    distance: z.string().optional(),
+    pace: z.string().optional(),
+    intensity: z.string().optional(),
+    description: z.string().optional(),
+});
+export const TemplateIntervalSetSchema = z.object({
+    type: z.literal("intervals"),
+    repeats: z.string(),
+    work: TemplateStepSchema,
+    recovery: TemplateStepSchema,
+});
+export const MainSetElementSchema = z.union([TemplateStepSchema, TemplateIntervalSetSchema]);
+export const TemplateStructureSchema = z.object({
+    warmup: z.array(TemplateStepSchema).optional(),
+    main: z.array(MainSetElementSchema),
+    cooldown: z.array(TemplateStepSchema).optional(),
+});
+// ============================================================================
+// Complete Template
+// ============================================================================
+export const WorkoutTemplateSchema = z.object({
+    id: z
+        .string()
+        .regex(/^[a-zA-Z0-9_.]+$/, "Template ID must contain only letters, numbers, dots, and underscores"),
+    name: z.string().min(1),
+    sport: SportSchema,
+    type: z.string().min(1),
+    category: WorkoutCategorySchema,
+    params: TemplateParamsSchema.optional(),
+    structure: TemplateStructureSchema.optional(),
+    humanReadable: z.string().min(1),
+    estimatedDuration: z.union([z.string(), z.number()]).optional(),
+    targetZone: z.string().optional(),
+    rpe: z.string().optional(),
+    notes: z.string().optional(),
+});
+/**
+ * Validate a workout template against the schema.
+ */
+export function validateTemplate(data) {
+    const result = WorkoutTemplateSchema.safeParse(data);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    const errors = result.error.issues.map((issue) => ({
+        path: issue.path.join("."),
+        message: issue.message,
+        code: issue.code,
+    }));
+    return { success: false, errors };
+}
+/**
+ * Validate a template and throw an error if invalid.
+ */
+export function validateTemplateOrThrow(data) {
+    return WorkoutTemplateSchema.parse(data);
+}

package/dist/templates/template.types.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Workout Template Types
+ *
+ * Templates define reusable workout structures with parametrized values.
+ * They're referenced in compact plans and expanded with athlete-specific data.
+ */
+import type { Sport } from "../schema/compact-plan.js";
+/**
+ * Parameter types for template variables.
+ */
+export type ParamType = "int" | "number" | "duration" | "distance" | "string";
+/**
+ * A template parameter definition.
+ */
+export interface TemplateParam {
+    type: ParamType;
+    required?: boolean;
+    default?: number | string;
+    min?: number;
+    max?: number;
+    description?: string;
+}
+/**
+ * Map of parameter names to their definitions.
+ */
+export interface TemplateParams {
+    [paramName: string]: TemplateParam;
+}
+/**
+ * Step types within a structured workout.
+ */
+export type StepType = "warmup" | "work" | "recovery" | "rest" | "cooldown";
+/**
+ * A single step in a workout structure.
+ * Values can include ${variable} interpolation.
+ */
+export interface TemplateStep {
+    type: StepType;
+    name?: string;
+    duration?: string;
+    distance?: string;
+    pace?: string;
+    intensity?: string;
+    description?: string;
+}
+/**
+ * An interval set with work/recovery pattern.
+ */
+export interface TemplateIntervalSet {
+    type: "intervals";
+    repeats: string;
+    work: TemplateStep;
+    recovery: TemplateStep;
+}
+/**
+ * The main section can be simple steps or interval sets.
+ */
+export type MainSetElement = TemplateStep | TemplateIntervalSet;
+/**
+ * Structured workout with warmup, main, and cooldown sections.
+ */
+export interface TemplateStructure {
+    warmup?: TemplateStep[];
+    main: MainSetElement[];
+    cooldown?: TemplateStep[];
+}
+/**
+ * Workout category for organization.
+ */
+export type WorkoutCategory = "rest" | "recovery" | "endurance" | "tempo" | "threshold" | "intervals" | "speed" | "hills" | "race" | "strength" | "technique";
+/**
+ * A complete workout template.
+ */
+export interface WorkoutTemplate {
+    /** Unique template identifier, e.g., "intervals.400", "easy", "tempo" */
+    id: string;
+    /** Human-readable name, e.g., "400m Repeats", "Easy Run" */
+    name: string;
+    /** Sport type */
+    sport: Sport;
+    /** Workout type for classification */
+    type: string;
+    /** Category for grouping */
+    category: WorkoutCategory;
+    /** Template parameters with defaults and validation */
+    params?: TemplateParams;
+    /** Structured workout (optional, for device export) */
+    structure?: TemplateStructure;
+    /**
+     * Human-readable workout description.
+     * Supports ${variable} interpolation.
+     * This becomes the workout's humanReadable field after expansion.
+     */
+    humanReadable: string;
+    /**
+     * Estimated duration calculation.
+     * Can be a number (minutes) or expression string.
+     * E.g., "${10 + (reps * 3.5) + 10}" or "30"
+     */
+    estimatedDuration?: string | number;
+    /** Target training zone, e.g., "Z2", "Z4-Z5" */
+    targetZone?: string;
+    /** RPE range, e.g., "6-7", "8-9" */
+    rpe?: string;
+    /** Additional notes about the workout */
+    notes?: string;
+}
+/**
+ * A registry of all available workout templates.
+ */
+export interface TemplateRegistry {
+    /** All templates indexed by ID */
+    templates: Map<string, WorkoutTemplate>;
+    /** Get a template by ID */
+    get(id: string): WorkoutTemplate | undefined;
+    /** List all templates, optionally filtered by sport */
+    list(sport?: Sport): WorkoutTemplate[];
+    /** Check if a template exists */
+    has(id: string): boolean;
+    /** Get all template IDs */
+    ids(): string[];
+}
+/**
+ * Context provided during template interpolation.
+ */
+export interface InterpolationContext {
+    /** Athlete's pace values */
+    paces: Record<string, string | undefined>;
+    /** Athlete's zone configuration */
+    zones?: {
+        hr?: {
+            lthr: number;
+            [zone: string]: number | undefined;
+        };
+        [key: string]: unknown;
+    };
+    /** Template parameters (reps, duration, etc.) */
+    [param: string]: unknown;
+}
+/**
+ * A workout after template expansion.
+ * All ${variables} have been replaced with actual values.
+ */
+export interface ExpandedWorkout {
+    id: string;
+    sport: Sport;
+    type: string;
+    name: string;
+    description?: string;
+    durationMinutes?: number;
+    humanReadable: string;
+    targetZone?: string;
+    rpe?: string;
+    completed: boolean;
+}

package/dist/templates/template.types.js

@@ -0,0 +1,7 @@
+/**
+ * Workout Template Types
+ *
+ * Templates define reusable workout structures with parametrized values.
+ * They're referenced in compact plans and expanded with athlete-specific data.
+ */
+export {};

package/dist/templates/yaml-parser.d.ts

@@ -0,0 +1,15 @@
+/**
+ * YAML Parser Wrapper
+ *
+ * Provides consistent YAML parsing for templates and compact plans.
+ */
+/**
+ * Parse a YAML string into a JavaScript object.
+ */
+export declare function parse<T = unknown>(content: string): T;
+/**
+ * Stringify a JavaScript object to YAML.
+ */
+export declare function stringify(data: unknown, options?: {
+    indent?: number;
+}): string;

package/dist/templates/yaml-parser.js

@@ -0,0 +1,18 @@
+/**
+ * YAML Parser Wrapper
+ *
+ * Provides consistent YAML parsing for templates and compact plans.
+ */
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
+/**
+ * Parse a YAML string into a JavaScript object.
+ */
+export function parse(content) {
+    return yamlParse(content);
+}
+/**
+ * Stringify a JavaScript object to YAML.
+ */
+export function stringify(data, options) {
+    return yamlStringify(data, { indent: options?.indent ?? 2 });
+}