@rlynjb/aptkit-core 0.2.0 → 0.3.0

package/README.md

@@ -13,7 +13,7 @@ The package is published to npmjs as `@rlynjb/aptkit-core`.
 Blooming keeps its existing imports by installing this package through an npm alias:
 
 ```sh
-npm install @aptkit/core@npm:@rlynjb/aptkit-core@0.2.0
+npm install @aptkit/core@npm:@rlynjb/aptkit-core@0.2.1
 ```
 
 Because the package is public on npmjs, consumers do not need a package registry token.

package/dist/src/index.d.ts

@@ -3,7 +3,7 @@ export * from '@aptkit/tools';
 export * from '@aptkit/context';
 export * from '@aptkit/prompts';
 export * from '@aptkit/evals';
-export * from '@aptkit/provider-synthetic';
+export * from '@aptkit/workflows';
 export * from '@aptkit/agent-recommendation';
 export { ANOMALY_MONITORING_CAPABILITY_ID, AnomalyMonitoringAgent, ECOMMERCE_ANOMALY_CATEGORIES, anomalyMonitoringToolPolicy, coverageReport, formatCategoryChecklist, runnableCategories, schemaCapabilities, tryParseAnomalies, validateAnomalies, } from '@aptkit/agent-anomaly-monitoring';
 export type { Anomaly as MonitoringAnomaly, AnomalyCategory as MonitoringAnomalyCategory, } from '@aptkit/agent-anomaly-monitoring';

package/dist/src/index.js

@@ -3,7 +3,7 @@ export * from '@aptkit/tools';
 export * from '@aptkit/context';
 export * from '@aptkit/prompts';
 export * from '@aptkit/evals';
-export * from '@aptkit/provider-synthetic';
+export * from '@aptkit/workflows';
 export * from '@aptkit/agent-recommendation';
 export { ANOMALY_MONITORING_CAPABILITY_ID, AnomalyMonitoringAgent, ECOMMERCE_ANOMALY_CATEGORIES, anomalyMonitoringToolPolicy, coverageReport, formatCategoryChecklist, runnableCategories, schemaCapabilities, tryParseAnomalies, validateAnomalies, } from '@aptkit/agent-anomaly-monitoring';
 export { DIAGNOSTIC_INVESTIGATION_CAPABILITY_ID, DiagnosticInvestigationAgent, diagnosticInvestigationToolPolicy, diagnosisConfidence, tryParseDiagnosis, validateDiagnosis, } from '@aptkit/agent-diagnostic-investigation';

package/node_modules/@aptkit/evals/dist/src/index.d.ts

@@ -1,3 +1,4 @@
 export * from './assertions.js';
 export * from './detection-scorer.js';
+export * from './rubric-judge.js';
 export * from './structural-diff.js';

package/node_modules/@aptkit/evals/dist/src/index.js

@@ -1,3 +1,4 @@
 export * from './assertions.js';
 export * from './detection-scorer.js';
+export * from './rubric-judge.js';
 export * from './structural-diff.js';

package/node_modules/@aptkit/evals/dist/src/rubric-judge.d.ts

@@ -0,0 +1,67 @@
+import { type CapabilityTraceSink, type JsonValidation, type ModelProvider, type StructuredGenerationResult } from '@aptkit/runtime';
+export type RubricScoreLevel = {
+    score: number;
+    description: string;
+};
+export type RubricDimension = {
+    id: string;
+    label: string;
+    description: string;
+    scale: readonly RubricScoreLevel[];
+};
+export type RubricVerdictRule = {
+    verdict: string;
+    description: string;
+};
+export type RubricCalibrationExample = {
+    input: string;
+    expected: string;
+};
+export type RubricDefinition = {
+    id: string;
+    title: string;
+    task: string;
+    dimensions: readonly RubricDimension[];
+    verdicts: readonly RubricVerdictRule[];
+    checks?: readonly string[];
+    calibrationExamples?: readonly RubricCalibrationExample[];
+};
+export type RubricDimensionScore = {
+    score: number;
+    reason: string;
+};
+export type RubricJudgment = {
+    dimensions: Record<string, RubricDimensionScore>;
+    checks?: Record<string, boolean>;
+    verdict: string;
+    fix: string;
+    reasoning?: string;
+};
+export type RubricJudgeInput = {
+    subject: string;
+    context?: Record<string, string>;
+};
+export type RubricJudgeOptions = {
+    model: ModelProvider;
+    rubric: RubricDefinition;
+    capabilityId?: string;
+    maxTokens?: number;
+    temperature?: number;
+    trace?: CapabilityTraceSink;
+};
+export type RubricJudgeRunOptions = {
+    signal?: AbortSignal;
+};
+export declare class RubricJudge {
+    private readonly model;
+    private readonly rubric;
+    private readonly capabilityId;
+    private readonly maxTokens;
+    private readonly temperature?;
+    private readonly trace?;
+    constructor(options: RubricJudgeOptions);
+    judge(input: RubricJudgeInput, options?: RubricJudgeRunOptions): Promise<StructuredGenerationResult<RubricJudgment>>;
+}
+export declare function buildRubricJudgeSystemPrompt(rubric: RubricDefinition): string;
+export declare function buildRubricJudgeUserPrompt(input: RubricJudgeInput): string;
+export declare function createRubricJudgmentValidator(rubric: RubricDefinition): (value: unknown) => JsonValidation<RubricJudgment>;

package/node_modules/@aptkit/evals/dist/src/rubric-judge.js

