@vamos-ui/react 0.0.0-stage → 0.3.0

package/dist/render/index.d.ts

@@ -0,0 +1,6 @@
+export { BlockRenderer, renderDoc, renderPrepared, BlockNotice, type BlockRendererProps, type RenderDocOptions } from "./block-renderer.js";
+export { prepareDoc, resolveDoc, isOutsideSchedule, type PreparedDoc, type PreparedNode, type PreparedStatus, type PreparedQuery, type PrepareOptions, type Resolvers } from "./prepare.js";
+export { RichText, renderInline, renderRichBlocks, type RichTextProps, type RichTextRenderOptions } from "../blocks/rich-text.js";
+export { JsonLd, mergeJsonLd } from "../blocks/json-ld.js";
+/** Alias of `BlockRenderer` (plan 05 vocabulary). */
+export { BlockRenderer as DocRenderer } from "./block-renderer.js";

package/dist/render/index.js

@@ -0,0 +1,7 @@
+// Public API of @vamos-ui/react/render — layer 3: VamosDoc → React. RSC-safe, zero editor code.
+export { BlockRenderer, renderDoc, renderPrepared, BlockNotice } from "./block-renderer.js";
+export { prepareDoc, resolveDoc, isOutsideSchedule } from "./prepare.js";
+export { RichText, renderInline, renderRichBlocks } from "../blocks/rich-text.js";
+export { JsonLd, mergeJsonLd } from "../blocks/json-ld.js";
+/** Alias of `BlockRenderer` (plan 05 vocabulary). */
+export { BlockRenderer as DocRenderer } from "./block-renderer.js";

package/dist/render/prepare.d.ts

@@ -0,0 +1,61 @@
+import type { AnyBlockDefinition, BlockRegistry, BlockRegion } from "../blocks/schema/define-block.js";
+import type { BlockNode, VamosDoc } from "../blocks/schema/types.js";
+import type { LintIssue } from "../blocks/schema/lint-types.js";
+export type PreparedStatus = "ok" | "core" | "unknown" | "invalid" | "newer" | "unrenderable";
+export interface PreparedQuery {
+    /** Resolver name (`f.query("posts")` → "posts"). */
+    resource: string;
+    /** Prop the resolved data lands in. */
+    into: string;
+    /** The stored query value ({ kind, limit, … }). */
+    query: unknown;
+}
+export interface PreparedNode {
+    /** Migrated + localized node. */
+    node: BlockNode;
+    def?: AnyBlockDefinition;
+    status: PreparedStatus;
+    /** Validated, localized props (defaults applied). */
+    props: Record<string, unknown>;
+    /** Top-level fields replaced by sample values during salvage. */
+    replaced: string[];
+    headingLevel: 1 | 2;
+    region: BlockRegion;
+    slots: Record<string, PreparedNode[]>;
+    queries: PreparedQuery[];
+}
+export interface PrepareOptions {
+    registry: BlockRegistry;
+    /** Active locale. Default: `doc.lang ?? doc.locales[0] ?? "en"`. */
+    locale?: string;
+    fallbackLocales?: readonly string[];
+    /** Builder canvas: keep hidden/scheduled blocks (marked) and show placeholders. */
+    editMode?: boolean;
+    /** Clock for `schedule`. Default `new Date()`. */
+    now?: Date;
+    /** Called for every problem found (logging, builder badges). */
+    onIssue?: (issue: LintIssue) => void;
+}
+export interface PreparedDoc {
+    doc: VamosDoc;
+    locale: string;
+    header: PreparedNode[];
+    body: PreparedNode[];
+    footer: PreparedNode[];
+    overlay: PreparedNode[];
+    issues: LintIssue[];
+}
+/** Whether a node is outside its schedule window at `now`. */
+export declare function isOutsideSchedule(node: BlockNode, now: Date): boolean;
+/**
+ * Turns a stored doc into render-ready nodes for one locale. Never throws on bad content:
+ * problems become statuses + issues, and content is never dropped from the source doc.
+ */
+export declare function prepareDoc(input: VamosDoc | unknown, opts: PrepareOptions): PreparedDoc;
+/** Resolver map: `resolvers.posts(query, ctx)` returns the data for `f.query("posts")`. */
+export type Resolvers = Record<string, (query: unknown, ctx: {
+    locale: string;
+    node: BlockNode;
+}) => unknown | Promise<unknown>>;
+/** Runs every block's queries in parallel and writes the results into its props. Failures leave the prop unset (block's empty state). */
+export declare function resolveDoc(prepared: PreparedDoc, resolvers?: Resolvers, onIssue?: (i: LintIssue) => void): Promise<PreparedDoc>;

