@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/vendor/@vfrey/contracts/dist/domain/types.d.ts

@@ -0,0 +1,216 @@
+export type Platform = "youtube" | "tiktok" | "instagram" | "facebook";
+export type TemplateId = "KineticType" | "EditorialSplit" | "SignalBoard";
+export type Pacing = "fast" | "medium" | "slow";
+export type CaptionStyle = "slam" | "lower-third" | "terminal";
+export type DurationBucket = "short" | "mid" | "long";
+export type HookPattern = "question" | "contrarian" | "story" | "statistic" | "cold-open";
+export type ScriptStructure = "list" | "narrative" | "debate" | "breakdown";
+export type HashtagStrategy = "niche-first" | "question-led" | "plain-language";
+export type JobKind = "pipeline" | "engage" | "analytics";
+export type JobStage = "source" | "generate" | "render" | "publish" | "engage" | "done";
+export type JobStatus = "pending" | "leased" | "succeeded" | "rejected" | "blocked" | "dead";
+export interface Palette {
+    id: string;
+    background: string;
+    foreground: string;
+    accent: string;
+    muted: string;
+    surface: string;
+}
+export interface VariationPlan {
+    templateId: TemplateId;
+    pacing: Pacing;
+    captionStyle: CaptionStyle;
+    paletteId: string;
+    hookPattern: HookPattern;
+    structure: ScriptStructure;
+    hashtagStrategy: HashtagStrategy;
+    durationTargetSec: number;
+    durationBucket: DurationBucket;
+    voiceId: string;
+    coverTimestampMs: number;
+    layoutSeed: number;
+}
+export interface VariationSnapshot extends VariationPlan {
+    hook: string;
+    title: string;
+    hashtags: string[];
+    script: string;
+}
+export interface Beat {
+    role: "hook" | "setup" | "turn" | "evidence" | "payoff" | "cta";
+    text: string;
+    caption: string;
+    seconds: number;
+}
+export interface RenderProps {
+    templateId: TemplateId;
+    title: string;
+    hook: string;
+    beats: Beat[];
+    palette: Palette;
+    captionStyle: CaptionStyle;
+    pacing: Pacing;
+    voiceoverFile: string | null;
+    layoutSeed: number;
+    durationSec: number;
+}
+export interface Candidate {
+    fingerprint: string;
+    provider: "rss" | "reddit" | "youtube" | "tiktok" | "manual";
+    title: string;
+    url: string;
+    excerpt: string;
+    publishedAt: string | null;
+}
+export interface ContentPackage {
+    candidate: Candidate;
+    plan: VariationPlan;
+    title: string;
+    hook: string;
+    beats: Beat[];
+    caption: string;
+    description: string;
+    hashtags: string[];
+    thumbnailPrompt: string;
+    imagePrompts: string[];
+    voiceoverScript: string;
+    voiceoverPath: string | null;
+    durationSec: number;
+    outputPath: string | null;
+}
+export interface DisclosureProof {
+    platform: Platform;
+    /** Dotted field path inside the official request body or form. */
+    field: string;
+    value: true;
+    /** Human-readable request location, for the audit log. */
+    location: string;
+}
+export type PublishPhase = "idle" | "initialized" | "uploaded" | "done" | "failed" | "skipped";
+export interface PlatformSession {
+    phase: PublishPhase;
+    externalId: string | null;
+    uploadUrl: string | null;
+    creationId: string | null;
+    logId: string | null;
+    disclosure: DisclosureProof | null;
+    errorCode: string | null;
+    errorMessage: string | null;
+    errorRisk?: "quality" | "compliance" | "transport" | "config" | null;
+    /** Bytes confirmed by the platform, for resumable uploads. */
+    uploadedBytes: number;
+}
+export interface PipelineData {
+    candidates: Candidate[];
+    rejectedFingerprints: string[];
+    content: ContentPackage | null;
+    platforms: Partial<Record<Platform, PlatformSession>>;
+    engageReplied: number;
+    dryRunPayloads: Partial<Record<Platform, unknown>>;
+}
+export interface AccountPublish {
+    enabled: boolean;
+}
+export interface YouTubeAccount extends AccountPublish {
+    privacyStatus: "public" | "private" | "unlisted";
+    categoryId: string;
+    madeForKids: boolean;
+    refreshTokenEnv: string;
+    clientIdEnv: string;
+    clientSecretEnv: string;
+    notifySubscribers: boolean | null;
+}
+export interface TikTokAccount extends AccountPublish {
+    /** Requested level. Unaudited clients must use SELF_ONLY, and only if creator options include it. */
+    privacyLevel: "PUBLIC_TO_EVERYONE" | "MUTUAL_FOLLOW_FRIENDS" | "FOLLOWER_OF_CREATOR" | "SELF_ONLY";
+    refreshTokenEnv: string;
+    openIdEnv: string;
+    brandContent: boolean;
+    brandOrganic: boolean;
+    disableComment: boolean;
+}
+export interface InstagramAccount extends AccountPublish {
+    igUserIdEnv: string;
+    accessTokenEnv: string;
+    shareToFeed: boolean;
+}
+export interface FacebookAccount extends AccountPublish {
+    pageIdEnv: string;
+    pageTokenEnv: string;
+}
+export interface Account {
+    id: string;
+    niche: string;
+    language: string;
+    cadence: {
+        timezone: string;
+        minHoursBetweenPosts: number;
+        maxPostsPerDay: number;
+        windows: string[];
+    };
+    voices: string[];
+    hashtagPool: string[];
+    sources: {
+        rss: string[];
+        subreddits: string[];
+        youtubeChannelIds: string[];
+        /** Official videos.list chart=mostPopular. Costs Data API quota. */
+        youtubeTrendingRegion: string | null;
+    };
+    platforms: {
+        youtube?: YouTubeAccount;
+        tiktok?: TikTokAccount;
+        instagram?: InstagramAccount;
+        facebook?: FacebookAccount;
+    };
+    engage: {
+        enabled: boolean;
+        allowSpicy: boolean;
+        maxRepliesPerDay: number;
+        minSecondsBetweenReplies: number;
+    };
+    /** Quality waiver. Default false. Recorded on the publication when used. */
+    waiveAudioRotation: boolean;
+}
+export interface AppConfig {
+    /** QA is the default. Production is selected only when APP_ENV=production. */
+    appEnv: "qa" | "production";
+    dataDir: string;
+    accountsFile: string;
+    dryRun: boolean;
+    llm: {
+        provider: string;
+        baseUrl: string;
+        apiKey: string | null;
+        model: string;
+    };
+    tts: {
+        provider: "openai" | "none";
+        baseUrl: string;
+        apiKey: string | null;
+        model: string;
+    };
+    googleApiKey: string | null;
+    reddit: {
+        clientId: string | null;
+        clientSecret: string | null;
+        userAgent: string;
+    };
+    tiktok: {
+        clientKey: string | null;
+        clientSecret: string | null;
+        /** False until TikTok completes the Content Posting audit. Public posts are refused. */
+        clientAudited: boolean;
+    };
+    meta: {
+        graphVersion: string;
+        appId: string | null;
+        appSecret: string | null;
+    };
+    youtube: {
+        /** Headroom under the 100 upload/day bucket introduced for videos.insert. */
+        dailyUploadCap: number;
+    };
+    accounts: Account[];
+}