@@ -0,0 +1,154 @@
+import { generateStructured, } from '@aptkit/runtime';
+export class RubricJudge {
+    model;
+    rubric;
+    capabilityId;
+    maxTokens;
+    temperature;
+    trace;
+    constructor(options) {
+        this.model = options.model;
+        this.rubric = options.rubric;
+        this.capabilityId = options.capabilityId ?? 'rubric-judge';
+        this.maxTokens = options.maxTokens ?? 1200;
+        this.temperature = options.temperature;
+        this.trace = options.trace;
+    }
+    judge(input, options = {}) {
+        return generateStructured({
+            capabilityId: this.capabilityId,
+            model: this.model,
+            system: buildRubricJudgeSystemPrompt(this.rubric),
+            userPrompt: buildRubricJudgeUserPrompt(input),
+            validate: createRubricJudgmentValidator(this.rubric),
+            maxTokens: this.maxTokens,
+            temperature: this.temperature,
+            trace: this.trace,
+            signal: options.signal,
+        });
+    }
+}
+export function buildRubricJudgeSystemPrompt(rubric) {
+    const dimensions = rubric.dimensions
+        .map((dimension) => {
+        const scale = dimension.scale
+            .map((level) => `  ${level.score} = ${level.description}`)
+            .join('\n');
+        return `${dimension.id} ${dimension.label}: ${dimension.description}\n${scale}`;
+    })
+        .join('\n\n');
+    const verdicts = rubric.verdicts
+        .map((rule) => `- ${rule.verdict}: ${rule.description}`)
+        .join('\n');
+    const checks = rubric.checks?.length
+        ? `\nChecks to return as booleans:\n${rubric.checks.map((check) => `- ${check}`).join('\n')}\n`
+        : '';
+    const examples = rubric.calibrationExamples?.length
+        ? `\nCalibration examples. Use these only to anchor the scoring scale; do not repeat them.\n${rubric.calibrationExamples
+            .map((example) => `Input:\n${example.input}\nExpected:\n${example.expected}`)
+            .join('\n\n')}\n`
+        : '';
+    const dimensionShape = Object.fromEntries(rubric.dimensions.map((dimension) => [dimension.id, { score: 0, reason: '' }]));
+    const checkShape = Object.fromEntries((rubric.checks ?? []).map((check) => [check, true]));
+    const outputShape = {
+        dimensions: dimensionShape,
+        ...(rubric.checks?.length ? { checks: checkShape } : {}),
+        verdict: rubric.verdicts[0]?.verdict ?? 'pass',
+        fix: '',
+        reasoning: '',
+    };
+    return [
+        `You are a rubric judge for: ${rubric.title}.`,
+        rubric.task,
+        '',
+        'Score the subject against the rubric. Score meaning and evidence, not style preferences unless the rubric asks for style.',
+        'Never rewrite the subject. Return one highest-leverage fix, not a list.',
+        '',
+        'Rubric dimensions:',
+        dimensions,
+        '',
+        'Allowed verdicts:',
+        verdicts,
+        checks.trimEnd(),
+        examples.trimEnd(),
+        '',
+        'Output JSON only. No prose. No markdown fences. Use exactly this shape:',
+        JSON.stringify(outputShape),
+    ].filter(Boolean).join('\n');
+}
+export function buildRubricJudgeUserPrompt(input) {
+    const context = input.context && Object.keys(input.context).length > 0
+        ? `Context:\n${Object.entries(input.context).map(([key, value]) => `${key}: ${value}`).join('\n')}\n\n`
+        : '';
+    return `${context}Subject:\n${input.subject}`;
+}
+export function createRubricJudgmentValidator(rubric) {
+    const dimensionIds = new Set(rubric.dimensions.map((dimension) => dimension.id));
+    const verdicts = new Set(rubric.verdicts.map((rule) => rule.verdict));
+    const scoreRanges = new Map(rubric.dimensions.map((dimension) => [
+        dimension.id,
+        {
+            min: Math.min(...dimension.scale.map((level) => level.score)),
+            max: Math.max(...dimension.scale.map((level) => level.score)),
+        },
+    ]));
+    return (value) => {
+        if (!isRecord(value))
+            return { ok: false, error: 'judgment must be an object' };
+        if (!isRecord(value.dimensions))
+            return { ok: false, error: 'judgment.dimensions must be an object' };
+        const dimensions = {};
+        for (const id of dimensionIds) {
+            const score = value.dimensions[id];
+            if (!isRecord(score))
+                return { ok: false, error: `dimensions.${id} must be an object` };
+            if (typeof score.score !== 'number')
+                return { ok: false, error: `dimensions.${id}.score must be a number` };
+            if (typeof score.reason !== 'string')
+                return { ok: false, error: `dimensions.${id}.reason must be a string` };
+            const range = scoreRanges.get(id);
+            if (range && (score.score < range.min || score.score > range.max)) {
+                return { ok: false, error: `dimensions.${id}.score must be between ${range.min} and ${range.max}` };
+            }
+            dimensions[id] = { score: score.score, reason: score.reason.trim() };
+        }
+        if (typeof value.verdict !== 'string' || !verdicts.has(value.verdict)) {
+            return { ok: false, error: 'judgment.verdict is not allowed by the rubric' };
+        }
+        if (typeof value.fix !== 'string')
+            return { ok: false, error: 'judgment.fix must be a string' };
+        if (value.reasoning !== undefined && typeof value.reasoning !== 'string') {
+            return { ok: false, error: 'judgment.reasoning must be a string when present' };
+        }
+        const checks = validateChecks(value.checks, rubric.checks);
+        if (!checks.ok)
+            return checks;
+        return {
+            ok: true,
+            value: {
+                dimensions,
+                ...(checks.value ? { checks: checks.value } : {}),
+                verdict: value.verdict,
+                fix: value.fix.trim(),
+                ...(value.reasoning ? { reasoning: value.reasoning.trim() } : {}),
+            },
+        };
+    };
+}
+function validateChecks(value, expectedChecks) {
+    if (!expectedChecks?.length)
+        return { ok: true, value: undefined };
+    if (!isRecord(value))
+        return { ok: false, error: 'judgment.checks must be an object' };
+    const checks = {};
+    for (const check of expectedChecks) {
+        if (typeof value[check] !== 'boolean') {
+            return { ok: false, error: `checks.${check} must be a boolean` };
+        }
+        checks[check] = value[check];
+    }
+    return { ok: true, value: checks };
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/node_modules/@aptkit/evals/package.json

@@ -21,6 +21,9 @@
     "build": "tsc -p tsconfig.json",
     "test": "npm run build && node --test dist/test/*.test.js"
   },
+  "dependencies": {
+    "@aptkit/runtime": "0.0.0"
+  },
   "devDependencies": {
     "@types/node": "^20.0.0"
   }

package/node_modules/@aptkit/runtime/dist/src/index.d.ts

@@ -3,4 +3,5 @@ export * from './json-output.js';
 export * from './model-provider.js';
 export * from './ndjson-stream.js';
 export * from './run-agent-loop.js';
+export * from './structured-generation.js';
 export * from './usage-ledger.js';

package/node_modules/@aptkit/runtime/dist/src/index.js

@@ -3,4 +3,5 @@ export * from './json-output.js';
 export * from './model-provider.js';
 export * from './ndjson-stream.js';
 export * from './run-agent-loop.js';
+export * from './structured-generation.js';
 export * from './usage-ledger.js';

package/node_modules/@aptkit/runtime/dist/src/structured-generation.d.ts

