15.1 平台组合与接入时间线

{
  "version": 1,
  "game": "merge-island",
  "observedAt": "2026-10",
  "note": "出海接入时间线参数：把第 1 章选出的五平台组合装配成一张依赖图。口径是「公开可观察机制」的建模假设，不是任何平台后台实测。sharedTasks=五平台共享的前置任务（无依赖，manDays=工程人天）；platforms[].integrateManDays=该平台接入与适配人天（沿用 1.3 组合取值）；submitDays=提审材料准备天数；reviewDays=平台审核等待天数；needsShared=该平台接入必须先完成哪些共享任务。真实接入人天、审核时长与驳回往返需真实业务环境，命令行不可复现（X）。全整数，无浮点。",
  "sharedTasks": [
    { "id": "abstraction", "name": "平台抽象层与构建矩阵", "manDays": 8 },
    { "id": "i18n", "name": "多语言资源管线", "manDays": 5 },
    { "id": "compliance", "name": "合规与同意管理", "manDays": 6 }
  ],
  "platforms": [
    { "id": "gamedistribution", "name": "GameDistribution", "integrateManDays": 4, "submitDays": 1, "reviewDays": 5, "needsShared": ["abstraction"] },
    { "id": "poki", "name": "Poki", "integrateManDays": 6, "submitDays": 1, "reviewDays": 7, "needsShared": ["abstraction"] },
    { "id": "crazygames", "name": "CrazyGames", "integrateManDays": 5, "submitDays": 1, "reviewDays": 6, "needsShared": ["abstraction"] },
    { "id": "fb_instant", "name": "Facebook Instant Games", "integrateManDays": 12, "submitDays": 2, "reviewDays": 10, "needsShared": ["abstraction", "i18n", "compliance"] },
    { "id": "yt_playables", "name": "YouTube Playables", "integrateManDays": 9, "submitDays": 2, "reviewDays": 14, "needsShared": ["abstraction", "i18n", "compliance"] }
  ]
}

#!/usr/bin/env python3
# file: sim/g15_timeline.py
# tier: D
# verify: /opt/homebrew/bin/python3 sim/g15_timeline.py --config config/ --out out/
"""出海接入时间线扫描（D 层：计划表 / lint 校验）。

读 config/g15_timeline.json，把「共享前置任务 + 每平台接入→提审→审核」装配成依赖图，
用关键路径法（CPM）算工期与关键路径：

  node 集合 = 每个 sharedTask 一个节点 + 每个平台三个节点（integrate / submit / review）
  integrate 依赖该平台 needsShared 里的全部共享节点；submit 依赖 integrate；review 依赖 submit
  ES(v) = max(EF(前驱))      EF(v) = ES(v) + dur(v)
  makespan = max(EF(v))
  slack(v) = LS(v) - ES(v)   LS(v) = LF(v) - dur(v)，LF(v) = min(LS(后继))，无后继节点 LF = makespan
  关键路径 = 从 EF 最大的终点回溯 EF(前驱) == ES(当前) 的链

口径：人天、提审与审核时长是「公开可观察机制」口径的建模假设，观察时点 2026-10；真实接入
人天、审核时长与驳回往返需真实业务环境，命令行不可复现（X）。产出 JSON + CSV，全整数，无浮点。
"""
from __future__ import annotations

import argparse
import csv
import json
import os


def build_nodes(cfg: dict) -> dict:
    nodes: dict = {t["id"]: {"id": t["id"], "name": t["name"], "dur": t["manDays"], "deps": []}
                   for t in cfg["sharedTasks"]}
    for p in cfg["platforms"]:
        pid = p["id"]
        nodes[f"{pid}.integrate"] = {"id": f"{pid}.integrate", "name": f"{p['name']} 接入",
                                     "dur": p["integrateManDays"], "deps": list(p["needsShared"])}
        nodes[f"{pid}.submit"] = {"id": f"{pid}.submit", "name": f"{p['name']} 提审",
                                  "dur": p["submitDays"], "deps": [f"{pid}.integrate"]}
        nodes[f"{pid}.review"] = {"id": f"{pid}.review", "name": f"{p['name']} 审核",
                                  "dur": p["reviewDays"], "deps": [f"{pid}.submit"]}
    return nodes