package/dist/render/prepare.js

@@ -0,0 +1,119 @@
+// The render pipeline as pure data: filter hidden/scheduled → migrate → validate (salvage) →
+// localize → heading levels → collect queries. No React; unit-testable and reusable by builders.
+import { migrateDoc, migrateNode } from "../blocks/schema/migrate.js";
+import { validateNode } from "../blocks/schema/validate.js";
+import { localize, localizeProps } from "../blocks/schema/localize.js";
+import { walkFields } from "../blocks/schema/walk.js";
+import { isCoreTextType } from "../blocks/schema/nodes.js";
+/** Whether a node is outside its schedule window at `now`. */
+export function isOutsideSchedule(node, now) {
+    const s = node.schedule;
+    if (!s)
+        return false;
+    const t = now.getTime();
+    if (s.from && Number.isFinite(Date.parse(s.from)) && t < Date.parse(s.from))
+        return true;
+    if (s.until && Number.isFinite(Date.parse(s.until)) && t >= Date.parse(s.until))
+        return true;
+    return false;
+}
+/**
+ * Turns a stored doc into render-ready nodes for one locale. Never throws on bad content:
+ * problems become statuses + issues, and content is never dropped from the source doc.
+ */
+export function prepareDoc(input, opts) {
+    const issues = [];
+    const report = (i) => {
+        issues.push(i);
+        opts.onIssue?.(i);
+    };
+    const doc = migrateDoc(input);
+    const locale = opts.locale ?? doc.lang ?? doc.locales?.[0] ?? "en";
+    const fallback = opts.fallbackLocales ?? [...(doc.locales ?? []).filter((l) => l !== locale), "en"];
+    const now = opts.now ?? new Date();
+    const { registry, editMode } = opts;
+    const prepareNode = (raw, region) => {
+        if (!editMode && (raw.hidden || isOutsideSchedule(raw, now)))
+            return null;
+        const def = registry.get(raw.type);
+        const base = { replaced: [], headingLevel: 2, region, queries: [] };
+        const prepareSlots = (n) => Object.fromEntries(Object.entries(n.slots ?? {}).map(([k, list]) => [k, list.map((c) => prepareNode(c, region)).filter((c) => !!c)]));
+        if (!def) {
+            if (isCoreTextType(raw.type)) {
+                const node = localize(raw, undefined, { locale, fallback });
+                return { ...base, node, status: "core", props: (raw.props ?? {}), slots: prepareSlots(raw) };
+            }
+            report({ severity: "warning", code: "unknown-block", message: `Unknown block type "${raw.type}".`, blockId: raw.id, blockType: raw.type });
+            return { ...base, node: raw, status: "unknown", props: {}, slots: {} };
+        }
+        const migrated = migrateNode(raw, def);
+        if (migrated.error)
+            report({ severity: "error", code: "missing-migration", message: migrated.error.message, blockId: raw.id, blockType: raw.type });
+        if (migrated.newer)
+            report({ severity: "warning", code: "newer-version", message: `"${raw.type}" v${raw.v} is newer than v${def.version}.`, blockId: raw.id, blockType: raw.type });
+        const node = migrated.node;
+        const result = validateNode(node, def);
+        if (!result.ok || result.replaced.length) {
+            for (const iss of result.issues)
+                report({ severity: "error", code: "invalid-props", message: iss.message, path: ["props", ...iss.path.map(String)].join("."), blockId: node.id, blockType: node.type });
+        }
+        const status = !result.ok ? "unrenderable" : migrated.newer ? "newer" : result.replaced.length ? "invalid" : "ok";
+        const props = result.ok ? localizeProps(def.schema, result.data, { locale, fallback }) : {};
+        const queries = [];
+        if (result.ok)
+            walkFields(def.schema, result.data, (f) => {
+                if (f.meta?.query && f.value !== undefined) {
+                    queries.push({ resource: f.meta.query.resource, into: f.meta.query.into, query: f.value });
+                    return "skip";
+                }
+            });
+        const localizedNode = localize({ ...node, props: undefined }, undefined, { locale, fallback });
+        return { ...base, node: { ...localizedNode, props }, def, status, props, replaced: result.replaced, slots: prepareSlots(node), queries };
+    };
+    const prepareList = (list, region) => (list ?? []).map((n) => prepareNode(n, region)).filter((n) => !!n);
+    const body = prepareList(doc.blocks, "body");
+    // Automatic heading levels: the first page-title block (hero, page intro) owns the page's h1.
+    const first = body.find((n) => n.def?.supports.pageTitle && n.status !== "unknown");
+    if (first)
+        first.headingLevel = 1;
+    return {
+        doc,
+        locale,
+        header: prepareList(doc.layout?.header, "header"),
+        body,
+        footer: prepareList(doc.layout?.footer, "footer"),
+        overlay: prepareList(doc.layout?.overlay, "overlay"),
+        issues,
+    };
+}
+/** Runs every block's queries in parallel and writes the results into its props. Failures leave the prop unset (block's empty state). */
+export async function resolveDoc(prepared, resolvers = {}, onIssue) {
+    const tasks = [];
+    const visit = (n) => {
+        for (const q of n.queries) {
+            const fn = resolvers[q.resource];
+            if (!fn) {
+                const issue = { severity: "warning", code: "missing-resolver", message: `No resolver for "${q.resource}".`, blockId: n.node.id, blockType: n.node.type };
+                prepared.issues.push(issue);
+                onIssue?.(issue);
+                continue;
+            }
+            tasks.push(Promise.resolve()
+                .then(() => fn(q.query, { locale: prepared.locale, node: n.node }))
+                .then((data) => {
+                n.props = { ...n.props, [q.into]: data };
+                n.node = { ...n.node, props: n.props };
+            })
+                .catch((error) => {
+                const issue = { severity: "error", code: "resolver-failed", message: `Resolver "${q.resource}" failed: ${error instanceof Error ? error.message : String(error)}`, blockId: n.node.id, blockType: n.node.type };
+                prepared.issues.push(issue);
+                onIssue?.(issue);
+            }));
+        }
+        for (const list of Object.values(n.slots))
+            list.forEach(visit);
+    };
+    [prepared.header, prepared.body, prepared.footer, prepared.overlay].forEach((list) => list.forEach(visit));
+    await Promise.all(tasks);
+    return prepared;
+}

