@outbuild-company/schedule-core 1.0.1 → 1.1.0

package/dist/index.d.cts

@@ -5,10 +5,8 @@
  * This file is the single seam between all components.  All scheduler code
  * depends ONLY on these types — never on the DHTMLX gantt object directly.
  */
-type ActivityId$2 = string;
+type ActivityId$1 = string;
 type LinkId$1 = string;
-type CalendarId$2 = string;
-
 /** Value constants for link types.  Matches `gantt.config.links`. */
 declare const LINK_TYPE: {
     readonly FINISH_TO_START: "0";
@@ -16,172 +14,10 @@ declare const LINK_TYPE: {
     readonly FINISH_TO_FINISH: "2";
     readonly START_TO_FINISH: "3";
 };
-/**
- * RAW DHTMLX row as the scheduler engine and `ScheduleState` see it:
- * snake_case fields, `parent` with the numeric-0 root sentinel,
- * `$source`/`$target` link id arrays, `duration` in HOURS, ids
- * `string | number`. Dates are real Date objects (not ISO strings);
- * serialization for JSON fixtures happens in the recording layer.
- * Sibling shapes: persisted `Activity` (`src/types.ts`) and the
- * pipelines' camelCase `ActivitySnapshot` (`src/columns/types.ts`) —
- * see the `Activity` docblock for the full map.
- */
-interface EngineActivitySnapshot {
-    id: ActivityId$2;
-    start_date: Date;
-    end_date: Date;
-    duration: number;
-    type: ActivityType;
-    parent: ActivityId$2 | 0;
-    constraint_type: ConstraintType | null;
-    constraint_date: Date | null;
-    progress: number;
-    auto_scheduling: boolean;
-    calendar_id: CalendarId$2 | null;
-    /** Outgoing link ids (this activity is the link source) */
-    $source: LinkId$1[];
-    /** Incoming link ids (this activity is the link target) */
-    $target: LinkId$1[];
-    /** Mirrors `Activity.is_critical` (`CriticalFlag`): boolean fresh from the
-     * backend, `'Si'`/`'No'` after the critical-path pass. */
-    is_critical?: boolean | 'Si' | 'No';
-    dragged?: boolean;
-    /**
-     * Display/domain fields carried at runtime via the activityToSnapshot `...a`
-     * spread; declared so state-ports reads them typed instead of casting.
-     */
-    text?: string;
-    description?: string;
-    cost?: number;
-    used_cost?: number;
-    real_cost?: number;
-    hhWorkTime?: number;
-    real_work?: number;
-    ponderator?: number;
-    tasks?: unknown[];
-    real_constraint_type?: ConstraintType | null;
-    last_constraint?: ConstraintType | null;
-    last_constraint_date?: Date | null;
-    last_start_date?: Date | null;
-    date_origin?: Date | null;
-    /**
-     * Backend DB row id (distinct from `id` which is `unique_id`). Optional
-     * because activities created in-session have no backend row yet.
-     */
-    proplannerId?: number;
-    /** Sequential display index used as a short human-readable activity label.
-     * `| undefined` is explicit: rollback before-images assign the prior value,
-     * which is `undefined` for an activity that had no correlative_id yet. */
-    correlative_id?: number | undefined;
-    /**
-     * Project-scoped unique identifier string, user-visible (e.g. "A-0001").
-     * Null for activities that have not been assigned one yet.
-     */
-    custom_id?: string | null;
-    /**
-     * UUID-like correlative assigned by Outbuild. May be string or number
-     * depending on the backend version; absent on in-session-created activities.
-     */
-    unique_correlative_id?: string | number | null;
-    /**
-     * Working-hours mirror of `duration` used by the Duration column renderer to
-     * avoid re-computing hours from days on every render. Stamped by
-     * `parseFromBackend`, `activityCreationPipeline`, and parent-bounds.
-     */
-    for_disable_milestone_duration?: number;
-    /**
-     * View-model visibility bit (UI filters); ex `should_be_showed` of the
-     * DHTMLX task. `visible !== false` = visible; default true.
-     */
-    visible?: boolean;
-    /** Checkbox-selection bit owned by the selection pipeline. */
-    checked?: boolean;
-    /** Visible (UI-layer) checkbox state, kept in sync with `checked`. */
-    visibleChecked?: boolean;
-    /** Signal to the bridge that `visibleChecked` was set this dispatch. */
-    mustApplyVisibleChecked?: boolean;
-    /**
-     * Pending Schedule Impact Requests freezing this activity (id-only
-     * reduction; non-empty ⇒ frozen). Carried verbatim from the backend payload.
-     * Only for dynamic setActivityField writes + arbitrary backend passthrough;
-     * all known fields are declared above.
-     */
-    pendingRequests?: PendingRequest[];
-    earlyStart?: Date | null;
-    earlyFinish?: Date | null;
-    lateStart?: Date | null;
-    lateFinish?: Date | null;
-    totalSlack?: number | null;
-    freeSlack?: number | null;
-    /** Expected-progress baseline output, written by the expected-progress pass. */
-    expected_progress?: number;
-    /** Lookahead membership; the core derives it in promote/demote (R4). */
-    is_lookahead?: boolean;
-    /** Client-side "new, unsaved" marker (not persisted as such). */
-    isNewActivity?: true | null;
-    /** Descendant new-activity id bookkeeping (R15, temporal). */
-    newActivitiesArray?: ActivityId$2[];
-    /** `newActivitiesArray.length > 0` mirror (R15, temporal). */
-    hasNewActivities?: boolean;
-    /** Activity modification log carried from the backend. */
-    activityModifications?: unknown[];
-    /** Load-derived: the activity fell back to the default calendar. */
-    assignedDefaultCalendar?: boolean;
-    /** Backend flag: has persisted children. */
-    has_childs?: boolean;
-    /** Backend flag: ponderator set manually (not auto-distributed). */
-    hasCustomPonderator?: boolean;
-    /** Backend aggregate: recursive duration sum. */
-    sumOfDurationRecursively?: number;
-    /** Backend row ids (distinct from the domain `id`). */
-    ganttId?: number;
-    sectorId?: number;
-    companyId?: number;
-    /** Subcontract column id + its raw backend object. */
-    subcontractId?: number | null;
-    subcontract?: unknown;
-    /** Responsibility / tag columns (arrays of backend rows). */
-    responsables?: unknown[];
-    tags?: unknown[];
-    /** Active baseline points overlaid at load. */
-    baseline_points?: BaselinePoint[];
-    /** Backend timestamps. */
-    createdAt?: string;
-    updatedAt?: string;
-    old_progress_registered?: number;
-    old_duration_registered?: number;
-    old_cost_registered?: number;
-    old_used_cost_registered?: number;
-    old_real_cost_registered?: number;
-    old_hhWorkTime_registered?: number;
-    /** Mirror of the constraint before the last change (constraint cluster). */
-    constraint_type_old?: ConstraintType | null;
-    /** `type === 'milestone'` cache flipped by the duration pipeline. */
-    is_milestone?: boolean;
-    /** DHTMLX markers consumed by the bridge / render layer. */
-    $keep_constraints?: boolean;
-    $rendered_type?: ActivityType;
-    $no_start?: boolean;
-    $no_end?: boolean;
-    status?: 'Waiting' | 'Doing' | 'Done';
-    progressSolidColor?: string;
-    color?: string;
-    /** Flags a recursive complete/uncomplete from the action-button flow. */
-    progressChangedByActionButton?: boolean;
-    custom_predecessors?: string;
-    /** Backend typo preserved (single 'c'). */
-    custom_sucessors?: string;
-    start_base?: Date;
-    end_base?: Date;
-    duration_base?: number;
-    cost_base?: number;
-    work_base?: number;
-    expected_progress_base?: number;
-}
 interface LinkSnapshot {
     id: LinkId$1;
-    source: ActivityId$2;
-    target: ActivityId$2;
+    source: ActivityId$1;
+    target: ActivityId$1;
     type: LinkType;
     lag: number;
     /**
@@ -208,6 +44,11 @@ interface LinkSnapshot {
     /** BE row id (distinct from the schedule-level `id`). */
     proplannerId?: number;
 }
+/**
+ * Gantt-wide flags that influence scheduling decisions.  Captured at the
+ * boundary of every scheduling run.
+ */
+type MutableLinkField = 'lag' | 'type';
 
 /**
  * Constraint Rules — single source of truth.
@@ -259,21 +100,13 @@ declare const CONSTRAINT_TYPE: {
  * DHTMLX convention) and camelCase for everything else, per Q14 in
  * SCHEDULE_CORE_API.md.
  */
-type ActivityId$1 = string;
+type ActivityId = string;
 type LinkId = string;
-type CalendarId$1 = string;
+type CalendarId = string;
 type ActivityType = 'project' | 'task' | 'milestone';
 
 /** DHTMLX link kinds: 0 = FS, 1 = SS, 2 = FF, 3 = SF. */
 type LinkType = '0' | '1' | '2' | '3';
-/**
- * Critical-path output flag. Carries two historical shapes: `parseFromBackend`
- * stores a boolean, and the critical-path pass (`initial-passes.ts`) overwrites
- * it with the DHTMLX string `'Si'`/`'No'`. Both are observed at runtime (the
- * CP / paste tests assert against `'Si'`/`'No'`; `parseFromBackend` against
- * boolean), so the type unions all three rather than lying with a bare boolean.
- */
-type CriticalFlag = boolean | 'Si' | 'No';
 /** Direction for closest-work-time snapping. */
 type WorkTimeDirection = 'future' | 'past';
 declare const WORK_TIME_DIRECTION: {
@@ -351,9 +184,6 @@ interface BaselinePoint {
  * matches the backend convention. No index signature — every field is
  * explicit. New backend fields must be added here and preserved by
  * `normalize-activity.ts`.
- *
- * Companion type for runtime mutations: see `ActivityRuntime` below,
- * which extends this with `DhtmlxHeritageFields`.
  */
 /**
  * A pending SIR freezing an activity, reduced to the only field the core
@@ -363,121 +193,101 @@ interface BaselinePoint {
 interface PendingRequest {
     id: string;
 }
-/**
- * PUBLIC persisted domain model — what `core.getActivityView()` returns and
- * what the backend payload parses into. Fields are snake_case (backend +
- * DHTMLX convention); `duration` is in DAYS at this boundary.
- *
- * The package has three activity shapes — one per layer:
- * - `Activity` (this): public, persisted, snake_case.
- * - `ActivitySnapshot` (`src/columns/types.ts`): camelCase + derived
- *   fields (hasChildren, isMilestone…); what column pipelines read.
- *   Built per-read by `state-ports.ts`; never persisted.
- * - `EngineActivitySnapshot` (`src/autoscheduler/types.ts`): raw DHTMLX
- *   row (snake_case + `parent`/`$source`/`$target`, hours-based
- *   duration); what `ScheduleState` stores and the scheduler engine
- *   consumes. Translation Activity ↔ engine: `src/dispatch/conversion.ts`.
- */
-interface Activity {
-    id: ActivityId$1;
-    /** Parent's `id`, or `'0'` when the activity is a root. */
-    parent: ActivityId$1 | '0';
-    text: string;
+declare const STATUS: {
+    readonly DONE: "Done";
+    readonly OVERDUE: "Overdue";
+    readonly ADVANCEMENT: "Advancement";
+    readonly WAITING: "Waiting";
+    readonly DOING: "Doing";
+};
+type ActivityStatus = (typeof STATUS)[keyof typeof STATUS];
+interface CriticalPathResult {
+    earlyStart: Date | null;
+    earlyFinish: Date | null;
+    lateStart: Date | null;
+    lateFinish: Date | null;
+    totalSlackHours: number | null;
+}
+interface ActivityBaselineSnapshot {
+    startDate: Date | null;
+    endDate: Date | null;
+    durationDays: number;
+    cost: number;
+    workHours: number;
+}
+interface CoreBaselinePoint {
+    startDate: Date | null;
+    endDate: Date | null;
+    durationDays: number;
+    cost: number;
+    workHours: number;
+    versionId: number | null;
+    isActiveVersion: boolean;
+    baseCalendarId: CalendarId | null;
+    hoursPerDay: number | null;
+    hoursPerWeek: number | null;
+}
+interface CoreActivity {
+    id: ActivityId;
+    proplannerId: number | null;
+    parentId: ActivityId | null;
+    name: string;
     description: string;
     type: ActivityType;
-    start_date: Date;
-    end_date: Date;
-    duration: number;
-    constraint_type: ConstraintType | null;
-    constraint_date: Date | null;
-    auto_scheduling: boolean;
-    calendar_id: CalendarId$1 | null;
-    /**
-     * True when the activity had no valid calendar of its own and inherited the
-     * project default at load (its backend `calendarId` was null/undefined or a
-     * dangling reference). Set by `parseFromBackend` when `resolveCalendarId`
-     * falls back. The legacy DHTMLX worker computed this; the core owns calendar
-     * assignment now, so it owns the flag. The UI uses it to surface
-     * default-assigned activities. See `CALENDARS.md`.
-     */
-    assignedDefaultCalendar?: boolean;
+    startDate: Date;
+    endDate: Date;
+    durationHours: number;
+    constraintType: ConstraintType | null;
+    constraintDate: Date | null;
+    autoScheduling: boolean;
+    calendarId: CalendarId | null;
+    assignedDefaultCalendar: boolean;
+    dateOrigin: Date | null;
     progress: number;
     cost: number;
-    used_cost: number;
-    real_cost: number;
-    hhWorkTime: number;
-    real_work: number;
+    usedCost: number;
+    realCost: number;
+    workHours: number;
+    realWorkHours: number;
     ponderator: number;
-    correlative_id: number;
-    is_lookahead: boolean;
-    /**
-     * Bit de visibilidad del view-model (filtros de UI); ex `should_be_showed`
-     * del task DHTMLX. `visible !== false` = visible; default true. Escrito por
-     * el intent `visibility-set` (prop-only) y por `parseFromBackend` al load.
-     */
-    visible?: boolean;
-    newActivitiesArray: ActivityId$1[];
-    activityModifications: unknown[];
-    /**
-     * Backend DB row id (distinct from the core `id`, which is `unique_id`).
-     * Captured from `a.id` in `parseActivity`; `undefined` for activities
-     * created in-session (no backend id yet). Used by save dirty-detection to
-     * tell persisted activities from new ones. Mirrors `Link.proplannerId`.
-     */
-    proplannerId?: number;
-    unique_correlative_id: string;
-    ganttId: number;
-    sectorId: number;
-    companyId: number;
-    subcontractId: number | null;
-    subcontract: unknown;
-    custom_id: string | null;
     hasCustomPonderator: boolean;
-    has_childs: boolean;
-    sumOfDurationRecursively: number;
-    /**
-     * Critical-path outputs (poblados cuando corre el CP: en background tras la
-     * carga vía `criticalPathReady`, o tras cada dispatch). `undefined` si el CP
-     * aún no corrió. `is_critical` es string DHTMLX (`'Si'`/`'No'`) post-CP,
-     * boolean recién parseado del backend — ver `CriticalFlag`.
-     */
-    earlyStart?: Date | null;
-    earlyFinish?: Date | null;
-    lateStart?: Date | null;
-    lateFinish?: Date | null;
-    totalSlack?: number | null;
-    freeSlack: number | null;
-    is_critical: CriticalFlag;
+    correlativeId: number;
+    uniqueCorrelativeId: string;
+    customId: string | null;
+    subcontractId: number | null;
+    isLookahead: boolean;
+    hasLookaheadTasks: boolean;
+    newActivityIds: ActivityId[];
     hasNewActivities: boolean;
-    isNewActivity: true | null;
-    date_origin?: Date | null;
-    /**
-     * Active-baseline snapshots for this activity (backend
-     * `sectorbaselinepoint[]`). Passthrough — carried verbatim so the
-     * frontend baseline columns and the ponderator computation can read the
-     * ACTIVE point via `getActiveBaseline`. `undefined` when the activity has
-     * no baseline (e.g. created in-session after the snapshot).
-     */
-    baseline_points?: BaselinePoint[];
-    tasks: unknown[];
-    responsables: unknown[];
-    tags: unknown[];
-    /**
-     * Pending Schedule Impact Requests (SIRs) freezing this activity. The
-     * schedule load path (`sector.controller.js`) already filters to
-     * `state==='pending'` and sends `{ id }` only, so the core stores just the
-     * id — enough to name the SIR when emitting a `sir-auto-reject` effect.
-     * Non-empty ⇒ the activity is frozen (`isFrozen`). The full SIR record lives
-     * in the front's Redux, not here. See `SIR_MAP.md`.
-     */
-    pendingRequests: PendingRequest[];
-    createdAt: string;
-    updatedAt: string;
+    isNewActivity?: true | null;
+    pendingRequestIds: string[];
+    responsableIds: string[];
+    tagIds: string[];
+    baselinePoints: CoreBaselinePoint[];
+    baselineSnapshot: ActivityBaselineSnapshot | null;
+    recursiveDurationHours: number;
+    isCritical: boolean;
+    freeSlackHours: number | null;
+    expectedProgress: number | null;
+    expectedProgressBaseline: number | null;
+    status: ActivityStatus | null;
+    criticalPath: CriticalPathResult | null;
+    /** Internal reversible leaf→project promotion state; never serialized. */
+    promotionRestore: {
+        type: 'task' | 'milestone';
+        startDate: Date;
+        endDate: Date;
+        durationHours: number;
+        expectedProgressBaseline: number | null;
+        constraintType: ConstraintType;
+        constraintDate: Date | null;
+        progress: number;
+    } | null;
 }
 interface Link {
     id: LinkId;
-    source: ActivityId$1;
-    target: ActivityId$1;
+    source: ActivityId;
+    target: ActivityId;
     type: LinkType;
     lag: number;
     ganttId?: number;
@@ -494,10 +304,12 @@ interface CalendarWorktime {
      *                   (supports per-day variation, e.g. a short Friday,
      *                    and multi-shift split days like `["8-12","13-17"]`)
      *
-     * Single source of truth: this is exactly what `parseFromBackend` emits —
-     * a working day ALWAYS carries its resolved windows (the parser resolves
-     * the default-hours fallback at parse time). The vendored work-calendar
-     * engine natively also accepts a boolean `true` per day (DHTMLX
+     * Single source of truth: this is exactly what `parseFromBackend` emits. A
+     * usable working day carries its resolved windows; `[]` is reserved for a
+     * catalog calendar that declares the day as working but provides no usable
+     * shift anywhere. Those catalog-only calendars remain selectable/persistable
+     * but are deliberately not registered as arithmetic calendars. The vendored
+     * work-calendar engine natively also accepts a boolean `true` per day (DHTMLX
      * contract), but that form never appears in the domain `Calendar`; it is
      * reserved for the engine-facing internals (`SnapshotWorktime`,
      * synthetic replay fixtures).
@@ -508,8 +320,8 @@ interface CalendarWorktime {
     days: Array<false | string[]>;
     /**
      * Default working-hour windows (`"HH:MM-HH:MM"`). Used as the engine's
-     * global fallback. `parseFromBackend` sets it to the first working day's
-     * windows.
+     * global fallback. `parseFromBackend` sets it to the first usable working
+     * day's windows, or `[]` when the calendar has no usable shift.
      */
     hours: string[];
     /**
@@ -523,7 +335,7 @@ interface CalendarWorktime {
      *   - `string[]`           → use these `"HH:MM-HH:MM"` windows instead
      *                            of the default `hours`
      *
-     * Source: `BackendCalendar.exceptiondays[]` after the adapter expands
+     * Source: `BackendCalendarInput.exceptiondays[]` after the adapter expands
      * `from_date`/`to_date` ranges into individual UTC days.
      */
     dates?: Record<string, false | string[]>;
@@ -531,7 +343,7 @@ interface CalendarWorktime {
     customWeeks?: Record<string, unknown>;
 }
 interface Calendar {
-    id: CalendarId$1;
+    id: CalendarId;
     /** Display name. Used by the DHTMLX calendar-selector column. */
     name: string;
     worktime: CalendarWorktime;
@@ -613,6 +425,68 @@ interface EntityChange<T> {
     after: Readonly<T> | null;
 }
 
+declare const COLUMN: {
+    readonly REAL_WORK: "real_work";
+    readonly REAL_COST: "real_cost";
+    readonly EXPECTED_PROGRESS: "expected_progress";
+    readonly EXPECTED_PROGRESS_BASE: "expected_progress_base";
+    readonly START_BASE: "start_base";
+    readonly END_BASE: "end_base";
+    readonly DURATION_BASE: "duration_base";
+    readonly COST_BASE: "cost_base";
+    readonly WORK_BASE: "work_base";
+    readonly CALENDAR_DURATION: "calendarDuration";
+    readonly IS_CRITICAL: "is_critical";
+    readonly EARLY_START: "earlyStart";
+    readonly EARLY_FINISH: "earlyFinish";
+    readonly LATE_START: "lateStart";
+    readonly LATE_FINISH: "lateFinish";
+    readonly FREE_SLACK: "freeSlack";
+    readonly TOTAL_SLACK: "totalSlack";
+    readonly CORRELATIVE_ID: "correlative_id";
+    readonly UNIQUE_CORRELATIVE_ID: "unique_correlative_id";
+    readonly PONDERATOR: "ponderator";
+    readonly STATUS: "status";
+    readonly TEXT: "text";
+    readonly DESCRIPTION: "description";
+    readonly DURATION: "duration";
+    readonly PROGRESS: "progress";
+    readonly COST: "cost";
+    readonly USED_COST: "used_cost";
+    readonly HH_WORK_TIME: "hhWorkTime";
+    readonly START_DATE: "start_date";
+    readonly END_DATE: "end_date";
+    readonly CONSTRAINT_TYPE: "constraint_type";
+    readonly CONSTRAINT_DATE: "constraint_date";
+    readonly CALENDAR_ID: "calendar_id";
+    readonly CUSTOM_ID: "custom_id";
+    readonly SUBCONTRACT_ID: "subcontractId";
+    readonly RESPONSABLES: "responsables";
+    readonly TAGS: "tags";
+    readonly CUSTOM_PREDECESSORS: "custom_predecessors";
+    readonly CUSTOM_SUCESSORS: "custom_sucessors";
+};
+type ColumnName = (typeof COLUMN)[keyof typeof COLUMN];
+
+/**
+ * Task creation pipeline — types.
+ *
+ * Ports the pure parts of `src/assets/js/custom_actions/createTask/` into a
+ * functional pipeline that replay tests (and eventually prod) can invoke
+ * against an adapter instead of the live gantt.
+ */
+
+/**
+ * Closed, canonical contract for create/paste overrides: camelCase, working
+ * hours, limited to the fields a caller may seed on a new activity. Identity
+ * and structure (`id`/`parentId`/`correlativeId`/`uniqueCorrelativeId`),
+ * derived/CP/baseline outputs and view-state are NOT overridable. PP2 adapts
+ * its own vocabulary to this contract in step 9.
+ */
+declare const CREATION_OVERRIDE_FIELD_LIST: readonly ["name", "description", "type", "startDate", "durationHours", "constraintType", "constraintDate", "calendarId", "assignedDefaultCalendar", "autoScheduling", "progress", "cost", "usedCost", "realCost", "workHours", "realWorkHours", "ponderator", "hasCustomPonderator", "customId", "subcontractId", "responsableIds", "tagIds", "isLookahead"];
+type CreationOverrideField = (typeof CREATION_OVERRIDE_FIELD_LIST)[number];
+type CreationOverrides = Partial<Pick<CoreActivity, CreationOverrideField>>;
+
 /**
  * Public dispatch types — see Q8/Q9/Q10 in SCHEDULE_CORE_API.md.
  *
@@ -635,8 +509,8 @@ interface EntityChange<T> {
  */
 type LinksBatchOperation = {
     kind: 'create';
-    source: ActivityId$1;
-    target: ActivityId$1;
+    source: ActivityId;
+    target: ActivityId;
     type: LinkType;
     lag?: number;
     linkId?: LinkId;
@@ -652,7 +526,7 @@ type LinksBatchOperation = {
 
 type DispatchAction = {
     kind: 'inline-edit';
-    activityId: ActivityId$1;
+    activityId: ActivityId;
     column: string;
     newValue: unknown;
 } | {
@@ -665,7 +539,7 @@ type DispatchAction = {
      */
     kind: 'dates-batch';
     edits: ReadonlyArray<{
-        activityId: ActivityId$1;
+        activityId: ActivityId;
         column: 'start_date' | 'end_date';
         newValue: unknown;
     }>;
@@ -687,15 +561,15 @@ type DispatchAction = {
      */
     kind: 'bulk-edit';
     edits: ReadonlyArray<{
-        activityId: ActivityId$1;
+        activityId: ActivityId;
         column: string;
         newValue: unknown;
     }>;
     eventSource?: string;
 } | {
     kind: 'link-create';
-    source: ActivityId$1;
-    target: ActivityId$1;
+    source: ActivityId;
+    target: ActivityId;
     type: LinkType;
     /** Lag in DAYS (public boundary unit; converted to working hours inside). */
     lag: number;
@@ -717,7 +591,7 @@ type DispatchAction = {
 } | {
     kind: 'activity-create';
     /** Where to put the new activity. Use `'0'` for root. */
-    parentId: ActivityId$1 | '0';
+    parentId: ActivityId | '0';
     /**
      * Optional — insert the new activity immediately AFTER this sibling.
      * If omitted (and `beforeSiblingId` also omitted), the new activity
@@ -725,7 +599,7 @@ type DispatchAction = {
      * currently be a child of `parentId`, otherwise the dispatch is
      * rejected. Mutually exclusive with `beforeSiblingId`.
      */
-    afterSiblingId?: ActivityId$1 | undefined;
+    afterSiblingId?: ActivityId | undefined;
     /**
      * Optional — insert the new activity immediately BEFORE this sibling.
      * Use case: "insert as first child" (`beforeSiblingId = currentFirstChild`)
@@ -733,25 +607,20 @@ type DispatchAction = {
      * The sibling must currently be a child of `parentId`, otherwise the
      * dispatch is rejected. Mutually exclusive with `afterSiblingId`.
      */
-    beforeSiblingId?: ActivityId$1 | undefined;
+    beforeSiblingId?: ActivityId | undefined;
     /**
-     * Optional field overrides applied on top of the defaults built by
-     * the creation pipeline. Common cases: `text`, `duration`,
-     * `start_date`, `constraint_type`, `constraint_date`, `calendar_id`.
-     *
-     * Only keys that name a real model field are honored — the pipeline
-     * drops any incidental non-model key (dhtmlx runtime junk, lightbox UI
-     * state) so it can never phantom onto the created activity. `name` is
-     * accepted as an alias for `text` (mapped, then dropped as a raw key).
-     * See `isDroppableOverrideKey` in `creation/defaults.ts`.
+     * Canonical field overrides applied on top of the creation defaults —
+     * camelCase, working hours, limited to creation-writable fields
+     * (`CreationOverrides`). Identity/structure and derived outputs are not
+     * overridable.
      */
-    overrides?: Partial<Activity>;
+    overrides?: CreationOverrides;
     /**
      * Deterministic activity id — used by tests and by replay flows
      * (paste, undo) that need to assign a specific id. If omitted, the
      * core's internal id generator allocates one.
      */
-    activityId?: ActivityId$1;
+    activityId?: ActivityId;
     /**
      * Where this create originated from — passed through to the
      * `schedule_activity_creation` Amplitude event. Free-form string
@@ -766,7 +635,7 @@ type DispatchAction = {
      * Operation is atomic — if any id is missing, the whole dispatch is
      * rejected before mutating anything.
      */
-    activityIds: ReadonlyArray<ActivityId$1>;
+    activityIds: ReadonlyArray<ActivityId>;
     eventSource?: string;
 } | {
     kind: 'activity-move';
@@ -774,16 +643,17 @@ type DispatchAction = {
      * The activity to move. Single-id only — for batch reorder use
      * multiple dispatches (each one observes the post-previous state).
      */
-    activityId: ActivityId$1;
+    activityId: ActivityId;
     /** Destination parent. Same as current parent = reorder within. */
-    parentId: ActivityId$1 | '0';
+    parentId: ActivityId | '0';
     /**
      * Optional — position the moved activity immediately below this
      * sibling. If omitted, appended as the last child of `parentId`.
      * The sibling must currently be a child of `parentId`; otherwise
-     * the dispatch is rejected.
+     * the dispatch is rejected. Mutually exclusive with `beforeSiblingId`.
      */
-    afterSiblingId?: ActivityId$1;
+    afterSiblingId?: ActivityId;
+    beforeSiblingId?: ActivityId;
     eventSource?: string;
 } | {
     kind: 'activity-indent';
@@ -793,7 +663,7 @@ type DispatchAction = {
      * selected set, so consecutive selected siblings all land under the
      * same anchor (matches legacy `findPreviousNonSelectedSibling`).
      */
-    activityIds: ReadonlyArray<ActivityId$1>;
+    activityIds: ReadonlyArray<ActivityId>;
     eventSource?: string;
 } | {
     kind: 'activity-outdent';
@@ -802,7 +672,7 @@ type DispatchAction = {
      * selected siblings via initial-index capture (matches legacy
      * `initialFirstSiblings` + `initialTaskIndexes` pre-loop setup).
      */
-    activityIds: ReadonlyArray<ActivityId$1>;
+    activityIds: ReadonlyArray<ActivityId>;
     eventSource?: string;
 } | {
     /**
@@ -825,7 +695,7 @@ type DispatchAction = {
      * with newValue=0 or newValue=100.
      */
     kind: 'activity-set-progress';
-    activityId: ActivityId$1;
+    activityId: ActivityId;
     /** Strictly 0 (uncomplete) or 100 (complete). */
     newValue: 0 | 100;
     eventSource?: string;
@@ -842,7 +712,7 @@ type DispatchAction = {
      * critical path.
      */
     kind: 'selection-toggle';
-    activityId: ActivityId$1;
+    activityId: ActivityId;
     /** Checkbox state AFTER the user click. */
     isChecked: boolean;
     /**
@@ -851,7 +721,7 @@ type DispatchAction = {
      * is load-time-stale until TODO #10). When omitted, the core
      * falls back to its own snapshots.
      */
-    frozenIds?: ReadonlyArray<ActivityId$1>;
+    frozenIds?: ReadonlyArray<ActivityId>;
     /**
      * Enable the upward auto-check of ancestors when all their
      * checkable children become selected. Mirrors the (inverted)
@@ -867,7 +737,7 @@ type DispatchAction = {
      * `selection-toggle`.
      */
     kind: 'selection-replace';
-    activityIds: ReadonlyArray<ActivityId$1>;
+    activityIds: ReadonlyArray<ActivityId>;
     eventSource?: string;
 } | {
     /**
@@ -881,7 +751,7 @@ type DispatchAction = {
      * path, no undo step. Idempotent.
      */
     kind: 'visibility-set';
-    visibleIds: ReadonlyArray<ActivityId$1>;
+    visibleIds: ReadonlyArray<ActivityId>;
     eventSource?: string;
 } | {
     /**
@@ -893,9 +763,21 @@ type DispatchAction = {
      * ChangeSet; no autoscheduler, no CP. Idempotent.
      */
     kind: 'sir-sync';
-    activityId: ActivityId$1;
+    activityId: ActivityId;
     pendingRequests: ReadonlyArray<PendingRequest>;
     eventSource?: string;
+} | {
+    /**
+     * Synchronize the schedule-side flags owned by Lookahead task
+     * creation/deletion. The Lookahead records remain at the application
+     * boundary; the core owns these flags because they affect schedule
+     * editing rules and the public activity view.
+     */
+    kind: 'activity-lookahead-sync';
+    activityIds: ReadonlyArray<ActivityId>;
+    isLookahead: boolean;
+    hasLookaheadTasks: boolean;
+    eventSource?: string;
 } | {
     /**
      * Bulk paste (2026-06-08). Creates N activities (preserving the
@@ -920,22 +802,24 @@ type DispatchAction = {
      * is derived from the sibling.
      */
     destination: {
-        parentId: ActivityId$1 | '0';
+        parentId: ActivityId | '0';
         index: number;
     } | {
-        afterSiblingId: ActivityId$1;
+        afterSiblingId: ActivityId;
     };
     /**
      * The activity the paste is anchored to (the single selected row).
      * Used as the custom_id reference for pasted children. Replaces
      * the legacy `gantt.pasteReferenceActivity` instance flag.
      */
-    referenceActivityId: ActivityId$1;
+    referenceActivityId: ActivityId;
     /**
      * Activities to create, in tree order (parents before children).
      * `originalId` / `originalParentId` are the ids from the copied
      * payload; the core remaps them to freshly allocated ids and uses
-     * the remap to re-hang the hierarchy and the links.
+     * the remap to re-hang the hierarchy and the links. A pasted activity
+     * may carry its visible baseline snapshot, but it is not enrolled in an
+     * already-created historical baseline.
      */
     activities: ReadonlyArray<PastedActivityInput>;
     /**
@@ -947,26 +831,30 @@ type DispatchAction = {
     eventSource?: string;
 };
 interface PastedActivityInput {
-    readonly originalId: ActivityId$1;
-    readonly originalParentId: ActivityId$1 | '0';
-    readonly overrides: Partial<Activity>;
+    readonly originalId: ActivityId;
+    readonly originalParentId: ActivityId | '0';
+    /**
+     * Optional explicit destination id. Production normally omits it and lets
+     * the adapter allocate; recorder replay supplies MAIN's observed id so the
+     * whole-tree oracle can compare identity without an invented id remap.
+     */
+    readonly activityId?: ActivityId;
+    readonly overrides: CreationOverrides;
+    readonly baselineSnapshot?: ActivityBaselineSnapshot | null;
 }
 interface PastedLinkInput {
-    readonly source: ActivityId$1;
-    readonly target: ActivityId$1;
+    readonly source: ActivityId;
+    readonly target: ActivityId;
     readonly type: LinkType;
     /** Lag in DAYS (public boundary unit; converted to working hours inside). */
     readonly lag: number;
+    readonly linkId?: LinkId;
 }
-/** Unit of duration/lag at the public boundary. Default 'days'. */
-type OutputUnit = 'days' | 'hours';
 interface DispatchOptions {
     /** Skip the autoscheduler pass after the mutation. Default: false. */
     skipAutoSchedule?: boolean;
     /** Skip the CP recompute after the mutation. Default: false. */
     skipCriticalPath?: boolean;
-    /** 'days' default; the DHTMLX bridge passes 'hours' to skip conversion. */
-    outputUnit?: OutputUnit;
     /**
      * Unit of the INPUT `newValue` for unit-bearing inline-edit columns (today:
      * duration). Default 'days' (public contract; card + tests send days). The
@@ -974,7 +862,7 @@ interface DispatchOptions {
      * the bridge passes 'hours' for those edits → the pipeline skips the days→hours
      * conversion instead of double-converting.
      */
-    inputUnit?: OutputUnit;
+    inputUnit?: 'days' | 'hours';
 }
 type DispatchResult = {
     ok: true;
@@ -994,7 +882,7 @@ type DispatchResult = {
      * handlers (delete/move/paste); stripped before the result reaches the
      * bridge in the Wave-3 integration.
      */
-    __beforeSnap?: ReadonlyMap<string, EngineActivitySnapshot>;
+    __beforeSnap?: ReadonlyMap<string, CoreActivity>;
     /**
      * INTERNAL (undo / B4). Incident links of deleted activities, keyed by
      * STRING id (EntityChange link ids are String()-normalized). Carries the
@@ -1030,7 +918,7 @@ interface TrackingEvent {
  */
 type ScheduleEffect = {
     kind: 'sir-auto-reject';
-    activityId: ActivityId$1;
+    activityId: ActivityId;
     /** Backend SIR id == the front Redux item id (see parseFromBackend A1). */
     sirId: string;
     reason: 'date_changed' | 'activity_deleted';
@@ -1044,13 +932,22 @@ type ScheduleEffect = {
  */
 interface ConstraintWarning {
     kind: 'constraint_violation';
-    activityId: ActivityId$1;
+    activityId: ActivityId;
     constraintType: ConstraintType;
     constraintDate: Date;
     /** The projected date that violated (start or end, per constraint type). */
     projectedDate: Date;
     messageKey: string;
 }
+interface ViewStatePropChange {
+    readonly before: boolean;
+    readonly after: boolean;
+}
+interface ViewStateChange {
+    readonly activityId: ActivityId;
+    readonly checked?: ViewStatePropChange;
+    readonly visible?: ViewStatePropChange;
+}
 interface ChangeSet {
     source: DispatchAction | {
         kind: 'init';
@@ -1059,10 +956,11 @@ interface ChangeSet {
     } | {
         kind: 'redo';
     };
-    activities: ReadonlyArray<EntityChange<Activity>>;
+    activities: ReadonlyArray<EntityChange<CoreActivity>>;
     links: ReadonlyArray<EntityChange<Link>>;
     calendars: ReadonlyArray<EntityChange<Calendar>>;
     trackingEvents: ReadonlyArray<TrackingEvent>;
+    viewState?: ReadonlyArray<ViewStateChange>;
     /**
      * Optional — present only when the dispatch produced side effects. Builders
      * that emit none omit it; consumers read `changeSet.effects ?? []`. Kept
@@ -1083,133 +981,69 @@ interface ProjectWorkHours {
     endHour: string;
 }
 
-/**
- * Backend payload shapes — exactly as the Outbuild server returns.
- *
- * The core accepts these directly in the constructor and parses them into
- * normalized internal types.  Keeping these as the public input type means
- * any consumer of the schedule API (frontend, node_server, future) speaks
- * the same contract.
- *
- * Validated against the real mocks in
- * `packages/schedule-core/src/testing/projects/startDate/`.
- */
-
-/** Calendar shift definition — one shift per day, CSV-encoded strings. */
-interface BackendShift {
-    id: number;
-    /**
-     * Encoded shift string for the week:
-     * `false,8:00,8:00,8:00,8:00,8:00,false-false,16:00,...,false`
-     * left side = starts, right side = ends, each CSV is Sun..Sat.
-     * `false` means non-working day.
-     */
+interface BackendShiftInput {
     shift_string: string;
-    correlative_id: number;
-    createdAt: string;
-    updatedAt: string;
-    calendarId: number;
-    calendarexceptiondayId: number | null;
 }
-/** Backend calendar exception (per-date override). */
-interface BackendCalendarException {
-    id: number;
-    date: string;
-    /** Optional shifts for this specific exception. */
-    shifts?: BackendShift[];
-    [key: string]: unknown;
+interface BackendCalendarExceptionInput {
+    from_date: string;
+    to_date: string;
+    workable: boolean;
+    shifts?: BackendShiftInput[];
 }
-/** Calendar as returned by the server. */
-interface BackendCalendar {
+interface BackendCalendarInput {
     id: number;
     name: string;
-    unique_id: number;
     is_default: boolean;
-    /** CSV of Sun..Sat: `"0,1,1,1,1,1,0"` (0 = non-working, 1 = working). */
+    baseDefault?: boolean;
     working_days: string;
-    /** CSV of shift starts per day: `"false,8:00,8:00,8:00,8:00,8:00,false"`. */
-    shift_start: string;
-    /** CSV of shift ends per day: `"false,16:00,...,false"`. */
-    shift_end: string;
-    exceptiondays: BackendCalendarException[];
-    baseexceptiondays?: BackendCalendarException[];
-    shifts: BackendShift[];
-    status: boolean;
-    companyId: number;
-    ganttId: number | null;
-    userId: number;
-    sectorId: number;
-    createdAt: string;
-    updatedAt: string;
-    [key: string]: unknown;
+    shift_start: string | null;
+    shift_end: string | null;
+    shifts: BackendShiftInput[];
+    exceptiondays: BackendCalendarExceptionInput[];
+    baseexceptiondays?: BackendCalendarExceptionInput[];
 }
-/**
- * Activity exactly as the Outbuild server returns it — the raw, untrusted
- * input boundary. Dates are strings, `duration` is in backend DAYS, and field
- * names are the backend's (snake_case, `unique_id`, `parent_id`, `name`).
- *
- * `parseFromBackend` is the only place that consumes it: it validates and
- * normalizes each row into the internal model. Nothing else in the core should
- * read a `BackendActivityInput` after parse.
- */
 interface BackendActivityInput {
-    /** Database row id. Distinct from `unique_id`. */
     id: number;
-    /** Canonical schedule id (used by links and DHTMLX). String-encoded number. */
     unique_id: string;
-    /** Parent's `unique_id`, or `"0"` for root. */
     parent_id: string;
     unique_correlative_id: string;
     correlative_id: number;
     name: string;
-    description: string;
+    description: string | null;
     type: 'project' | 'task' | 'milestone';
-    /** Format: `"YYYY/MM/DD H:MM"` (server local, see dateFormat in sector). */
     start_date: string;
     end_date: string;
     duration: number;
-    /**
-     * Constraint label in plain English: `"As soon As Possible"`,
-     * `"Start no earlier than"`, etc.  Mapped to internal `ConstraintType`.
-     */
-    constraint: string;
-    /** Optional constraint date — server uses ISO 8601 or null. */
+    constraint: string | null;
     constraint_date?: string | null;
     progress: number;
     cost: number;
-    used_cost: number;
-    real_cost: number;
+    used_cost: number | null;
+    real_cost: number | null;
     hhWorkTime: number;
-    real_work: number;
-    ponderator: number;
+    real_work: number | null;
+    ponderator: number | null;
     hasCustomPonderator: boolean;
     has_childs: boolean;
     isOnLookahead: boolean;
-    sumOfDurationRecursively: number;
+    sumOfDurationRecursively: number | null;
     freeSlack: number | null;
     is_critical: boolean;
-    newActivitiesArray: string;
-    hasNewActivities: boolean;
+    newActivitiesArray: string | (string | number)[] | null;
+    hasNewActivities: boolean | null;
     isNewActivity: true | null;
     custom_id: string | null;
     ganttId: number;
     sectorId: number;
     companyId: number;
-    calendarId: number;
+    calendarId: number | null;
     subcontractId: number | null;
-    /**
-     * Visibility bit of the legacy view-model. Historically NEVER sent by the
-     * backend (0 of ~105k activities across the captured seeds carry it) — the
-     * legacy client hardcoded `should_be_showed: true` at parse. Declared so
-     * `parseActivity` can map it to `visible` if it ever arrives; absent/null
-     * defaults to visible.
-     */
-    should_be_showed?: boolean;
+    should_be_showed?: boolean | null;
     tasks: unknown[];
     responsables: unknown[];
     tags: unknown[];
     activitymodifications: unknown[];
-    pendingRequests: readonly {
+    pendingRequests?: readonly {
         id?: unknown;
     }[];
     subcontract: unknown;
@@ -1217,10 +1051,8 @@ interface BackendActivityInput {
     baseline_points?: BaselinePoint[];
     createdAt: string;
     updatedAt: string;
-    /** Custom fields the backend may include — passed through opaquely. */
-    [key: string]: unknown;
 }
-interface BackendLink {
+interface BackendLinkInput {
     id: number | string;
     unique_id?: string | null;
     source_id?: string;
@@ -1228,116 +1060,32 @@ interface BackendLink {
     source?: number | string;
     target?: number | string;
     type?: unknown;
-    lag: number;
+    lag: number | null;
     ganttId?: number;
     sectorId?: number;
 }
-/** Sector metadata — project-level config from the server. */
-interface BackendSector {
+interface BackendSectorInput {
     id: number;
     name: string;
-    description: string | null;
-    status: boolean;
-    set_current: boolean;
-    visible: boolean;
-    order: number;
-    productive: boolean;
     hoursPerDay: number;
     hoursPerWeek: number;
-    accumulatedDuration: number;
-    /** Date format string used by the backend, e.g. `"DD/MM/YY hh:mm"`. */
     dateFormat: string;
-    didCloseWeek: string | null;
-    currentClosedWeek: string | null;
-    expectedProgress: number;
-    /**
-     * Legacy Primavera-import flag. When true, the stored `duration` of each
-     * activity may not match the calendar (Primavera stores end-driven
-     * durations); the core recomputes duration from start/end at load. ~218
-     * production sectors carry it (active). See `Obsidian:newPlanSchedule/CALENDARS.md`.
-     */
-    update_duration_for_primavera_for_end_date?: boolean | null;
-    companyId: number;
     projectId: number;
-    version: string;
-    createdAt: string;
-    updatedAt: string;
-    /** Calendars nested inside sector when the sector-fetch endpoint is used. */
-    calendars?: BackendCalendar[];
-    [key: string]: unknown;
-}
-/** Optional sibling payloads the API often returns alongside the sector. */
-interface BackendScheduleImpactRequests {
-    pending: unknown[];
-    approved: unknown[];
-    rejected: unknown[];
+    companyId: number;
+    update_duration_for_primavera_for_end_date?: boolean | null;
+    activity_creter?: string | null;
+    custom_id_prefix?: string | null;
+    custom_id_increment?: string | number | null;
+    calendars?: BackendCalendarInput[];
 }
-/** Complete server payload accepted by `ScheduleCore`. */
-interface BackendInput {
-    sector: BackendSector;
+interface BackendScheduleInput {
+    sector: BackendSectorInput;
     activities: BackendActivityInput[];
-    links: BackendLink[];
-    /**
-     * Calendars come either inside `sector.calendars` or as a sibling array.
-     * If both are present, the sibling array wins.
-     */
-    calendars?: BackendCalendar[] | undefined;
-    /**
-     * Baseline calendars, RAW from the backend's `showBaseCalendar` endpoint
-     * (exceptions under `baseexceptiondays`, `is_default`, no `-base` suffix).
-     * Parsed into a separate `ParsedInput.baseCalendars` collection — never
-     * mixed into the scheduling calendars. The core owns their reshape /
-     * differentiation (previously done by the frontend `refreshCalendarsRewrite`).
-     */
-    baseCalendars?: BackendCalendar[] | undefined;
+    links: BackendLinkInput[];
+    calendars?: BackendCalendarInput[] | undefined;
+    baseCalendars?: BackendCalendarInput[] | undefined;
 }
 
-declare const COLUMN: {
-    readonly REAL_WORK: "real_work";
-    readonly REAL_COST: "real_cost";
-    readonly EXPECTED_PROGRESS: "expected_progress";
-    readonly EXPECTED_PROGRESS_BASE: "expected_progress_base";
-    readonly START_BASE: "start_base";
-    readonly END_BASE: "end_base";
-    readonly DURATION_BASE: "duration_base";
-    readonly COST_BASE: "cost_base";
-    readonly WORK_BASE: "work_base";
-    readonly CALENDAR_DURATION: "calendarDuration";
-    readonly IS_CRITICAL: "is_critical";
-    readonly EARLY_START: "earlyStart";
-    readonly EARLY_FINISH: "earlyFinish";
-    readonly LATE_START: "lateStart";
-    readonly LATE_FINISH: "lateFinish";
-    readonly FREE_SLACK: "freeSlack";
-    readonly TOTAL_SLACK: "totalSlack";
-    readonly CORRELATIVE_ID: "correlative_id";
-    readonly UNIQUE_CORRELATIVE_ID: "unique_correlative_id";
-    readonly PONDERATOR: "ponderator";
-    readonly STATUS: "status";
-    readonly TEXT: "text";
-    readonly DESCRIPTION: "description";
-    readonly DURATION: "duration";
-    readonly PROGRESS: "progress";
-    readonly COST: "cost";
-    readonly USED_COST: "used_cost";
-    readonly HH_WORK_TIME: "hhWorkTime";
-    readonly START_DATE: "start_date";
-    readonly END_DATE: "end_date";
-    readonly CONSTRAINT_TYPE: "constraint_type";
-    readonly CONSTRAINT_DATE: "constraint_date";
-    readonly CALENDAR_ID: "calendar_id";
-    readonly CUSTOM_ID: "custom_id";
-    readonly SUBCONTRACT_ID: "subcontractId";
-    readonly RESPONSABLES: "responsables";
-    readonly TAGS: "tags";
-    readonly CUSTOM_PREDECESSORS: "custom_predecessors";
-    readonly CUSTOM_SUCESSORS: "custom_sucessors";
-};
-type ColumnName = (typeof COLUMN)[keyof typeof COLUMN];
-
-type ActivityId = string;
-type CalendarId = string;
-
 /**
  * Role interfaces (Interface Segregation).
  *
@@ -1355,30 +1103,37 @@ type CalendarId = string;
 
 /** READ surface over the activity/link store and the hierarchy index. */
 interface ActivityReader {
-    getActivity(activityId: ActivityId$2): EngineActivitySnapshot | null;
-    getAllActivities(): ReadonlyArray<EngineActivitySnapshot>;
+    getActivity(activityId: ActivityId$1): CoreActivity | null;
+    getLastStartDate(activityId: ActivityId$1): Date | null;
+    getAllActivities(): ReadonlyArray<CoreActivity>;
     getAllLinks(): LinkSnapshot[];
     getLink(linkId: LinkId$1): LinkSnapshot | null;
-    activityExists(activityId: ActivityId$2): boolean;
-    getChildren(parentId: ActivityId$2): ActivityId$2[];
-    getParent(activityId: ActivityId$2): EngineActivitySnapshot | null;
-    getParentId(activityId: ActivityId$2): ActivityId$2 | 0;
-    isChildOf(childId: ActivityId$2, parentId: ActivityId$2): boolean;
-    getAllIds(): readonly ActivityId$2[];
+    activityExists(activityId: ActivityId$1): boolean;
+    getChildren(parentId: ActivityId$1): ActivityId$1[];
+    hasChildren(parentId: ActivityId$1): boolean;
+    getParent(activityId: ActivityId$1): CoreActivity | null;
+    getParentId(activityId: ActivityId$1): ActivityId$1 | null;
+    getRootIds(): ReadonlyArray<ActivityId$1>;
+    isChildOf(childId: ActivityId$1, parentId: ActivityId$1): boolean;
+    getOutgoingLinkIds(activityId: ActivityId$1): ReadonlyArray<LinkId$1>;
+    getIncomingLinkIds(activityId: ActivityId$1): ReadonlyArray<LinkId$1>;
+    getAllIds(): readonly ActivityId$1[];
     activityCount(): number;
-    forEachActivity(visit: (activity: EngineActivitySnapshot, id: ActivityId$2) => void): void;
+    forEachActivity(visit: (activity: CoreActivity, id: ActivityId$1) => void): void;
 }
 /** READ + WRITE surface over the store. */
 interface ActivityWriter extends ActivityReader {
-    setActivityField<Field extends keyof EngineActivitySnapshot>(activityId: ActivityId$2, field: Field, value: EngineActivitySnapshot[Field]): void;
+    setActivityField<Field extends keyof CoreActivity>(activityId: ActivityId$1, field: Field, value: CoreActivity[Field]): void;
+    setActivityFieldDynamic(activityId: ActivityId$1, field: string, value: unknown): void;
     /** Bulk write of several fields of one activity in a single getActivity +
      * write-capture note (vs N setActivityField calls). */
-    setActivityFields(activityId: ActivityId$2, fields: Partial<EngineActivitySnapshot>): void;
+    setActivityFields(activityId: ActivityId$1, fields: Partial<CoreActivity>): void;
     addLink(link: LinkSnapshot): void;
     removeLink(linkId: LinkId$1): void;
-    setLinkField<Field extends keyof LinkSnapshot>(linkId: LinkId$1, field: Field, value: LinkSnapshot[Field]): void;
-    addActivity(activity: EngineActivitySnapshot): void;
-    removeActivity(activityId: ActivityId$2): void;
+    setLinkField<Field extends MutableLinkField>(linkId: LinkId$1, field: Field, value: LinkSnapshot[Field]): void;
+    setLinkFieldDynamic(linkId: LinkId$1, field: string, value: unknown): void;
+    addActivity(activity: CoreActivity): void;
+    removeActivity(activityId: ActivityId$1): void;
 }
 
 /**
@@ -1416,7 +1171,7 @@ interface ScheduleCoreReporter {
  */
 
 type ScheduleCoreStatus = 'ready' | 'destroyed' | 'poisoned';
-interface ScheduleCoreInput extends BackendInput {
+interface ScheduleCoreInput extends BackendScheduleInput {
     /**
      * Skip the full autoscheduler pass that normally runs from the
      * constructor (`runInitialPasses`).
@@ -1480,6 +1235,14 @@ interface ScheduleCoreInput extends BackendInput {
     reporter?: ScheduleCoreReporter;
 }
 
+interface PersistedEntityIdentity {
+    readonly id: string;
+    readonly proplannerId: number;
+}
+interface PersistenceAcknowledgement {
+    readonly activities?: ReadonlyArray<PersistedEntityIdentity>;
+    readonly links?: ReadonlyArray<PersistedEntityIdentity>;
+}
 declare class ScheduleCore {
     private _status;
     /** True while an async dispatch is suspended inside the write-capture window.
@@ -1498,17 +1261,15 @@ declare class ScheduleCore {
     }>;
     get status(): ScheduleCoreStatus;
     getSector(): Readonly<SectorMetadata>;
-    getActivityView(id: ActivityId$1, unit?: OutputUnit): Readonly<Activity> | null;
-    getAllActivitiesView(unit?: OutputUnit): ReadonlyArray<Readonly<Activity>>;
-    getChildrenView(parentId: ActivityId$1 | '0', unit?: OutputUnit): ReadonlyArray<Readonly<Activity>>;
-    getLinkView(id: LinkId, unit?: OutputUnit): Readonly<Link> | null;
-    getAllLinksView(unit?: OutputUnit): ReadonlyArray<Readonly<Link>>;
-    getProperty<Property extends keyof Activity>(activityId: ActivityId$1, property: Property, options?: {
-        unit?: OutputUnit;
-    }): Activity[Property] | null;
+    getActivityView(id: ActivityId): Readonly<CoreActivity> | null;
+    getAllActivitiesView(): ReadonlyArray<Readonly<CoreActivity>>;
+    getChildrenView(parentId: ActivityId | '0'): ReadonlyArray<Readonly<CoreActivity>>;
+    getLinkView(id: LinkId): Readonly<Link> | null;
+    getAllLinksView(): ReadonlyArray<Readonly<Link>>;
+    getProperty<Property extends keyof CoreActivity>(activityId: ActivityId, property: Property): CoreActivity[Property] | null;
     getAllIds(): readonly string[];
     forEachActivityId(visit: (id: string) => void): void;
-    getChildrenIds(parentId: ActivityId$1 | '0'): ReadonlyArray<ActivityId$1>;
+    getChildrenIds(parentId: ActivityId | '0'): ReadonlyArray<ActivityId>;
     getSelectedActivityIds(): string[];
     /**
      * Every activity id in canonical DFS visual order (pre-order from roots,
@@ -1517,18 +1278,28 @@ declare class ScheduleCore {
      * on any structural mutation (add/remove/reparent/renumber), so repeated
      * reads between mutations are O(1).
      */
-    getVisualOrderIds(): ReadonlyArray<ActivityId$1>;
-    hasChild(parentId: ActivityId$1 | '0'): boolean;
-    getCalendar(id: CalendarId$1): Readonly<Calendar> | null;
+    getVisualOrderIds(): ReadonlyArray<ActivityId>;
+    hasChild(parentId: ActivityId | '0'): boolean;
+    getCalendar(id: CalendarId): Readonly<Calendar> | null;
     getAllCalendars(): ReadonlyArray<Readonly<Calendar>>;
     getBaseCalendars(): ReadonlyArray<Readonly<Calendar>>;
     isCustomIdInUse(customId: string, currentCustomId?: string | null): boolean;
     getProjectWorkHours(): ProjectWorkHours | null;
     getModifiedLinks(): ReadonlyArray<Readonly<Link>>;
     markLinksPersisted(): void;
-    getModifiedActivities(): ReadonlyArray<Readonly<Activity>>;
+    getModifiedActivities(): ReadonlyArray<Readonly<CoreActivity>>;
     markActivitiesPersisted(): void;
-    applyBaselines(points: readonly BaselinePoint[]): ReadonlyArray<Readonly<Activity>>;
+    /**
+     * Reconciles the backend identities returned by a successful schedule save.
+     *
+     * This is an application-boundary acknowledgement, not an editable schedule
+     * gesture: it does not autoschedule, recompute, emit an undo entry, or invent
+     * domain changes. Every assignment is validated before the first mutation so
+     * a malformed/partial response cannot leave the core half-reconciled. Once
+     * applied, the complete live graph becomes the new save-tracker baseline.
+     */
+    acknowledgePersistence(acknowledgement: PersistenceAcknowledgement): void;
+    applyBaselines(points: readonly BaselinePoint[]): ReadonlyArray<Readonly<CoreActivity>>;
     /**
      * Whole-tree ponderator recompute (zeroes, then redistributes 100 within
      * each parent from its children's active baselines, weighted by `criterion`).
@@ -1536,25 +1307,25 @@ declare class ScheduleCore {
      * The base rollup (`applyBaselines`) depends on fresh ponderators, so callers
      * run this before it on a criterion change or baseline save.
      */
-    recomputeAllPonderators(criterion: ActivityCreter): ReadonlyArray<Readonly<Activity>>;
+    recomputeAllPonderators(criterion: ActivityCreter): ReadonlyArray<Readonly<CoreActivity>>;
     /**
      * Recompute the weighted-progress rollup of every parent, bottom-up.
      * Returns the activities whose `progress` changed, for a prop-only repaint.
      */
-    recomputeAllProgressRollup(): ReadonlyArray<Readonly<Activity>>;
+    recomputeAllProgressRollup(): ReadonlyArray<Readonly<CoreActivity>>;
     /**
      * Set the project's status criterion (the Baseline↔Actual toggle) and
      * recompute every activity's `status` against it. Stores the criterion so
      * future dispatches keep deriving status with it. Returns the activities
      * whose `status` changed, for a prop-only repaint.
      */
-    setStatusCriteria(criteria: StatusCriteria): ReadonlyArray<Readonly<Activity>>;
-    allocateActivityId(): ActivityId$1;
+    setStatusCriteria(criteria: StatusCriteria): ReadonlyArray<Readonly<CoreActivity>>;
+    allocateActivityId(): ActivityId;
     createActivity(input: Omit<Extract<DispatchAction, {
         kind: 'activity-create';
-    }>, 'kind'>, outputUnit?: OutputUnit): {
+    }>, 'kind'>): {
         ok: true;
-        activity: Readonly<Activity>;
+        activity: Readonly<CoreActivity>;
         changes: ChangeSet;
     } | {
         ok: false;
@@ -1580,12 +1351,8 @@ declare class ScheduleCore {
     } | null>;
     private _recomputeCriticalPathIfStale;
     private _runCriticalPathAndCapture;
-    undo(options?: {
-        outputUnit?: OutputUnit;
-    }): Promise<ChangeSet | null>;
-    redo(options?: {
-        outputUnit?: OutputUnit;
-    }): Promise<ChangeSet | null>;
+    undo(): Promise<ChangeSet | null>;
+    redo(): Promise<ChangeSet | null>;
     clearHistory(): void;
     canUndo(): boolean;
     canRedo(): boolean;
@@ -1607,14 +1374,18 @@ declare class ScheduleCore {
     private _rollback;
 }
 
+interface ViewStateSeed {
+    readonly hiddenIds: readonly ActivityId[];
+}
 interface ParsedInput {
     sector: SectorMetadata;
-    activities: Activity[];
+    activities: CoreActivity[];
     links: Link[];
     calendars: Calendar[];
     baseCalendars: Calendar[];
+    viewStateSeed: ViewStateSeed;
 }
-declare function parseFromBackend(input: BackendInput, reporter?: ScheduleCoreReporter): ParsedInput;
+declare function parseFromBackend(input: BackendScheduleInput, reporter?: ScheduleCoreReporter): ParsedInput;
 
 /**
  * Returns the ACTIVE baseline point of an activity, or null.
@@ -1636,8 +1407,8 @@ declare function parseFromBackend(input: BackendInput, reporter?: ScheduleCoreRe
  * the legacy `if (base.sectorbaselineversion.active)` check.
  */
 declare function getActiveBaseline(activity: {
-    baseline_points?: unknown;
-} | null | undefined): BaselinePoint | null;
+    baselinePoints?: readonly CoreBaselinePoint[];
+} | null | undefined): CoreBaselinePoint | null;
 
 /**
  * Surface this function needs from ScheduleState — kept structural so the
@@ -1656,7 +1427,7 @@ interface BaselineApplyAdapter {
  * `baseline_points` reset to `[]`. Returns the ids of activities whose
  * `baseline_points` changed (so the caller can repaint just those).
  */
-declare function applyBaselinePoints(adapter: BaselineApplyAdapter, points: readonly BaselinePoint[]): string[];
+declare function applyBaselinePoints(adapter: BaselineApplyAdapter, points: readonly BaselinePoint[], reporter: ScheduleCoreReporter): string[];
 
 interface CalendarLike {
     calculateDuration(start: Date, end: Date): number;
@@ -1730,9 +1501,9 @@ declare function recomputeAllPonderators(criterion: ActivityCreter, adapter: Act
  *
  * PROGRESS-ONLY by design: unlike the dispatch post-processor
  * `recomputeParentFromChildren` (post-processors/parent-bounds.ts), this does NOT
- * touch parent start/end/duration — only `progress` and the milestone mirror
- * `for_disable_milestone_duration`. That keeps it testable in isolation
- * (no calendars/dates needed) and matches what `check_progress` actually did.
+ * touch parent start/end/duration — only `progress`. That keeps it testable
+ * in isolation (no calendars/dates needed) and matches what `check_progress`
+ * actually did.
  *
  * Order is load-bearing (unlike ponderators, which are order-independent): a
  * grandparent's rollup consumes its children-parents' ALREADY rolled-up
@@ -1749,127 +1520,8 @@ declare function recomputeAllPonderators(criterion: ActivityCreter, adapter: Act
 
 declare function recomputeAllProgressRollup(adapter: ActivityWriter): void;
 
-/**
- * Task creation pipeline — types.
- *
- * Ports the pure parts of `src/assets/js/custom_actions/createTask/` into a
- * functional pipeline that replay tests (and eventually prod) can invoke
- * against an adapter instead of the live gantt.
- */
-
-/**
- * Shape of the task object AFTER the pipeline configures it.
- *
- * Mirrors the canonical `Activity` interface (from `../../types.ts`) plus
- * a handful of Outbuild-specific fields (responsables, tags, subcontractId,
- * real_constraint_type) and legacy lifecycle flags (new_task, isNewActivity,
- * $source, $target) that downstream consumers still read.
- *
- * Every field in `Activity` is present here. The defaults for the
- * non-runtime-computed ones live in `NEW_ACTIVITY_DEFAULTS`.
- */
-interface NewActivityFields {
-    text: string;
-    description: string;
-    type: 'task' | 'milestone' | 'project';
-    start_date: Date;
-    end_date: Date;
-    duration: number;
-    progress: number;
-    constraint_type: ConstraintType | null;
-    constraint_date: Date | null;
-    calendar_id: CalendarId;
-    /** Parent id (string) or `'0'` for root. Always string — no number drift. */
-    parent: ActivityId | '0';
-    auto_scheduling: boolean;
-    hhWorkTime: number;
-    cost: number;
-    used_cost: number;
-    /**
-     * Earned cost: `(progress/100) × activeBaseline.cost`. A fresh activity has
-     * progress 0 and no active baseline, so it starts at 0 — matching what the
-     * load-path `emitRealCost` would compute for a new leaf. Seeded explicitly so
-     * the field is never `undefined` (which surfaced as `NaN` downstream).
-     */
-    real_cost: number;
-    /** Real worked hours; aggregated from progress submittals. Starts at 0. */
-    real_work: number;
-    /**
-     * Baseline-derived weighting factor used by the parent.progress rollup.
-     * Starts at 0 (no baseline yet); set by the backend on baseline import.
-     * Not editable from the schedule UI — see `project_ponderator_not_editable`.
-     */
-    ponderator: number;
-    responsables: unknown[];
-    tags: unknown[];
-    subcontractId: string | number | null;
-    real_constraint_type: ConstraintType | null;
-    should_be_showed: boolean;
-    /** View-model visibility bit (`visible !== false` = visible). */
-    visible: boolean;
-    activityModifications: unknown[];
-    pendingRequests: unknown[];
-    /** String form, matches Sequelize BIGINT serialization. */
-    unique_correlative_id: string;
-    start_date_backup: string;
-    new_task: true;
-    isNewActivity: true;
-    /**
-     * Tracks outgoing link ids (this activity is the link source).
-     * Initialized empty; mutated by link-create / link-delete to keep the
-     * index consistent. The snapshot reads it directly, so it must always
-     * exist (not undefined) — see D1 in DIVERGENCES_activity_create.md.
-     */
-    $source: string[];
-    /** Same as $source for incoming links (this activity is the target). */
-    $target: string[];
-    /** Pass-through bucket for any extra fields the caller provides. */
-    [key: string]: unknown;
-}
-
-/**
- * Working-day vocabulary — genuine cross-component primitive (creation
- * defaults, internal/state context fallbacks, link lag display). The value
- * is the FALLBACK only; a sector- or calendar-provided hoursPerDay always
- * takes precedence at every consumer.
- */
-declare const DEFAULT_HOURS_PER_DAY = 8;
-
-/**
- * Defaults for newly-created activities — the **canonical template** that
- * `buildNewActivity` spreads before applying caller-provided overrides.
- *
- * Single source of truth: any documentation that says "a new activity
- * starts as X" must reference this constant, never inline literals.
- *
- * The shape produced by spreading this constant + the runtime-computed
- * fields below is a complete Activity (every field in the `Activity`
- * interface from `../../types.ts` is accounted for).
- *
- * Fields NOT in this constant are computed at runtime because they depend
- * on input or context:
- *   - `id`                       → allocated by `ActivityIdGenerator.next()`
- *   - `parent`                   → from `DispatchAction.parentId` (or `'0'`)
- *   - `start_date`               → inherited from parent or `fallbackStartDate`,
- *                                  then snapped to the calendar's next
- *                                  working-time boundary
- *   - `end_date`                 → calendar-aware via `adapter.calculateEndDate`
- *   - `duration`                 → override > `sector.hoursPerDay` > `8`
- *   - `calendar_id`              → override > `sector.defaultCalendar`
- *   - `unique_correlative_id`    → allocated by `UniqueCorrelativeIdGenerator.next()`
- *   - `custom_id`                → allocated by `customIdTracker`
- *   - `text`                     → `'New Master Plan'` when this is the very
- *                                  first activity of the sector, `'New Activity'`
- *                                  otherwise (override beats both)
- *   - `correlative_id`           → assigned by `recomputeCorrelativeIds` after
- *                                  the new activity has been inserted in the
- *                                  parent's children list
- *
- * The `real_constraint_type` field is set AFTER the spread of overrides so
- * it always mirrors the (possibly overridden) `constraint_type`.
- */
-
-declare const NEW_ACTIVITY_DEFAULTS: Readonly<Omit<NewActivityFields, 'id' | 'parent' | 'start_date' | 'end_date' | 'duration' | 'calendar_id' | 'unique_correlative_id' | 'text' | 'start_date_backup'>>;
+type StaticActivityDefaults = Omit<CoreActivity, 'id' | 'parentId' | 'name' | 'startDate' | 'endDate' | 'durationHours' | 'calendarId' | 'uniqueCorrelativeId'>;
+declare const NEW_ACTIVITY_DEFAULTS: Readonly<StaticActivityDefaults>;
 
 /**
  * Schedule-core equivalent of the legacy frontend `checkNoUpdatedLinks`.
@@ -1996,6 +1648,14 @@ declare const LINK_CODE_TO_TYPE: {
 /** Inverse of `CONSTRAINT_LABEL_MAP` — internal code → backend label. */
 declare const CONSTRAINT_TYPE_TO_LABEL: Record<ConstraintType, string>;
 
+/**
+ * Working-day vocabulary — genuine cross-component primitive (creation
+ * defaults, internal/state context fallbacks, link lag display). The value
+ * is the FALLBACK only; a sector- or calendar-provided hoursPerDay always
+ * takes precedence at every consumer.
+ */
+declare const DEFAULT_HOURS_PER_DAY = 8;
+
 /**
  * Canonical catalog of `DispatchAction` kinds.
  *
@@ -2032,6 +1692,7 @@ declare const DISPATCH_ACTION_KIND: {
     readonly SELECTION_REPLACE: "selection-replace";
     readonly VISIBILITY_SET: "visibility-set";
     readonly SIR_SYNC: "sir-sync";
+    readonly ACTIVITY_LOOKAHEAD_SYNC: "activity-lookahead-sync";
 };
 declare const DISPATCH_ACTION_KINDS: ReadonlyArray<DispatchActionKind>;
 
@@ -2107,4 +1768,4 @@ declare const DISPATCH_TRACK_EVENT: {
 };
 type DispatchTrackEvent = (typeof DISPATCH_TRACK_EVENT)[keyof typeof DISPATCH_TRACK_EVENT];
 
-export { ACTIVITY_TYPE, type Activity, type ActivityCreter, type ActivityId$1 as ActivityId, type ActivityType, type BackendActivityInput, type BackendCalendar, type BackendCalendarException, type BackendInput, type BackendLink, type BackendScheduleImpactRequests, type BackendSector, type BackendShift, type BaselinePoint, type BaselineVersion, CALENDAR_UNIT, COLUMN, CONSTRAINT_TYPE, CONSTRAINT_TYPE_TO_LABEL, CREATION_KIND, type Calendar, type CalendarId$1 as CalendarId, type CalendarUnit, type CalendarWorktime, type ChangeSet, type ColumnName, type ConstraintType, type ConstraintWarning, type CreationKind, DEFAULT_HOURS_PER_DAY, DISPATCH_ACTION_KIND, DISPATCH_ACTION_KINDS, DISPATCH_TRACK_EVENT, type DispatchAction, type DispatchActionKind, type DispatchOptions, type DispatchRejectReason, type DispatchResult, type DispatchTrackEvent, type EntityChange, LINK_CODE_TO_TYPE, LINK_TYPE, LINK_TYPE_CODE, type Link, type LinkId, type LinkType, type LinkTypeCode, type LinksBatchOperation, NEW_ACTIVITY_DEFAULTS, type OutputUnit, type ParsedInput, type PastedActivityInput, type PastedLinkInput, type PendingRequest, REJECTION_REASON, ROOT_PARENT_ID, ScheduleCore, type ScheduleCoreInput, type ScheduleCoreReporter, type ScheduleCoreStatus, type ScheduleEffect, type SectorMetadata, type StatusCriteria, type TrackingEvent, WORK_TIME_DIRECTION, type WorkTimeDirection, applyBaselinePoints, checkNoUpdatedLinks, computeExpectedProgress, expectedProgressFromBaseline, getActiveBaseline, getUnsavedActivities, isRootParent, normalizeParentKey, parseFromBackend, recomputeAllPonderators, recomputeAllProgressRollup, willRunCriticalPath, yieldToBrowser };
+export { ACTIVITY_TYPE, type ActivityCreter, type ActivityId, type ActivityType, type BackendActivityInput, type BackendCalendarInput, type BackendLinkInput, type BackendScheduleInput, type BackendSectorInput, type BaselinePoint, type BaselineVersion, CALENDAR_UNIT, COLUMN, CONSTRAINT_TYPE, CONSTRAINT_TYPE_TO_LABEL, CREATION_KIND, type Calendar, type CalendarId, type CalendarUnit, type CalendarWorktime, type ChangeSet, type ColumnName, type ConstraintType, type ConstraintWarning, type CoreActivity, type CreationKind, DEFAULT_HOURS_PER_DAY, DISPATCH_ACTION_KIND, DISPATCH_ACTION_KINDS, DISPATCH_TRACK_EVENT, type DispatchAction, type DispatchActionKind, type DispatchOptions, type DispatchRejectReason, type DispatchResult, type DispatchTrackEvent, type EntityChange, LINK_CODE_TO_TYPE, LINK_TYPE, LINK_TYPE_CODE, type Link, type LinkId, type LinkType, type LinkTypeCode, type LinksBatchOperation, NEW_ACTIVITY_DEFAULTS, type ParsedInput, type PastedActivityInput, type PastedLinkInput, type PendingRequest, type PersistedEntityIdentity, type PersistenceAcknowledgement, REJECTION_REASON, ROOT_PARENT_ID, ScheduleCore, type ScheduleCoreInput, type ScheduleCoreReporter, type ScheduleCoreStatus, type ScheduleEffect, type SectorMetadata, type StatusCriteria, type TrackingEvent, WORK_TIME_DIRECTION, type WorkTimeDirection, applyBaselinePoints, checkNoUpdatedLinks, computeExpectedProgress, expectedProgressFromBaseline, getActiveBaseline, getUnsavedActivities, isRootParent, normalizeParentKey, parseFromBackend, recomputeAllPonderators, recomputeAllProgressRollup, willRunCriticalPath, yieldToBrowser };