package/vendor/@vfrey/contracts/dist/domain/types.js

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

package/vendor/@vfrey/contracts/dist/domain/variation.d.ts

@@ -0,0 +1,57 @@
+import type { TemplateId, VariationPlan, VariationSnapshot } from "./types.js";
+/**
+ * Quality checklist for material variation between consecutive videos.
+ *
+ * YouTube's channel monetization policy (support.google.com/youtube/answer/1311392,
+ * updated July 15, 2025) says monetized content must not be mass-produced or
+ * repetitive, and that the substance of each video should be materially varied.
+ * It also says AI output that is a generic template with no original perspective
+ * is not eligible. These gates encode that standard as content-quality checks.
+ *
+ * They are not a detector-evasion layer. They do not add hidden noise, spoof
+ * metadata, or omit the synthetic-media disclosure. Passing them does not
+ * guarantee Partner Program eligibility. The February 1, 2027 YPP update is a
+ * terms acceptance inside YouTube Studio. This process cannot click that
+ * prompt, and it does not try to.
+ */
+export interface ChecklistItem {
+    id: string;
+    axis: string;
+    rule: string;
+    enforcedBy: string;
+    risk: "quality" | "compliance";
+}
+export declare const VARIATION_CHECKLIST: ChecklistItem[];
+export declare function selectVariation(input: {
+    history: VariationSnapshot[];
+    voices: string[];
+    waiveAudioRotation: boolean;
+}): VariationPlan;
+export interface QualityReport {
+    ok: boolean;
+    failures: string[];
+}
+export declare function evaluateQualityVariation(input: {
+    plan: VariationPlan;
+    hook: string;
+    title: string;
+    hashtags: string[];
+    previous: VariationSnapshot | null;
+    voicePoolSize: number;
+    waiveAudioRotation: boolean;
+    durationSec: number;
+}): QualityReport;
+export declare function assertQualityVariation(input: Parameters<typeof evaluateQualityVariation>[0]): void;
+export declare function assertSubjectBinding(script: string, sourceTitle: string): void;
+export declare function fitBeats(beats: Array<{
+    role: VariationSnapshot["structure"] extends never ? never : string;
+    text: string;
+    caption: string;
+    seconds: number;
+}>, templateId: TemplateId): Array<{
+    role: "hook" | "setup" | "turn" | "evidence" | "payoff" | "cta";
+    text: string;
+    caption: string;
+    seconds: number;
+}>;
+export declare function templatePalette(templateId: TemplateId, paletteId: string): import("./types.js").Palette;