package/dist/scheduler/core/duration.d.ts

@@ -0,0 +1,83 @@
+export interface TimeEntry {
+    id: string;
+    /** UTC ISO instant. */
+    start: string;
+    /** UTC ISO instant; absent while the timer runs. */
+    end?: string;
+    /** Overrides `end - start` (manual entries). */
+    durationMin?: number;
+    projectId?: string;
+    /** Display name of the project (denormalised for lists and invoices). */
+    projectLabel?: string;
+    taskId?: string;
+    taskLabel?: string;
+    note?: string;
+    billable?: boolean;
+    /** Hourly rate. `amount` is a decimal string. */
+    rate?: {
+        amount: string;
+        currency: string;
+    };
+}
+/** A draft line for Line items (01): quantity in hours, decimal strings throughout. */
+export interface LineItemDraft {
+    description: string;
+    /** Hours, 2 decimals ("3.25"). */
+    quantity: string;
+    /** UN/ECE Rec 20 unit code: `HUR` (hour). */
+    unitCode: "HUR";
+    unitPrice: string;
+    currency: string;
+    /** quantity × unitPrice, rounded half-up to 2 places. */
+    total: string;
+    /** Ids of the entries folded into this line. */
+    entryIds: string[];
+}
+/**
+ * Parses what people type into a timesheet cell. Returns minutes, or `null` when it can't be read.
+ *
+ * ```ts
+ * parseDuration("1.5", "en-US");      // 90   (bare numbers are hours)
+ * parseDuration("1,5", "tr-TR");      // 90   (decimal comma where the locale uses it)
+ * parseDuration("1:30");              // 90
+ * parseDuration("90m");               // 90
+ * parseDuration("1h 30m");            // 90
+ * parseDuration("1 sa 30 dk", "tr");  // 90
+ * parseDuration("");                  // 0    (cleared)
+ * ```
+ */
+export declare function parseDuration(input: string, locale?: string): number | null;
+/**
+ * Formats minutes for display.
+ *
+ * - `"short"` (default): "3 h 20 min" / "3 sa 20 dk" (built-in for en / tr / de, Intl.DurationFormat for other locales when available).
+ * - `"clock"`: "3:20".
+ * - `"decimal"`: "3.33" / "3,33" hours.
+ */
+export declare function formatDuration(min: number, locale?: string, style?: "short" | "clock" | "decimal"): string;
+/** Minutes of an entry (running entries count up to `now`). */
+export declare function entryMinutes(e: Pick<TimeEntry, "start" | "end" | "durationMin">, now?: number): number;
+/** Sums a timesheet value map: per row, per day and the grand total. */
+export declare function timesheetTotals(value: Record<string, Record<string, number>>, days: readonly string[]): {
+    rows: Record<string, number>;
+    days: Record<string, number>;
+    total: number;
+};
+/**
+ * Billable entries → invoice line drafts, one line per project (or task) and rate.
+ * Hours are rounded half-up to 2 decimals per line; amounts stay decimal strings.
+ *
+ * ```ts
+ * toLineItems(entries, "project");
+ * // [{ description: "Mobile app", quantity: "3.33", unitCode: "HUR", unitPrice: "95.00", currency: "EUR", total: "316.35", … }]
+ * ```
+ */
+export declare function toLineItems(entries: readonly TimeEntry[], groupBy?: "project" | "task", opts?: {
+    now?: number;
+    describe?(key: {
+        project?: string;
+        task?: string;
+    }): string;
+}): LineItemDraft[];
+/** Sum of line totals (decimal string). */
+export declare const lineItemsTotal: (lines: readonly LineItemDraft[]) => string;