def cpm(nodes: dict) -> dict:
    succ: dict = {nid: [] for nid in nodes}
    for nid, n in nodes.items():
        for d in n["deps"]:
            succ[d].append(nid)
    indeg = {nid: len(n["deps"]) for nid, n in nodes.items()}
    order, ready = [], sorted(nid for nid, k in indeg.items() if k == 0)
    while ready:
        nid = ready.pop(0)
        order.append(nid)
        for s in sorted(succ[nid]):
            indeg[s] -= 1
            if indeg[s] == 0:
                ready.append(s)
                ready.sort()
    es, ef = {}, {}
    for nid in order:
        es[nid] = max((ef[d] for d in nodes[nid]["deps"]), default=0)
        ef[nid] = es[nid] + nodes[nid]["dur"]
    makespan = max(ef.values())
    ends = sorted(nid for nid in nodes if not succ[nid])
    lf = {nid: makespan for nid in ends}
    ls = {}
    for nid in reversed(order):
        if nid not in lf:
            lf[nid] = min(ls[s] for s in succ[nid])
        ls[nid] = lf[nid] - nodes[nid]["dur"]
    slack = {nid: ls[nid] - es[nid] for nid in nodes}
    end = sorted(ends, key=lambda n: (-ef[n], n))[0]
    path, cur = [end], end
    while nodes[cur]["deps"]:
        prev = sorted(d for d in nodes[cur]["deps"] if ef[d] == es[cur])[0]
        cur = prev
        path.append(cur)
    path.reverse()
    return {"es": es, "ef": ef, "ls": ls, "slack": slack, "makespan": makespan, "path": path}


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--config", default="config/")
    ap.add_argument("--out", default="out/")
    a = ap.parse_args()
    with open(os.path.join(a.config, "g15_timeline.json"), encoding="utf-8") as f:
        cfg = json.load(f)
    nodes = build_nodes(cfg)
    r = cpm(nodes)
    rows = [{"id": nid, "name": nodes[nid]["name"], "dur": nodes[nid]["dur"],
             "es": r["es"][nid], "ef": r["ef"][nid], "ls": r["ls"][nid], "slack": r["slack"][nid],
             "critical": 1 if r["slack"][nid] == 0 else 0} for nid in sorted(nodes)]
    digest = (f'makespan={r["makespan"]}|nodes={len(nodes)}|critical={" > ".join(r["path"])}'
              f'|zeroSlack={sum(x["critical"] for x in rows)}')
    os.makedirs(a.out, exist_ok=True)
    with open(os.path.join(a.out, "g15_timeline.csv"), "w", encoding="utf-8", newline="") as f:
        w = csv.writer(f)
        w.writerow(["id", "name", "dur", "es", "ef", "ls", "slack", "critical"])
        for x in rows:
            w.writerow([x[k] for k in ("id", "name", "dur", "es", "ef", "ls", "slack", "critical")])
    rep = {"version": cfg["version"], "game": cfg["game"], "observedAt": cfg["observedAt"],
           "makespan": r["makespan"], "nodeCount": len(nodes), "criticalPath": r["path"],
           "digest": digest, "tasks": rows, "csv": os.path.join(a.out, "g15_timeline.csv")}
    with open(os.path.join(a.out, "g15_timeline.json"), "w", encoding="utf-8") as f:
        json.dump(rep, f, ensure_ascii=False, indent=2)
    print(json.dumps({"makespan": r["makespan"], "criticalPath": r["path"], "digest": digest,
                      "tasks": rows}, ensure_ascii=False, indent=2))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

// file: core/src/g15/timeline.ts
// tier: P
// verify: node --test 'core/test/g15_*.test.ts'
//
// 出海接入时间线内核：与 sim/g15_timeline.py 逐位等价的 TypeScript 对偶实现。
// 读同一份 config/g15_timeline.json，用关键路径法（CPM）算工期与关键路径。
// 全整数、无浮点、无随机（禁 Math.random；只用可擦除语法，禁 enum / namespace）。