@@ -0,0 +1,43 @@
+import { type CapabilityTraceSink } from './events.js';
+import { type JsonValidator } from './json-output.js';
+import type { ModelMessage, ModelProvider } from './model-provider.js';
+export type StructuredGenerationAttempt = {
+    attempt: number;
+    rawText?: string;
+    error?: string;
+};
+export type StructuredGenerationSuccess<T> = {
+    ok: true;
+    value: T;
+    rawText: string;
+    attempts: StructuredGenerationAttempt[];
+};
+export type StructuredGenerationFailure = {
+    ok: false;
+    error: string;
+    attempts: StructuredGenerationAttempt[];
+};
+export type StructuredGenerationResult<T> = StructuredGenerationSuccess<T> | StructuredGenerationFailure;
+export type StructuredGenerationRetryOptions = {
+    maxAttempts?: number;
+    strictSuffix?: string;
+};
+export type GenerateStructuredOptions<T> = {
+    capabilityId: string;
+    model: ModelProvider;
+    validate: JsonValidator<T>;
+    system?: string;
+    messages?: ModelMessage[];
+    userPrompt?: string;
+    maxTokens?: number;
+    temperature?: number;
+    retry?: StructuredGenerationRetryOptions;
+    trace?: CapabilityTraceSink;
+    signal?: AbortSignal;
+};
+/**
+ * Runs a JSON-producing model prompt with bounded parse/validation retries.
+ * This is the provider-neutral version of Dryrun's on-device JSON pipeline:
+ * generate, extract JSON, validate, retry once with a strict JSON-only nudge.
+ */
+export declare function generateStructured<T>(options: GenerateStructuredOptions<T>): Promise<StructuredGenerationResult<T>>;

package/node_modules/@aptkit/runtime/dist/src/structured-generation.js

@@ -0,0 +1,109 @@
+import { timestamp } from './events.js';
+import { parseValidatedJson } from './json-output.js';
+const DEFAULT_STRICT_SUFFIX = '\n\nReturn ONLY valid JSON - no prose, no markdown fences.';
+/**
+ * Runs a JSON-producing model prompt with bounded parse/validation retries.
+ * This is the provider-neutral version of Dryrun's on-device JSON pipeline:
+ * generate, extract JSON, validate, retry once with a strict JSON-only nudge.
+ */
+export async function generateStructured(options) {
+    const maxAttempts = Math.max(1, options.retry?.maxAttempts ?? 2);
+    const strictSuffix = options.retry?.strictSuffix ?? DEFAULT_STRICT_SUFFIX;
+    const baseMessages = normalizeMessages(options);
+    const attempts = [];
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        options.signal?.throwIfAborted();
+        const messages = attempt === 1 ? baseMessages : appendStrictSuffix(baseMessages, strictSuffix);
+        let response;
+        try {
+            response = await options.model.complete({
+                system: options.system,
+                messages,
+                maxTokens: options.maxTokens,
+                temperature: options.temperature,
+                signal: options.signal,
+            });
+        }
+        catch (error) {
+            if (isAbortError(error) || options.signal?.aborted)
+                throw error;
+            const message = error instanceof Error ? error.message : String(error);
+            attempts.push({ attempt, error: message });
+            emitWarning(options, `structured generation model call failed on attempt ${attempt}: ${message}`);
+            return { ok: false, error: message, attempts };
+        }
+        emitUsage(options, response);
+        const rawText = textFromResponse(response);
+        const parsed = parseValidatedJson(rawText, options.validate);
+        if (parsed.ok) {
+            attempts.push({ attempt, rawText });
+            return { ok: true, value: parsed.value, rawText, attempts };
+        }
+        attempts.push({ attempt, rawText, error: parsed.error });
+        if (attempt < maxAttempts) {
+            emitWarning(options, `structured generation validation failed on attempt ${attempt}: ${parsed.error}`);
+        }
+    }
+    const error = attempts[attempts.length - 1]?.error ?? 'structured generation failed';
+    emitError(options, `structured generation failed after ${maxAttempts} attempt${maxAttempts === 1 ? '' : 's'}: ${error}`);
+    return { ok: false, error, attempts };
+}
+function normalizeMessages(options) {
+    if (options.messages?.length)
+        return [...options.messages];
+    if (options.userPrompt !== undefined)
+        return [{ role: 'user', content: options.userPrompt }];
+    throw new Error('generateStructured requires messages or userPrompt');
+}
+function appendStrictSuffix(messages, strictSuffix) {
+    const next = [...messages];
+    for (let index = next.length - 1; index >= 0; index -= 1) {
+        const message = next[index];
+        if (message.role === 'user' && typeof message.content === 'string') {
+            next[index] = { ...message, content: `${message.content}${strictSuffix}` };
+            return next;
+        }
+    }
+    next.push({ role: 'user', content: strictSuffix.trim() });
+    return next;
+}
+function textFromResponse(response) {
+    return response.content
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('');
+}
+function emitUsage(options, response) {
+    if (!response.usage)
+        return;
+    options.trace?.emit({
+        type: 'model_usage',
+        capabilityId: options.capabilityId,
+        provider: options.model.id,
+        model: response.model ?? options.model.defaultModel ?? 'unknown',
+        inputTokens: response.usage.inputTokens,
+        outputTokens: response.usage.outputTokens,
+        estimated: response.usage.estimated,
+        timestamp: timestamp(),
+    });
+}
+function emitWarning(options, message) {
+    options.trace?.emit({
+        type: 'warning',
+        capabilityId: options.capabilityId,
+        message,
+        timestamp: timestamp(),
+    });
+}
+function emitError(options, message) {
+    options.trace?.emit({
+        type: 'error',
+        capabilityId: options.capabilityId,
+        message,
+        timestamp: timestamp(),
+    });
+}
+function isAbortError(error) {
+    return error instanceof DOMException && error.name === 'AbortError'
+        || error instanceof Error && error.name === 'AbortError';
+}

package/node_modules/@aptkit/workflows/README.md

@@ -0,0 +1,6 @@
+# @aptkit/workflows
+
+Reusable workflow orchestration helpers for AptKit capabilities.
+
+This package owns deterministic workflow mechanics only. Host apps provide
+storage, domain prompts, model providers, and output card shapes.

package/node_modules/@aptkit/workflows/dist/src/content-generation-workflow.d.ts