package/dist/scheduler/core/duration.js

@@ -0,0 +1,174 @@
+/**
+ * Time tracking core: duration parsing / formatting, entry totals and the bridge to invoice
+ * line items. React-free; identical results on server and client.
+ */
+import { addDecimal, multiplyDecimal, roundHalfUp } from "../../locale-data/core/decimal.js";
+const UNIT_WORDS = {
+    h: "h", hr: "h", hrs: "h", hour: "h", hours: "h", sa: "h", saat: "h", std: "h",
+    m: "m", min: "m", mins: "m", minute: "m", minutes: "m", dk: "m", dak: "m", dakika: "m", mn: "m",
+};
+/**
+ * Parses what people type into a timesheet cell. Returns minutes, or `null` when it can't be read.
+ *
+ * ```ts
+ * parseDuration("1.5", "en-US");      // 90   (bare numbers are hours)
+ * parseDuration("1,5", "tr-TR");      // 90   (decimal comma where the locale uses it)
+ * parseDuration("1:30");              // 90
+ * parseDuration("90m");               // 90
+ * parseDuration("1h 30m");            // 90
+ * parseDuration("1 sa 30 dk", "tr");  // 90
+ * parseDuration("");                  // 0    (cleared)
+ * ```
+ */
+export function parseDuration(input, locale = "en-US") {
+    const raw = input.trim().toLocaleLowerCase(locale.startsWith("tr") ? "tr-TR" : "en-US");
+    if (raw === "" || raw === "-" || raw === "–")
+        return 0;
+    const commaDecimal = decimalSeparator(locale) === ",";
+    // h:mm
+    const clock = /^(\d{1,3}):([0-5]?\d)$/.exec(raw);
+    if (clock)
+        return Number(clock[1]) * 60 + Number(clock[2]);
+    const num = (s) => {
+        let t = s;
+        if (commaDecimal)
+            t = t.replace(/\./g, "").replace(",", ".");
+        else
+            t = t.replace(/,/g, ".");
+        if (!/^\d+(\.\d+)?$|^\.\d+$/.test(t))
+            return null;
+        return Number(t);
+    };
+    // bare number → hours
+    const bare = num(raw);
+    if (bare !== null)
+        return Math.round(bare * 60);
+    // unit tokens: "1h 30m", "1.5h", "90 min", "1 sa 30 dk"
+    const re = /(\d+(?:[.,]\d+)?)\s*([a-zçğıöşü]+)\.?/g;
+    let total = 0;
+    let consumed = "";
+    let m;
+    while ((m = re.exec(raw))) {
+        const unit = UNIT_WORDS[m[2]];
+        if (!unit)
+            return null;
+        const value = Number(m[1].replace(",", "."));
+        total += unit === "h" ? value * 60 : value;
+        consumed += m[0];
+    }
+    if (!consumed || consumed.replace(/\s+/g, "") !== raw.replace(/\s+/g, ""))
+        return null;
+    return Math.round(total);
+}
+function decimalSeparator(locale) {
+    try {
+        return new Intl.NumberFormat(locale).formatToParts(1.5).find((p) => p.type === "decimal")?.value ?? ".";
+    }
+    catch {
+        return ".";
+    }
+}
+const FALLBACK_UNITS = {
+    en: { h: "h", m: "min" },
+    tr: { h: "sa", m: "dk" },
+    de: { h: "Std.", m: "Min." },
+};
+/**
+ * Formats minutes for display.
+ *
+ * - `"short"` (default): "3 h 20 min" / "3 sa 20 dk" (built-in for en / tr / de, Intl.DurationFormat for other locales when available).
+ * - `"clock"`: "3:20".
+ * - `"decimal"`: "3.33" / "3,33" hours.
+ */
+export function formatDuration(min, locale = "en-US", style = "short") {
+    const sign = min < 0 ? "−" : "";
+    const abs = Math.round(Math.abs(min));
+    const h = Math.floor(abs / 60);
+    const m = abs % 60;
+    if (style === "clock")
+        return `${sign}${h}:${String(m).padStart(2, "0")}`;
+    if (style === "decimal")
+        return sign + new Intl.NumberFormat(locale, { minimumFractionDigits: 0, maximumFractionDigits: 2 }).format(abs / 60);
+    const known = FALLBACK_UNITS[locale.slice(0, 2).toLowerCase()];
+    // Known languages use the dictionary so server and browser render the same text (no
+    // hydration drift between runtimes with and without Intl.DurationFormat).
+    const DF = Intl.DurationFormat;
+    if (!known && DF) {
+        try {
+            return sign + new DF(locale, { style: "short" }).format(h && m ? { hours: h, minutes: m } : h ? { hours: h } : { minutes: m });
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    const u = FALLBACK_UNITS[locale.slice(0, 2).toLowerCase()] ?? FALLBACK_UNITS.en;
+    const nf = new Intl.NumberFormat(locale);
+    if (h && m)
+        return `${sign}${nf.format(h)} ${u.h} ${nf.format(m)} ${u.m}`;
+    if (h)
+        return `${sign}${nf.format(h)} ${u.h}`;
+    return `${sign}${nf.format(m)} ${u.m}`;
+}
+/** Minutes of an entry (running entries count up to `now`). */
+export function entryMinutes(e, now = Date.now()) {
+    if (typeof e.durationMin === "number")
+        return e.durationMin;
+    const s = Date.parse(e.start);
+    const en = e.end ? Date.parse(e.end) : now;
+    return Math.max(0, Math.round((en - s) / 60_000));
+}
+/** Sums a timesheet value map: per row, per day and the grand total. */
+export function timesheetTotals(value, days) {
+    const rows = {};
+    const dayTotals = Object.fromEntries(days.map((d) => [d, 0]));
+    let total = 0;
+    for (const [rowId, cells] of Object.entries(value)) {
+        let r = 0;
+        for (const d of days) {
+            const v = cells[d] ?? 0;
+            r += v;
+            dayTotals[d] = (dayTotals[d] ?? 0) + v;
+        }
+        rows[rowId] = r;
+        total += r;
+    }
+    return { rows, days: dayTotals, total };
+}
+/**
+ * Billable entries → invoice line drafts, one line per project (or task) and rate.
+ * Hours are rounded half-up to 2 decimals per line; amounts stay decimal strings.
+ *
+ * ```ts
+ * toLineItems(entries, "project");
+ * // [{ description: "Mobile app", quantity: "3.33", unitCode: "HUR", unitPrice: "95.00", currency: "EUR", total: "316.35", … }]
+ * ```
+ */
+export function toLineItems(entries, groupBy = "project", opts = {}) {
+    const groups = new Map();
+    for (const e of entries) {
+        if (!e.billable || !e.rate)
+            continue;
+        const project = e.projectLabel ?? e.projectId;
+        const task = e.taskLabel ?? e.taskId;
+        const key = `${groupBy === "task" ? `${project}\u0000${task}` : project}\u0000${e.rate.amount}\u0000${e.rate.currency}`;
+        const g = groups.get(key) ?? { project, task: groupBy === "task" ? task : undefined, minutes: 0, rate: e.rate, ids: [] };
+        g.minutes += entryMinutes(e, opts.now);
+        g.ids.push(e.id);
+        groups.set(key, g);
+    }
+    return [...groups.values()].map((g) => {
+        const quantity = roundHalfUp(String(g.minutes / 60), 2);
+        const description = opts.describe ? opts.describe({ project: g.project, task: g.task }) : [g.project, g.task].filter(Boolean).join(" · ") || "Time";
+        return {
+            description,
+            quantity,
+            unitCode: "HUR",
+            unitPrice: roundHalfUp(g.rate.amount, 2),
+            currency: g.rate.currency,
+            total: multiplyDecimal(quantity, g.rate.amount, 2),
+            entryIds: g.ids,
+        };
+    });
+}
+/** Sum of line totals (decimal string). */
+export const lineItemsTotal = (lines) => (lines.length ? addDecimal(...lines.map((l) => l.total)) : "0.00");

package/dist/scheduler/core/gantt.d.ts

@@ -0,0 +1,63 @@
+import type { IsoDate, WorkCalendar } from "../../locale-data/core/types.js";
+export type GanttTaskType = "task" | "milestone" | "summary";
+export interface GanttTaskCore {
+    id: string;
+    parentId?: string;
+    start: IsoDate;
+    end: IsoDate;
+    type?: GanttTaskType;
+    progress?: number;
+}
+export interface GanttLinkCore {
+    id: string;
+    from: string;
+    to: string;
+    /** First release: `"FS"` (finish-to-start) only. */
+    type?: "FS" | "SS" | "FF" | "SF";
+    /** Days between the predecessor's end and the successor's start. Default 0. */
+    lagDays?: number;
+}
+export interface FlatTask<T extends GanttTaskCore = GanttTaskCore> {
+    task: T;
+    depth: number;
+    /** "1", "1.2", "1.2.3" */
+    wbs: string;
+    /** Row number (1-based) in the full, expanded order. */
+    index: number;
+    hasChildren: boolean;
+    parentId?: string;
+}
+/** Depth-first order of a task forest (input order is kept among siblings). */
+export declare function flattenTasks<T extends GanttTaskCore>(tasks: readonly T[]): FlatTask<T>[];
+/** Visible rows given a set of collapsed task ids. */
+export declare function visibleTasks<T extends GanttTaskCore>(flat: readonly FlatTask<T>[], collapsed: ReadonlySet<string>): FlatTask<T>[];
+/**
+ * Summary tasks (and any task with children) span their children: earliest start, latest end,
+ * duration-weighted progress. Returns new task objects for changed summaries only.
+ */
+export declare function rollupSummaries<T extends GanttTaskCore>(tasks: readonly T[]): T[];
+/**
+ * Cycles in the dependency graph, each as a list of task ids (`["a", "b", "c"]` for a → b → c → a).
+ * Empty when the graph is acyclic.
+ */
+export declare function detectCycles(links: readonly Pick<GanttLinkCore, "from" | "to">[]): string[][];
+/** Would adding `from → to` create a cycle? */
+export declare function createsCycle(links: readonly Pick<GanttLinkCore, "from" | "to">[], from: string, to: string): boolean;
+/** Task length in days or working days (inclusive of both ends). Milestones are 0. */
+export declare function taskDuration(task: Pick<GanttTaskCore, "start" | "end" | "type">, cal?: WorkCalendar, unit?: "workdays" | "days"): number;
+/** Moves a task so it starts on `start`, keeping its length (working days when a calendar is given). */
+export declare function moveTaskTo<T extends GanttTaskCore>(task: T, start: IsoDate, cal?: WorkCalendar, unit?: "workdays" | "days"): T;
+/**
+ * Forward scheduling of finish-to-start links: every successor starts no earlier than the day
+ * after its predecessor ends (+ `lagDays`), skipping non-working days when a calendar is given.
+ * Successors are only pushed later, never pulled earlier. Returns a new array with moved tasks
+ * replaced; unchanged tasks keep their identity. Links in a cycle are ignored.
+ *
+ * ```ts
+ * const next = scheduleForward(tasks, links, trWorkCalendar);
+ * const moved = next.filter((t, i) => t !== tasks[i]);
+ * ```
+ */
+export declare function scheduleForward<T extends GanttTaskCore>(tasks: readonly T[], links: readonly GanttLinkCore[], cal?: WorkCalendar, unit?: "workdays" | "days"): T[];
+/** Links whose successor starts before its predecessor allows (FS violated). */
+export declare function linkViolations(tasks: readonly GanttTaskCore[], links: readonly GanttLinkCore[]): Set<string>;