package/vendor/@vfrey/contracts/dist/domain/variation.js

@@ -0,0 +1,278 @@
+import { QualityError } from "./errors.js";
+import { jaccard, sameSet, sharedFourGram, significantTokens } from "./similarity.js";
+import { TEMPLATES, TEMPLATE_IDS, durationBucket } from "./templates.js";
+export const VARIATION_CHECKLIST = [
+    {
+        id: "template",
+        axis: "Visual system",
+        rule: "Consecutive videos use different Remotion templates (type, editorial, or signal board).",
+        enforcedBy: "selectVariation",
+        risk: "quality",
+    },
+    {
+        id: "pacing",
+        axis: "Pacing",
+        rule: "Fast, medium, and slow pacing rotate with the template. Beat timing is refit to that template's duration band.",
+        enforcedBy: "selectVariation + fitBeats",
+        risk: "quality",
+    },
+    {
+        id: "caption-style",
+        axis: "Captions",
+        rule: "Caption language changes with the template: slam type, editorial lower-third, or terminal chip.",
+        enforcedBy: "selectVariation",
+        risk: "quality",
+    },
+    {
+        id: "visual-palette",
+        axis: "Visual style",
+        rule: "Palette id changes every video. Each template has four palettes.",
+        enforcedBy: "selectVariation",
+        risk: "quality",
+    },
+    {
+        id: "structure",
+        axis: "Structure",
+        rule: "Rhetorical structure rotates through list, narrative, debate, and breakdown.",
+        enforcedBy: "selectVariation",
+        risk: "quality",
+    },
+    {
+        id: "hook-pattern",
+        axis: "Hook",
+        rule: "Hook pattern does not repeat either of the previous two videos.",
+        enforcedBy: "selectVariation",
+        risk: "quality",
+    },
+    {
+        id: "duration-bucket",
+        axis: "Duration",
+        rule: "Short, mid, and long buckets rotate. All buckets stay inside a 60 second Short.",
+        enforcedBy: "selectVariation + fitBeats",
+        risk: "quality",
+    },
+    {
+        id: "duration-range",
+        axis: "Duration",
+        rule: "The finished film runs inside its template's published minimum and maximum seconds, not just its bucket.",
+        enforcedBy: "evaluateQualityVariation",
+        risk: "quality",
+    },
+    {
+        id: "audio-voice",
+        axis: "Audio",
+        rule: "Voice id rotates when the account has two or more voices. A single voice fails the quality gate unless waiveAudioRotation is set.",
+        enforcedBy: "selectVariation + evaluateQualityVariation",
+        risk: "quality",
+    },
+    {
+        id: "hook-wording",
+        axis: "Hook wording",
+        rule: "Token overlap between this hook and the previous hook stays below 0.5.",
+        enforcedBy: "evaluateQualityVariation",
+        risk: "quality",
+    },
+    {
+        id: "title-ngram",
+        axis: "Title",
+        rule: "The title shares no 4-word window with the previous title.",
+        enforcedBy: "evaluateQualityVariation",
+        risk: "quality",
+    },
+    {
+        id: "hashtag-set",
+        axis: "Hashtags",
+        rule: "The hashtag set is not identical to the previous video.",
+        enforcedBy: "evaluateQualityVariation",
+        risk: "quality",
+    },
+    {
+        id: "subject-binding",
+        axis: "Specific subject",
+        rule: "The script uses at least two significant words from this source title, so a generic script cannot be reused across topics.",
+        enforcedBy: "assertSubjectBinding",
+        risk: "quality",
+    },
+    {
+        id: "layout-seed",
+        axis: "Layout",
+        rule: "Layout seed changes, which flips rail side and caption lift inside the template.",
+        enforcedBy: "selectVariation",
+        risk: "quality",
+    },
+];
+const HOOKS = ["question", "contrarian", "story", "statistic", "cold-open"];
+const STRUCTURES = ["list", "narrative", "debate", "breakdown"];
+const HASHTAGS = ["niche-first", "question-led", "plain-language"];
+function nextOf(items, current, step) {
+    const index = current === undefined ? 0 : items.indexOf(current);
+    const start = index < 0 ? 0 : index;
+    return items[(start + step) % items.length];
+}
+export function selectVariation(input) {
+    if (input.voices.length === 0) {
+        throw new QualityError("audio_voice", "Account needs at least one TTS voice id.");
+    }
+    const recent = input.history[0];
+    const previousHooks = new Set(input.history.slice(0, 2).map((item) => item.hookPattern));
+    const templateId = nextOf(TEMPLATE_IDS, recent?.templateId, 1);
+    const spec = TEMPLATES[templateId];
+    let hookPattern = nextOf(HOOKS, recent?.hookPattern, 1);
+    if (previousHooks.has(hookPattern)) {
+        hookPattern = HOOKS.find((pattern) => !previousHooks.has(pattern)) ?? hookPattern;
+    }
+    const structure = nextOf(STRUCTURES, recent?.structure, 1);
+    const palette = spec.palettes[input.history.length % spec.palettes.length] ?? spec.palettes[0];
+    const paletteId = palette.id === recent?.paletteId
+        ? (spec.palettes.find((item) => item.id !== recent.paletteId) ?? palette).id
+        : palette.id;
+    let voiceId = input.voices[input.history.length % input.voices.length] ?? input.voices[0];
+    if (voiceId === recent?.voiceId && input.voices.length > 1) {
+        voiceId = input.voices[(input.voices.indexOf(voiceId) + 1) % input.voices.length] ?? voiceId;
+    }
+    const layoutSeed = (recent?.layoutSeed ?? 0) + 1 + input.history.length;
+    return {
+        templateId,
+        pacing: spec.pacing,
+        captionStyle: spec.captionStyle,
+        paletteId,
+        hookPattern,
+        structure,
+        hashtagStrategy: nextOf(HASHTAGS, recent?.hashtagStrategy, 1),
+        durationTargetSec: spec.durationTargetSec,
+        durationBucket: spec.bucket,
+        voiceId,
+        coverTimestampMs: spec.coverTimestampMs,
+        layoutSeed,
+    };
+}
+export function evaluateQualityVariation(input) {
+    const failures = [];
+    const previous = input.previous;
+    const spec = TEMPLATES[input.plan.templateId];
+    if (input.plan.pacing !== spec.pacing)
+        failures.push("pacing");
+    if (input.plan.captionStyle !== spec.captionStyle)
+        failures.push("caption-style");
+    if (input.plan.durationBucket !== spec.bucket)
+        failures.push("duration-bucket");
+    if (durationBucket(input.durationSec) !== spec.bucket)
+        failures.push("duration-bucket");
+    if (!(input.durationSec >= spec.durationMinSec && input.durationSec <= spec.durationMaxSec)) {
+        failures.push("duration-range");
+    }
+    if (!spec.palettes.some((palette) => palette.id === input.plan.paletteId))
+        failures.push("visual-palette");
+    if (input.voicePoolSize < 2 && !input.waiveAudioRotation)
+        failures.push("audio-voice");
+    if (!previous) {
+        return { ok: failures.length === 0, failures: unique(failures) };
+    }
+    if (input.plan.templateId === previous.templateId)
+        failures.push("template");
+    if (input.plan.pacing === previous.pacing)
+        failures.push("pacing");
+    if (input.plan.captionStyle === previous.captionStyle)
+        failures.push("caption-style");
+    if (input.plan.paletteId === previous.paletteId)
+        failures.push("visual-palette");
+    if (input.plan.structure === previous.structure)
+        failures.push("structure");
+    if (input.plan.hookPattern === previous.hookPattern)
+        failures.push("hook-pattern");
+    if (input.plan.durationBucket === previous.durationBucket)
+        failures.push("duration-bucket");
+    if (input.plan.layoutSeed === previous.layoutSeed)
+        failures.push("layout-seed");
+    if (input.voicePoolSize > 1 && input.plan.voiceId === previous.voiceId)
+        failures.push("audio-voice");
+    if (jaccard(input.hook, previous.hook) >= 0.5)
+        failures.push("hook-wording");
+    if (sharedFourGram(input.title, previous.title))
+        failures.push("title-ngram");
+    if (sameSet(input.hashtags, previous.hashtags))
+        failures.push("hashtag-set");
+    return { ok: failures.length === 0, failures: unique(failures) };
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+export function assertQualityVariation(input) {
+    const report = evaluateQualityVariation(input);
+    if (!report.ok) {
+        throw new QualityError("variation", `Quality gate failed (${report.failures.join(", ")}). This is a content-variation rejection, not a platform API error.`);
+    }
+}
+export function assertSubjectBinding(script, sourceTitle) {
+    const wanted = significantTokens(sourceTitle);
+    if (wanted.length === 0)
+        return;
+    const scriptTokens = new Set(significantTokens(script));
+    const hits = wanted.filter((token) => scriptTokens.has(token));
+    const needed = Math.min(2, wanted.length);
+    if (hits.length < needed) {
+        throw new QualityError("subject-binding", `Script does not bind to this source. Needed ${needed} of: ${wanted.join(", ")}.`);
+    }
+}
+const MIN_BEAT_SECONDS = 1.2;
+/**
+ * Split `target` seconds across beats in proportion to `weights`, never giving
+ * a beat less than the floor. Beats that would fall below it are pinned to the
+ * floor and the rest share what remains. Totals the target to a tenth of a second.
+ */
+function allocateSeconds(weights, target) {
+    const pinned = new Array(weights.length).fill(false);
+    let result = weights.map(() => MIN_BEAT_SECONDS);
+    for (let pass = 0; pass <= weights.length; pass += 1) {
+        const free = weights.map((_, index) => index).filter((index) => !pinned[index]);
+        const remaining = target - MIN_BEAT_SECONDS * (weights.length - free.length);
+        const freeWeight = free.reduce((sum, index) => sum + (weights[index] ?? 1), 0);
+        result = weights.map((_, index) => pinned[index] ? MIN_BEAT_SECONDS : ((weights[index] ?? 1) / freeWeight) * remaining);
+        const below = free.filter((index) => (result[index] ?? 0) < MIN_BEAT_SECONDS);
+        if (below.length === 0)
+            break;
+        for (const index of below)
+            pinned[index] = true;
+    }
+    const rounded = result.map((value) => Math.max(MIN_BEAT_SECONDS, Math.round(value * 10) / 10));
+    // Put rounding drift on the longest beat (last on ties) so no beat drops under the floor.
+    const drift = target - rounded.reduce((sum, value) => sum + value, 0);
+    let longest = 0;
+    rounded.forEach((value, index) => {
+        if (value >= (rounded[longest] ?? 0))
+            longest = index;
+    });
+    rounded[longest] = Math.round(((rounded[longest] ?? MIN_BEAT_SECONDS) + drift) * 10) / 10;
+    return rounded;
+}
+export function fitBeats(beats, templateId) {
+    const spec = TEMPLATES[templateId];
+    if (beats.length < 4) {
+        throw new QualityError("thin_script", "A video needs at least four beats so it has a structure, not a single card.");
+    }
+    const usable = beats.slice(0, 8);
+    const weights = usable.map((beat) => Math.max(1, beat.seconds || 1));
+    const target = spec.durationTargetSec;
+    if (usable.length * MIN_BEAT_SECONDS > target + 1e-9) {
+        throw new QualityError("thin_beats", `${usable.length} beats cannot fit ${target}s of ${templateId} at ${MIN_BEAT_SECONDS}s each. Cut beats or pick a longer template.`);
+    }
+    const seconds = allocateSeconds(weights, target);
+    const roles = ["hook", "setup", "turn", "evidence", "payoff", "cta"];
+    return usable.map((beat, index) => {
+        const fallback = index === 0 ? "hook" : index === usable.length - 1 ? "cta" : "turn";
+        const role = roles.includes(beat.role) ? beat.role : fallback;
+        return {
+            role: role,
+            text: beat.text.trim(),
+            caption: (beat.caption || beat.text).trim(),
+            seconds: seconds[index] ?? MIN_BEAT_SECONDS,
+        };
+    });
+}
+export function templatePalette(templateId, paletteId) {
+    const palette = TEMPLATES[templateId].palettes.find((item) => item.id === paletteId);
+    if (!palette) {
+        throw new QualityError("visual-palette", `Palette ${paletteId} is not part of ${templateId}.`);
+    }
+    return palette;
+}

package/vendor/@vfrey/contracts/dist/events.d.ts

@@ -0,0 +1,20 @@
+import type { JobStage, JobStatus } from "./domain/types.js";
+export interface JobEvent {
+    jobId: string;
+    at: string;
+    stage: JobStage;
+    status: JobStatus;
+    code: string | null;
+    message: string | null;
+    durationMs: number | null;
+}
+export type WarningCode = "missing_credential" | "refresh_failure" | "quota" | "disclosure_rejected" | "cadence_behind" | "review_rejected" | "orchestrator_timeout";
+export interface Warning {
+    id: string;
+    accountId: string;
+    channelId: string | null;
+    code: WarningCode;
+    message: string;
+    at: string;
+    ackedAt: string | null;
+}

package/vendor/@vfrey/contracts/dist/events.js

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

package/vendor/@vfrey/contracts/dist/http.d.ts

@@ -0,0 +1,11 @@
+export interface HttpResult {
+    status: number;
+    headers: Headers;
+    text: string;
+    json: unknown;
+}
+export declare function requestJson(fetchImpl: typeof fetch, url: string, init: RequestInit & {
+    timeoutMs?: number;
+}): Promise<HttpResult>;
+export declare function retryAfterFrom(result: HttpResult, nowMs: number): number | undefined;
+export declare function assertOk(result: HttpResult, code: string): void;

package/vendor/@vfrey/contracts/dist/http.js

@@ -0,0 +1,37 @@
+import { RetryableError } from "./domain/errors.js";
+import { parseRetryAfter } from "./domain/backoff.js";
+import { redact } from "./domain/redact.js";
+export async function requestJson(fetchImpl, url, init) {
+    const timeoutMs = init.timeoutMs ?? 30_000;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetchImpl(url, { ...init, signal: controller.signal });
+        const text = await response.text();
+        let json = null;
+        if (text) {
+            try {
+                json = JSON.parse(text);
+            }
+            catch {
+                json = null;
+            }
+        }
+        return { status: response.status, headers: response.headers, text, json };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new RetryableError("network", redact(message));
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function retryAfterFrom(result, nowMs) {
+    return parseRetryAfter(result.headers.get("retry-after"), nowMs);
+}
+export function assertOk(result, code) {
+    if (result.status === 429 || result.status >= 500) {
+        throw new RetryableError(code, redact(`${result.status} ${result.text}`).slice(0, 500), retryAfterFrom(result, Date.now()));
+    }
+}

package/vendor/@vfrey/contracts/dist/index.d.ts

@@ -0,0 +1,22 @@
+export * from "./domain/advice-persona.js";
+export * from "./domain/backoff.js";
+export * from "./domain/cadence.js";
+export * from "./domain/creators.js";
+export * from "./domain/disclosure.js";
+export * from "./domain/errors.js";
+export * from "./domain/redact.js";
+export * from "./domain/revenue.js";
+export * from "./domain/safety.js";
+export * from "./domain/similarity.js";
+export * from "./domain/templates.js";
+export * from "./domain/tiktok-chunks.js";
+export * from "./domain/topics.js";
+export * from "./domain/types.js";
+export * from "./domain/variation.js";
+export * from "./credentials/crypto.js";
+export * from "./http.js";
+export * from "./log.js";
+export * from "./checks.js";
+export * from "./events.js";
+export * from "./mail.js";
+export * from "./account.js";

package/vendor/@vfrey/contracts/dist/index.js

@@ -0,0 +1,22 @@
+export * from "./domain/advice-persona.js";
+export * from "./domain/backoff.js";
+export * from "./domain/cadence.js";
+export * from "./domain/creators.js";
+export * from "./domain/disclosure.js";
+export * from "./domain/errors.js";
+export * from "./domain/redact.js";
+export * from "./domain/revenue.js";
+export * from "./domain/safety.js";
+export * from "./domain/similarity.js";
+export * from "./domain/templates.js";
+export * from "./domain/tiktok-chunks.js";
+export * from "./domain/topics.js";
+export * from "./domain/types.js";
+export * from "./domain/variation.js";
+export * from "./credentials/crypto.js";
+export * from "./http.js";
+export * from "./log.js";
+export * from "./checks.js";
+export * from "./events.js";
+export * from "./mail.js";
+export * from "./account.js";

package/vendor/@vfrey/contracts/dist/log.d.ts

@@ -0,0 +1,2 @@
+export type LogLevel = "info" | "warn" | "error";
+export declare function log(level: LogLevel, message: string, fields?: Record<string, unknown>): void;