@@ -0,0 +1,58 @@
+import { type CapabilityTraceSink } from '@aptkit/runtime';
+import { type MarkdownSection } from './markdown-sections.js';
+export type ContentAngle = {
+    id: string;
+    label: string;
+};
+export type ExistingContentVariant = {
+    sourceHash: string;
+    variantIndex: number;
+};
+export type ContentVariantPlan = {
+    sourceHash: string;
+    variantIndex: number;
+    sectionIndex: number;
+    totalSections: number;
+    section: MarkdownSection;
+    angle: ContentAngle;
+};
+export type GeneratedContentVariant<T> = ContentVariantPlan & {
+    item: T;
+};
+export type ContentGenerator<T> = (plan: ContentVariantPlan, options?: {
+    signal?: AbortSignal;
+    trace?: CapabilityTraceSink;
+}) => Promise<T | null>;
+export type EnsureGeneratedContentOptions<TExisting extends ExistingContentVariant, TGenerated> = {
+    capabilityId?: string;
+    sourceMarkdown: string;
+    sourceHash: string;
+    existing: readonly TExisting[];
+    targetCount?: number;
+    angles: readonly ContentAngle[];
+    maxSkips?: number;
+    generator: ContentGenerator<TGenerated>;
+    trace?: CapabilityTraceSink;
+    signal?: AbortSignal;
+};
+export type EnsureGeneratedContentResult<TExisting extends ExistingContentVariant, TGenerated> = {
+    freshExisting: TExisting[];
+    staleExisting: TExisting[];
+    generated: GeneratedContentVariant<TGenerated>[];
+    items: Array<TExisting | GeneratedContentVariant<TGenerated>>;
+    attempted: ContentVariantPlan[];
+    skipped: ContentVariantPlan[];
+};
+/**
+ * Ensures a source document has enough generated variants for the current hash.
+ *
+ * The host owns persistence. This helper returns fresh existing variants,
+ * stale variants to invalidate, and newly generated variants to save.
+ */
+export declare function ensureGeneratedContent<TExisting extends ExistingContentVariant, TGenerated>(options: EnsureGeneratedContentOptions<TExisting, TGenerated>): Promise<EnsureGeneratedContentResult<TExisting, TGenerated>>;
+export declare function planContentVariant(options: {
+    sourceHash: string;
+    variantIndex: number;
+    sections: readonly MarkdownSection[];
+    angles: readonly ContentAngle[];
+}): ContentVariantPlan;

package/node_modules/@aptkit/workflows/dist/src/content-generation-workflow.js

@@ -0,0 +1,93 @@
+import { timestamp } from '@aptkit/runtime';
+import { splitMarkdownSections } from './markdown-sections.js';
+const DEFAULT_TARGET_COUNT = 4;
+const DEFAULT_MAX_SKIPS = 3;
+/**
+ * Ensures a source document has enough generated variants for the current hash.
+ *
+ * The host owns persistence. This helper returns fresh existing variants,
+ * stale variants to invalidate, and newly generated variants to save.
+ */
+export async function ensureGeneratedContent(options) {
+    options.signal?.throwIfAborted();
+    if (options.angles.length === 0)
+        throw new Error('ensureGeneratedContent requires at least one angle');
+    const capabilityId = options.capabilityId ?? 'content-generation-workflow';
+    const targetCount = Math.max(0, options.targetCount ?? DEFAULT_TARGET_COUNT);
+    const maxSkips = Math.max(0, options.maxSkips ?? DEFAULT_MAX_SKIPS);
+    const sections = splitMarkdownSections(options.sourceMarkdown);
+    const freshExisting = options.existing
+        .filter((item) => item.sourceHash === options.sourceHash)
+        .sort((a, b) => a.variantIndex - b.variantIndex);
+    const staleExisting = options.existing
+        .filter((item) => item.sourceHash !== options.sourceHash)
+        .sort((a, b) => a.variantIndex - b.variantIndex);
+    if (targetCount === 0 || sections.length === 0 || freshExisting.length >= targetCount) {
+        return {
+            freshExisting,
+            staleExisting,
+            generated: [],
+            items: freshExisting,
+            attempted: [],
+            skipped: [],
+        };
+    }
+    const needed = targetCount - freshExisting.length;
+    const baseIndex = (freshExisting.at(-1)?.variantIndex ?? -1) + 1;
+    const lastIndex = baseIndex + needed + maxSkips;
+    const generated = [];
+    const attempted = [];
+    const skipped = [];
+    for (let variantIndex = baseIndex; generated.length < needed && variantIndex < lastIndex; variantIndex += 1) {
+        options.signal?.throwIfAborted();
+        const plan = planContentVariant({
+            sourceHash: options.sourceHash,
+            variantIndex,
+            sections,
+            angles: options.angles,
+        });
+        attempted.push(plan);
+        options.trace?.emit({
+            type: 'step',
+            capabilityId,
+            role: 'workflow',
+            content: `generating ${plan.angle.label} for section ${plan.sectionIndex + 1} of ${plan.totalSections}`,
+            timestamp: timestamp(),
+        });
+        const item = await options.generator(plan, { signal: options.signal, trace: options.trace });
+        if (item === null) {
+            skipped.push(plan);
+            options.trace?.emit({
+                type: 'warning',
+                capabilityId,
+                message: `content variant ${variantIndex} produced no usable output; trying next variant`,
+                timestamp: timestamp(),
+            });
+            continue;
+        }
+        generated.push({ ...plan, item });
+    }
+    return {
+        freshExisting,
+        staleExisting,
+        generated,
+        items: [...freshExisting, ...generated],
+        attempted,
+        skipped,
+    };
+}
+export function planContentVariant(options) {
+    if (options.sections.length === 0)
+        throw new Error('planContentVariant requires at least one section');
+    if (options.angles.length === 0)
+        throw new Error('planContentVariant requires at least one angle');
+    const sectionIndex = options.variantIndex % options.sections.length;
+    return {
+        sourceHash: options.sourceHash,
+        variantIndex: options.variantIndex,
+        sectionIndex,
+        totalSections: options.sections.length,
+        section: options.sections[sectionIndex],
+        angle: options.angles[options.variantIndex % options.angles.length],
+    };
+}

package/node_modules/@aptkit/workflows/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './content-generation-workflow.js';
+export * from './markdown-sections.js';

package/node_modules/@aptkit/workflows/dist/src/index.js

@@ -0,0 +1,2 @@
+export * from './content-generation-workflow.js';
+export * from './markdown-sections.js';

package/node_modules/@aptkit/workflows/dist/src/markdown-sections.d.ts

@@ -0,0 +1,9 @@
+export type MarkdownSection = {
+    heading?: string;
+    content: string;
+};
+/**
+ * Splits markdown into ordered sections by h2 (`##`) headings. H3+ headings
+ * stay inside the current section, matching Dryrun's source-document workflow.
+ */
+export declare function splitMarkdownSections(markdown: string): MarkdownSection[];

package/node_modules/@aptkit/workflows/dist/src/markdown-sections.js