export interface SharedTask { readonly id: string; readonly name: string; readonly manDays: number }
export interface PlatformPlan {
  readonly id: string; readonly name: string; readonly integrateManDays: number;
  readonly submitDays: number; readonly reviewDays: number; readonly needsShared: readonly string[];
}
export interface TimelineConfig {
  readonly version: number; readonly game: string;
  readonly sharedTasks: readonly SharedTask[]; readonly platforms: readonly PlatformPlan[];
}
export interface Node { readonly id: string; readonly name: string; readonly dur: number; readonly deps: readonly string[] }
export interface TaskRow {
  readonly id: string; readonly name: string; readonly dur: number;
  readonly es: number; readonly ef: number; readonly ls: number; readonly slack: number;
  readonly critical: boolean;
}
export interface CpmResult { readonly tasks: readonly TaskRow[]; readonly makespan: number; readonly criticalPath: readonly string[] }

export function buildNodes(cfg: TimelineConfig): Map<string, Node> {
  const nodes = new Map<string, Node>();
  for (const t of cfg.sharedTasks) nodes.set(t.id, { id: t.id, name: t.name, dur: t.manDays, deps: [] });
  for (const p of cfg.platforms) {
    nodes.set(`${p.id}.integrate`, { id: `${p.id}.integrate`, name: `${p.name} 接入`, dur: p.integrateManDays, deps: [...p.needsShared] });
    nodes.set(`${p.id}.submit`, { id: `${p.id}.submit`, name: `${p.name} 提审`, dur: p.submitDays, deps: [`${p.id}.integrate`] });
    nodes.set(`${p.id}.review`, { id: `${p.id}.review`, name: `${p.name} 审核`, dur: p.reviewDays, deps: [`${p.id}.submit`] });
  }
  return nodes;
}

export function cpm(nodes: Map<string, Node>): CpmResult {
  const succ = new Map<string, string[]>();
  const indeg = new Map<string, number>();
  for (const id of nodes.keys()) { succ.set(id, []); indeg.set(id, 0); }
  for (const n of nodes.values()) for (const d of n.deps) { succ.get(d)!.push(n.id); indeg.set(n.id, indeg.get(n.id)! + 1); }
  const order: string[] = [];
  const ready = [...indeg.keys()].filter((id) => indeg.get(id) === 0).sort();
  while (ready.length) {
    const id = ready.shift()!;
    order.push(id);
    for (const s of [...succ.get(id)!].sort()) {
      indeg.set(s, indeg.get(s)! - 1);
      if (indeg.get(s) === 0) { ready.push(s); ready.sort(); }
    }
  }
  const es = new Map<string, number>(); const ef = new Map<string, number>();
  for (const id of order) {
    let start = 0;
    for (const d of nodes.get(id)!.deps) start = Math.max(start, ef.get(d)!);
    es.set(id, start); ef.set(id, start + nodes.get(id)!.dur);
  }
  const makespan = Math.max(...[...ef.values()]);
  const ends = [...nodes.keys()].filter((id) => succ.get(id)!.length === 0).sort();
  const lf = new Map<string, number>(); const ls = new Map<string, number>();
  for (const id of ends) lf.set(id, makespan);
  for (const id of [...order].reverse()) {
    if (!lf.has(id)) lf.set(id, Math.min(...succ.get(id)!.map((s) => ls.get(s)!)));
    ls.set(id, lf.get(id)! - nodes.get(id)!.dur);
  }
  const tasks: TaskRow[] = [...nodes.keys()].sort().map((id) => ({
    id, name: nodes.get(id)!.name, dur: nodes.get(id)!.dur, es: es.get(id)!, ef: ef.get(id)!,
    ls: ls.get(id)!, slack: ls.get(id)! - es.get(id)!, critical: ls.get(id)! - es.get(id)! === 0,
  }));
  const endNode = [...ends].sort((a, b) => ef.get(b)! - ef.get(a)!)[0];
  const path: string[] = [endNode];
  let cur = endNode;
  while (nodes.get(cur)!.deps.length) {
    cur = nodes.get(cur)!.deps.filter((d) => ef.get(d) === es.get(cur)).sort()[0];
    path.push(cur);
  }
  path.reverse();
  return { tasks, makespan, criticalPath: path };
}

/** 跨语言对拍摘要：与 sim/g15_timeline.py 的 digest 逐字符一致。 */
export function digest(r: CpmResult): string {
  return `makespan=${r.makespan}|nodes=${r.tasks.length}|critical=${r.criticalPath.join(" > ")}`
    + `|zeroSlack=${r.tasks.filter((t) => t.critical).length}`;
}

digest = makespan=33|nodes=18|critical=abstraction > yt_playables.integrate > yt_playables.submit > yt_playables.review|zeroSlack=4