@@ -0,0 +1,32 @@
+/**
+ * Splits markdown into ordered sections by h2 (`##`) headings. H3+ headings
+ * stay inside the current section, matching Dryrun's source-document workflow.
+ */
+export function splitMarkdownSections(markdown) {
+    if (markdown.trim().length === 0)
+        return [];
+    const sections = [];
+    let heading;
+    let body = [];
+    function flush() {
+        const content = body.join('\n').trim();
+        if (content.length > 0 || heading !== undefined) {
+            sections.push(heading === undefined ? { content } : { heading, content });
+        }
+        body = [];
+    }
+    for (const line of markdown.split(/\r?\n/)) {
+        const trimmed = line.trimStart();
+        if (trimmed.startsWith('## ') && !trimmed.startsWith('### ')) {
+            flush();
+            heading = trimmed.slice(3).trim();
+        }
+        else {
+            body.push(line);
+        }
+    }
+    flush();
+    if (sections.length === 0)
+        return [{ content: markdown.trim() }];
+    return sections;
+}

package/node_modules/@aptkit/{provider-synthetic → workflows}/package.json

@@ -1,10 +1,11 @@
 {
-  "name": "@aptkit/provider-synthetic",
+  "name": "@aptkit/workflows",
   "version": "0.0.0",
   "type": "module",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "files": [
+    "README.md",
     "dist/src"
   ],
   "exports": {
@@ -18,9 +19,7 @@
     "test": "npm run build && node --test dist/test/*.test.js"
   },
   "dependencies": {
-    "@aptkit/context": "0.0.0",
-    "@aptkit/runtime": "0.0.0",
-    "@aptkit/tools": "0.0.0"
+    "@aptkit/runtime": "0.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rlynjb/aptkit-core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "Standalone AptKit core bundle for extracted agent capabilities.",
   "main": "./dist/src/index.js",
@@ -25,7 +25,7 @@
     }
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -b tsconfig.json",
     "test": "npm run build && node --test dist/test/*.test.js"
   },
   "dependencies": {
@@ -36,9 +36,9 @@
     "@aptkit/context": "0.0.0",
     "@aptkit/evals": "0.0.0",
     "@aptkit/prompts": "0.0.0",
-    "@aptkit/provider-synthetic": "0.0.0",
     "@aptkit/runtime": "0.0.0",
-    "@aptkit/tools": "0.0.0"
+    "@aptkit/tools": "0.0.0",
+    "@aptkit/workflows": "0.0.0"
   },
   "bundledDependencies": [
     "@aptkit/agent-anomaly-monitoring",
@@ -48,8 +48,8 @@
     "@aptkit/context",
     "@aptkit/evals",
     "@aptkit/prompts",
-    "@aptkit/provider-synthetic",
     "@aptkit/runtime",
-    "@aptkit/tools"
+    "@aptkit/tools",
+    "@aptkit/workflows"
   ]
 }

package/node_modules/@aptkit/provider-synthetic/dist/src/fixture-data-source.d.ts

@@ -1,18 +0,0 @@
-import type { WorkspaceDescriptor } from '@aptkit/context';
-import type { AnomalyContextArgs, AnomalyContextResult, MetricTimeseriesArgs, MetricTimeseriesResult, ProjectOverview, SyntheticEcommerceDataSource } from './types.js';
-export declare const syntheticEcommerceWorkspace: WorkspaceDescriptor;
-export type FixtureSyntheticEcommerceDataSourceOptions = {
-    scenarioId?: string;
-    workspace?: WorkspaceDescriptor;
-};
-/** Deterministic synthetic ecommerce data source for Studio, tests, and repeatable demos. */
-export declare class FixtureSyntheticEcommerceDataSource implements SyntheticEcommerceDataSource {
-    readonly mode: "fixture";
-    readonly scenarioId: string;
-    readonly workspace: WorkspaceDescriptor;
-    constructor(options?: FixtureSyntheticEcommerceDataSourceOptions);
-    getProjectOverview(): ProjectOverview;
-    getMetricTimeseries(args?: MetricTimeseriesArgs): MetricTimeseriesResult;
-    getAnomalyContext(args?: AnomalyContextArgs): AnomalyContextResult;
-    private providerMetadata;
-}

package/node_modules/@aptkit/provider-synthetic/dist/src/fixture-data-source.js

@@ -1,120 +0,0 @@
-const DEFAULT_RECENT_WINDOW = { from: '2026-05-04', to: '2026-06-01' };
-const DEFAULT_BASELINE_WINDOW = { from: '2026-02-09', to: '2026-05-04' };
-export const syntheticEcommerceWorkspace = {
-    projectId: 'synthetic-ecommerce',
-    projectName: 'Synthetic ecommerce analytics workspace',
-    events: [
-        { name: 'purchase', properties: ['state', 'category', 'payment_type', 'total_price'], eventCount: 50000 },
-        { name: 'session_start', properties: ['utm_source', 'device'], eventCount: 80000 },
-        { name: 'checkout', properties: ['state', 'payment_type'], eventCount: 35000 },
-        { name: 'view_item', properties: ['category'], eventCount: 120000 },
-    ],
-    customerProperties: ['state', 'city', 'loyalty_tier'],
-    catalogs: [{ id: 'products', name: 'Products' }],
-    totalCustomers: 125000,
-    totalEvents: 285000,
-    oldestTimestamp: Date.UTC(2025, 11, 1),
-    dataHorizon: { from: '2025-12-01', to: '2026-06-01', durationDays: 182 },
-};
-/** Deterministic synthetic ecommerce data source for Studio, tests, and repeatable demos. */
-export class FixtureSyntheticEcommerceDataSource {
-    mode = 'fixture';
-    scenarioId;
-    workspace;
-    constructor(options = {}) {
-        this.scenarioId = options.scenarioId ?? 'sp-revenue-drop';
-        this.workspace = options.workspace ?? syntheticEcommerceWorkspace;
-    }
-    getProjectOverview() {
-        return {
-            provider: this.providerMetadata(),
-            workspace: this.workspace,
-            highlights: [
-                'SP revenue is down 30.0245% over the recent four-week window.',
-                'RJ and MG remain approximately flat, making the movement region-specific.',
-                'The fixture is deterministic and safe for replay promotion.',
-            ],
-        };
-    }
-    getMetricTimeseries(args = {}) {
-        const metric = args.metric ?? 'revenue';
-        const dimension = args.dimension ?? 'state';
-        const segment = args.segment ?? 'SP';
-        const recentWindow = requiredRange(args.time_range, DEFAULT_RECENT_WINDOW);
-        return {
-            provider: this.providerMetadata(),
-            periodComparison: {
-                metric,
-                dimension,
-                segment,
-                recentWindow,
-                baselineWindow: DEFAULT_BASELINE_WINDOW,
-                recentValue: 28550000,
-                baselineAverage: 40800000,
-                pctChange: -0.300245,
-                relatedSegments: [
-                    { name: 'RJ', pctChange: -0.02 },
-                    { name: 'MG', pctChange: 0.01 },
-                ],
-            },
-            points: [
-                { ts: '2026-05-04', segment: 'SP', value: 7400000 },
-                { ts: '2026-05-11', segment: 'SP', value: 7200000 },
-                { ts: '2026-05-18', segment: 'SP', value: 7050000 },
-                { ts: '2026-05-25', segment: 'SP', value: 6900000 },
-                { ts: '2026-05-04', segment: 'RJ', value: 4300000 },
-                { ts: '2026-05-11', segment: 'RJ', value: 4350000 },
-                { ts: '2026-05-04', segment: 'MG', value: 3900000 },
-                { ts: '2026-05-11', segment: 'MG', value: 3940000 },
-            ],
-            totalCount: 4200,
-        };
-    }
-    getAnomalyContext(args = {}) {
-        const metric = args.metric ?? 'revenue';
-        const segment = args.segment ?? 'SP';
-        return {
-            provider: this.providerMetadata(),
-            anomaly_summary: {
-                metric,
-                segment,
-                anomaly_value: 28550000,
-                baseline_avg: 40800000,
-                pct_change: -0.300245,
-            },
-            related_segments: [
-                { name: 'RJ', pct_change: -0.02 },
-                { name: 'MG', pct_change: 0.01 },
-            ],
-            drivers: [
-                {
-                    name: 'electronics',
-                    contribution: -0.62,
-                    detail: 'Electronics orders in SP account for most of the recent revenue loss.',
-                },
-                {
-                    name: 'paid_search',
-                    contribution: -0.21,
-                    detail: 'Paid search sessions declined during the same window.',
-                },
-            ],
-            sample_orders: [
-                { order_id: 'syn-sp-101', purchase_ts: '2026-05-10', status: 'delivered', price_brl: 42000 },
-                { order_id: 'syn-sp-102', purchase_ts: '2026-05-23', status: 'delivered', price_brl: 31000 },
-            ],
-        };
-    }
-    providerMetadata() {
-        return {
-            id: 'synthetic-ecommerce',
-            mode: this.mode,
-            scenarioId: this.scenarioId,
-        };
-    }
-}
-function requiredRange(input, fallback) {
-    return {
-        from: input?.from ?? fallback.from,
-        to: input?.to ?? fallback.to,
-    };
-}

package/node_modules/@aptkit/provider-synthetic/dist/src/index.d.ts

@@ -1,5 +0,0 @@
-export * from './fixture-data-source.js';
-export * from './openai-synthetic-data-source.js';
-export * from './tool-definitions.js';
-export * from './tool-registry.js';
-export * from './types.js';

package/node_modules/@aptkit/provider-synthetic/dist/src/index.js

@@ -1,5 +0,0 @@
-export * from './fixture-data-source.js';
-export * from './openai-synthetic-data-source.js';
-export * from './tool-definitions.js';
-export * from './tool-registry.js';
-export * from './types.js';

package/node_modules/@aptkit/provider-synthetic/dist/src/openai-synthetic-data-source.d.ts

@@ -1,22 +0,0 @@
-import { type ModelProvider } from '@aptkit/runtime';
-import type { AnomalyContextArgs, AnomalyContextResult, MetricTimeseriesArgs, MetricTimeseriesResult, ProjectOverview, SyntheticEcommerceDataSource } from './types.js';
-import type { WorkspaceDescriptor } from '@aptkit/context';
-export type OpenAISyntheticEcommerceDataSourceOptions = {
-    model: ModelProvider;
-    scenarioId?: string;
-    workspace?: WorkspaceDescriptor;
-    systemPrompt?: string;
-};
-/** Model-backed synthetic data source. Use with OpenAIModelProvider or any ModelProvider adapter. */
-export declare class OpenAISyntheticEcommerceDataSource implements SyntheticEcommerceDataSource {
-    readonly mode: "openai";
-    readonly scenarioId: string;
-    readonly workspace: WorkspaceDescriptor;
-    private readonly model;
-    private readonly systemPrompt;
-    constructor(options: OpenAISyntheticEcommerceDataSourceOptions);
-    getProjectOverview(): Promise<ProjectOverview>;
-    getMetricTimeseries(args?: MetricTimeseriesArgs): Promise<MetricTimeseriesResult>;
-    getAnomalyContext(args?: AnomalyContextArgs): Promise<AnomalyContextResult>;
-    private completeJson;
-}

package/node_modules/@aptkit/provider-synthetic/dist/src/openai-synthetic-data-source.js

@@ -1,181 +0,0 @@
-import { parseAgentJson } from '@aptkit/runtime';
-import { syntheticEcommerceWorkspace } from './fixture-data-source.js';
-/** Model-backed synthetic data source. Use with OpenAIModelProvider or any ModelProvider adapter. */
-export class OpenAISyntheticEcommerceDataSource {
-    mode = 'openai';
-    scenarioId;
-    workspace;
-    model;
-    systemPrompt;
-    constructor(options) {
-        this.model = options.model;
-        this.scenarioId = options.scenarioId ?? 'sp-revenue-drop';
-        this.workspace = options.workspace ?? syntheticEcommerceWorkspace;
-        this.systemPrompt = options.systemPrompt ?? [
-            'You generate synthetic ecommerce analytics tool results for AptKit.',
-            'Return only JSON. Do not include prose or markdown fences.',
-            'Keep outputs internally consistent for the requested scenario and workspace.',
-            'Always include provider metadata: {"id":"synthetic-ecommerce","mode":"openai","scenarioId": string}.',
-        ].join('\n');
-    }
-    async getProjectOverview() {
-        const value = await this.completeJson('get_project_overview', {});
-        return assertProjectOverview(value, this.scenarioId);
-    }
-    async getMetricTimeseries(args = {}) {
-        const value = await this.completeJson('get_metric_timeseries', args);
-        return assertMetricTimeseries(value, this.scenarioId);
-    }
-    async getAnomalyContext(args = {}) {
-        const value = await this.completeJson('get_anomaly_context', args);
-        return assertAnomalyContext(value, this.scenarioId);
-    }
-    async completeJson(toolName, args) {
-        const response = await this.model.complete({
-            system: this.systemPrompt,
-            messages: [
-                {
-                    role: 'user',
-                    content: JSON.stringify({
-                        toolName,
-                        scenarioId: this.scenarioId,
-                        workspace: this.workspace,
-                        args,
-                    }),
-                },
-            ],
-            maxTokens: 1400,
-            temperature: 0.2,
-        });
-        const text = response.content
-            .filter((block) => block.type === 'text')
-            .map((block) => block.text)
-            .join('\n');
-        return parseAgentJson(text);
-    }
-}
-function assertProjectOverview(value, scenarioId) {
-    const object = assertObject(value, 'project overview');
-    if (!isObject(object.workspace))
-        throw new Error('project overview workspace is missing');
-    return {
-        provider: providerMetadata(object.provider, scenarioId, 'openai'),
-        workspace: object.workspace,
-        highlights: stringArray(object.highlights, 'highlights'),
-    };
-}
-function assertMetricTimeseries(value, scenarioId) {
-    const object = assertObject(value, 'metric timeseries');
-    const comparison = assertObject(object.periodComparison, 'periodComparison');
-    return {
-        provider: providerMetadata(object.provider, scenarioId, 'openai'),
-        periodComparison: {
-            metric: stringValue(comparison.metric, 'periodComparison.metric'),
-            dimension: stringValue(comparison.dimension, 'periodComparison.dimension'),
-            segment: stringValue(comparison.segment, 'periodComparison.segment'),
-            recentWindow: timeRange(comparison.recentWindow, 'periodComparison.recentWindow'),
-            baselineWindow: timeRange(comparison.baselineWindow, 'periodComparison.baselineWindow'),
-            recentValue: numberValue(comparison.recentValue, 'periodComparison.recentValue'),
-            baselineAverage: numberValue(comparison.baselineAverage, 'periodComparison.baselineAverage'),
-            pctChange: numberValue(comparison.pctChange, 'periodComparison.pctChange'),
-            relatedSegments: relatedSegments(comparison.relatedSegments),
-        },
-        points: metricPoints(object.points),
-        totalCount: numberValue(object.totalCount, 'totalCount'),
-    };
-}
-function assertAnomalyContext(value, scenarioId) {
-    const object = assertObject(value, 'anomaly context');
-    const summary = assertObject(object.anomaly_summary, 'anomaly_summary');
-    return {
-        provider: providerMetadata(object.provider, scenarioId, 'openai'),
-        anomaly_summary: {
-            metric: stringValue(summary.metric, 'anomaly_summary.metric'),
-            segment: stringValue(summary.segment, 'anomaly_summary.segment'),
-            anomaly_value: numberValue(summary.anomaly_value, 'anomaly_summary.anomaly_value'),
-            baseline_avg: numberValue(summary.baseline_avg, 'anomaly_summary.baseline_avg'),
-            pct_change: numberValue(summary.pct_change, 'anomaly_summary.pct_change'),
-        },
-        related_segments: relatedSegments(object.related_segments).map((segment) => ({
-            name: segment.name,
-            pct_change: segment.pctChange,
-        })),
-        drivers: arrayValue(object.drivers, 'drivers').map((driver, index) => {
-            const objectDriver = assertObject(driver, `drivers.${index}`);
-            return {
-                name: stringValue(objectDriver.name, `drivers.${index}.name`),
-                contribution: numberValue(objectDriver.contribution, `drivers.${index}.contribution`),
-                detail: stringValue(objectDriver.detail, `drivers.${index}.detail`),
-            };
-        }),
-        sample_orders: arrayValue(object.sample_orders, 'sample_orders').map((order, index) => {
-            const objectOrder = assertObject(order, `sample_orders.${index}`);
-            return {
-                order_id: stringValue(objectOrder.order_id, `sample_orders.${index}.order_id`),
-                purchase_ts: stringValue(objectOrder.purchase_ts, `sample_orders.${index}.purchase_ts`),
-                status: stringValue(objectOrder.status, `sample_orders.${index}.status`),
-                price_brl: numberValue(objectOrder.price_brl, `sample_orders.${index}.price_brl`),
-            };
-        }),
-    };
-}
-function providerMetadata(value, scenarioId, mode) {
-    const provider = isObject(value) ? value : {};
-    return {
-        id: 'synthetic-ecommerce',
-        mode,
-        scenarioId: typeof provider.scenarioId === 'string' ? provider.scenarioId : scenarioId,
-    };
-}
-function relatedSegments(value) {
-    return arrayValue(value, 'relatedSegments').map((segment, index) => {
-        const object = assertObject(segment, `relatedSegments.${index}`);
-        return {
-            name: stringValue(object.name, `relatedSegments.${index}.name`),
-            pctChange: numberValue(object.pctChange ?? object.pct_change, `relatedSegments.${index}.pctChange`),
-        };
-    });
-}
-function metricPoints(value) {
-    return arrayValue(value, 'points').map((point, index) => {
-        const object = assertObject(point, `points.${index}`);
-        return {
-            ts: stringValue(object.ts, `points.${index}.ts`),
-            segment: stringValue(object.segment, `points.${index}.segment`),
-            value: numberValue(object.value, `points.${index}.value`),
-        };
-    });
-}
-function timeRange(value, path) {
-    const object = assertObject(value, path);
-    return {
-        from: stringValue(object.from, `${path}.from`),
-        to: stringValue(object.to, `${path}.to`),
-    };
-}
-function assertObject(value, path) {
-    if (!isObject(value))
-        throw new Error(`${path} must be an object`);
-    return value;
-}
-function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function arrayValue(value, path) {
-    if (!Array.isArray(value))
-        throw new Error(`${path} must be an array`);
-    return value;
-}
-function stringArray(value, path) {
-    return arrayValue(value, path).map((item, index) => stringValue(item, `${path}.${index}`));
-}
-function stringValue(value, path) {
-    if (typeof value !== 'string')
-        throw new Error(`${path} must be a string`);
-    return value;
-}
-function numberValue(value, path) {
-    if (typeof value !== 'number' || !Number.isFinite(value))
-        throw new Error(`${path} must be a number`);
-    return value;
-}

package/node_modules/@aptkit/provider-synthetic/dist/src/tool-definitions.d.ts

@@ -1,2 +0,0 @@
-import type { ToolDefinition } from '@aptkit/tools';
-export declare const syntheticEcommerceToolDefinitions: ToolDefinition[];

package/node_modules/@aptkit/provider-synthetic/dist/src/tool-definitions.js

@@ -1,59 +0,0 @@
-export const syntheticEcommerceToolDefinitions = [
-    {
-        name: 'get_project_overview',
-        description: 'Return synthetic ecommerce workspace metadata and data horizon.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-            additionalProperties: false,
-        },
-    },
-    {
-        name: 'get_metric_timeseries',
-        description: 'Return synthetic ecommerce metric timeseries for an optional dimension and segment.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                metric: { type: 'string' },
-                dimension: { type: 'string' },
-                segment: { type: 'string' },
-                time_range: {
-                    type: 'object',
-                    properties: {
-                        from: { type: 'string' },
-                        to: { type: 'string' },
-                    },
-                },
-                granularity: { type: 'string' },
-            },
-            required: ['metric'],
-        },
-    },
-    {
-        name: 'get_anomaly_context',
-        description: 'Return synthetic ecommerce anomaly context, related segments, and sample records.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                metric: { type: 'string' },
-                dimension: { type: 'string' },
-                segment: { type: 'string' },
-                anomaly_window: {
-                    type: 'object',
-                    properties: {
-                        from: { type: 'string' },
-                        to: { type: 'string' },
-                    },
-                },
-                baseline_window: {
-                    type: 'object',
-                    properties: {
-                        from: { type: 'string' },
-                        to: { type: 'string' },
-                    },
-                },
-            },
-            required: ['metric', 'dimension', 'segment'],
-        },
-    },
-];

package/node_modules/@aptkit/provider-synthetic/dist/src/tool-registry.d.ts

@@ -1,15 +0,0 @@
-import type { ToolCallOptions, ToolCallResult, ToolDefinition, ToolRegistry } from '@aptkit/tools';
-import type { SyntheticEcommerceDataSource } from './types.js';
-export type SyntheticEcommerceToolRegistryOptions = {
-    dataSource: SyntheticEcommerceDataSource;
-    tools?: readonly ToolDefinition[];
-};
-/** ToolRegistry adapter that exposes synthetic ecommerce data through normal agent tools. */
-export declare class SyntheticEcommerceToolRegistry implements ToolRegistry {
-    private readonly dataSource;
-    private readonly tools;
-    constructor(options: SyntheticEcommerceToolRegistryOptions);
-    listTools(): ToolDefinition[];
-    callTool(name: string, args: Record<string, unknown>, options?: ToolCallOptions): Promise<ToolCallResult>;
-    private dispatch;
-}

package/node_modules/@aptkit/provider-synthetic/dist/src/tool-registry.js

@@ -1,28 +0,0 @@
-import { syntheticEcommerceToolDefinitions } from './tool-definitions.js';
-/** ToolRegistry adapter that exposes synthetic ecommerce data through normal agent tools. */
-export class SyntheticEcommerceToolRegistry {
-    dataSource;
-    tools;
-    constructor(options) {
-        this.dataSource = options.dataSource;
-        this.tools = options.tools ?? syntheticEcommerceToolDefinitions;
-    }
-    listTools() {
-        return [...this.tools];
-    }
-    async callTool(name, args, options) {
-        options?.signal?.throwIfAborted();
-        const start = performance.now();
-        const result = await this.dispatch(name, args);
-        return { result, durationMs: Math.round(performance.now() - start) };
-    }
-    dispatch(name, args) {
-        if (name === 'get_project_overview')
-            return this.dataSource.getProjectOverview();
-        if (name === 'get_metric_timeseries')
-            return this.dataSource.getMetricTimeseries(args);
-        if (name === 'get_anomaly_context')
-            return this.dataSource.getAnomalyContext(args);
-        throw new Error(`synthetic ecommerce tool not found: ${name}`);
-    }
-}

package/node_modules/@aptkit/provider-synthetic/dist/src/types.d.ts

@@ -1,94 +0,0 @@
-import type { WorkspaceDescriptor } from '@aptkit/context';
-export type SyntheticProviderMode = 'fixture' | 'openai';
-export type TimeRange = {
-    from?: string;
-    to?: string;
-};
-export type ProjectOverview = {
-    provider: {
-        id: 'synthetic-ecommerce';
-        mode: SyntheticProviderMode;
-        scenarioId: string;
-    };
-    workspace: WorkspaceDescriptor;
-    highlights: string[];
-};
-export type MetricTimeseriesArgs = {
-    metric?: string;
-    dimension?: string;
-    segment?: string;
-    time_range?: TimeRange;
-    granularity?: 'day' | 'week' | 'month' | string;
-};
-export type MetricPoint = {
-    ts: string;
-    segment: string;
-    value: number;
-};
-export type MetricTimeseriesResult = {
-    provider: {
-        id: 'synthetic-ecommerce';
-        mode: SyntheticProviderMode;
-        scenarioId: string;
-    };
-    periodComparison: {
-        metric: string;
-        dimension: string;
-        segment: string;
-        recentWindow: Required<TimeRange>;
-        baselineWindow: Required<TimeRange>;
-        recentValue: number;
-        baselineAverage: number;
-        pctChange: number;
-        relatedSegments: {
-            name: string;
-            pctChange: number;
-        }[];
-    };
-    points: MetricPoint[];
-    totalCount: number;
-};
-export type AnomalyContextArgs = {
-    metric?: string;
-    dimension?: string;
-    segment?: string;
-    anomaly_window?: TimeRange;
-    baseline_window?: TimeRange;
-};
-export type AnomalyContextResult = {
-    provider: {
-        id: 'synthetic-ecommerce';
-        mode: SyntheticProviderMode;
-        scenarioId: string;
-    };
-    anomaly_summary: {
-        metric: string;
-        segment: string;
-        anomaly_value: number;
-        baseline_avg: number;
-        pct_change: number;
-    };
-    related_segments: {
-        name: string;
-        pct_change: number;
-    }[];
-    drivers: {
-        name: string;
-        contribution: number;
-        detail: string;
-    }[];
-    sample_orders: {
-        order_id: string;
-        purchase_ts: string;
-        status: string;
-        price_brl: number;
-    }[];
-};
-export type SyntheticEcommerceDataSource = {
-    readonly mode: SyntheticProviderMode;
-    readonly scenarioId: string;
-    readonly workspace: WorkspaceDescriptor;
-    getProjectOverview(): Promise<ProjectOverview> | ProjectOverview;
-    getMetricTimeseries(args?: MetricTimeseriesArgs): Promise<MetricTimeseriesResult> | MetricTimeseriesResult;
-    getAnomalyContext(args?: AnomalyContextArgs): Promise<AnomalyContextResult> | AnomalyContextResult;
-};

package/node_modules/@aptkit/provider-synthetic/dist/src/types.js

@@ -1 +0,0 @@
-export {};