dsh-lifecard 0.2.2 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/novel.js CHANGED
@@ -73,6 +73,24 @@ export function bookAbs(root, id) {
73
73
  return abs
74
74
  }
75
75
 
76
+ /**
77
+ * 章号能不能用。
78
+ *
79
+ * `chapterFileName` 以前会 `Math.max(1, ...)` 兜底:`0`、`-1`、`'abc'`、`null`
80
+ * 全被悄悄夹成 1。读的时候无害,写的时候是灾——`novel.script.save({index:0})`
81
+ * 会把第 1 章原来那份剧本整份盖掉,而界面上什么都没说。
82
+ * 所以凡是**要写盘**的地方,先用这个判一遍。
83
+ */
84
+ export function isValidChapterIndex(index) {
85
+ if (typeof index === 'number') {
86
+ return Number.isInteger(index) && index >= 1 && index <= MAX_CHAPTERS
87
+ }
88
+ const text = String(index ?? '').trim()
89
+ if (!/^[0-9]{1,3}$/.test(text)) return false
90
+ const n = Number(text)
91
+ return Number.isInteger(n) && n >= 1 && n <= MAX_CHAPTERS
92
+ }
93
+
76
94
  /** 章文件名:`001.md` —— 补零到三位,字典序就是章序。 */
77
95
  export function chapterFileName(index) {
78
96
  const n = Math.max(1, Math.min(MAX_CHAPTERS, Math.floor(Number(index) || 1)))
@@ -124,7 +142,8 @@ export async function readBook(root, id) {
124
142
  text = await fs.readFile(abs, 'utf8')
125
143
  } catch (error) {
126
144
  if (error?.code === 'ENOENT') return { ok: false, error: '这本书不在了' }
127
- return { ok: false, error: '这本书的命令行读不出来。检查一下文件夹权限。' }
145
+ if (error?.code === 'EISDIR') return { ok: false, error: '这本书的位置被一个文件夹占住了,里面可能被别的东西动过。' }
146
+ return { ok: false, error: '这本书打不开。用访达看一眼那个文件夹还在不在。' }
128
147
  }
129
148
  const parsed = parseBookText(text)
130
149
  if (parsed.ok !== true) return parsed
@@ -494,7 +513,6 @@ export async function writeOutline(root, id, text) {
494
513
  return { ok: true, path: rel, chapters: parsed.chapters.length, theme: parsed.theme, ending: parsed.ending }
495
514
  }
496
515
 
497
- /** 取一章结尾的若干字(给下一章当「上一章结尾」)。 */
498
516
  /**
499
517
  * 把一场酒馆对话改写成小说的正文。
500
518
  *
@@ -541,6 +559,1474 @@ export function buildChatToChapterPrompt({ cardName, bookTitle, turns, note }) {
541
559
  return { system, user: lines.join('\n') }
542
560
  }
543
561
 
562
+ // ── 改成剧本 ──────────────────────────────────────────────────────
563
+ //
564
+ // 小说和剧本不是同一件事。小说里「他想起十六岁那年的雨」写得再好,也没法拍、
565
+ // 没法配音;剧本里「△他把碗放下,看着门口」在小说里又太干。所以这里是
566
+ // **改写**,不是排版:叙述换成能演的动作,心理换成表情、动作和台词,
567
+ // 一章切成一串场。
568
+ //
569
+ // 落盘形状:`books/<书 id>/scripts/<章号>.md`,一章一份。为什么跟章号同名:
570
+ // 剧本是按章改出来的,章号就是它的身份;再编一套号,人回头想找
571
+ // 「第三章改出来的那份」就得多记一个数。
572
+
573
+ /** 剧本放在书目录下的哪个子文件夹。 */
574
+ export const SCRIPT_DIR = 'scripts'
575
+
576
+ /**
577
+ * 剧本的落盘路径(工作区相对)。
578
+ *
579
+ * 章号过一遍 `chapterFileName`,和 `chapters/` 那边保持同一个三位数,
580
+ * 于是 `scripts/003.md` 和 `chapters/003.md` 一眼能对上。
581
+ */
582
+ export function scriptRelPath(id, index) {
583
+ const n = chapterIndexOf(chapterFileName(index))
584
+ return path.posix.join(bookRelPath(id), SCRIPT_DIR, chapterFileName(n))
585
+ }
586
+
587
+ /** 读一份剧本。没改过这一章也正常,返回空串。 */
588
+ export async function readScript(root, id, index) {
589
+ const rel = scriptRelPath(id, index)
590
+ const target = path.join(root, rel)
591
+ try {
592
+ const text = await fs.readFile(target, 'utf8')
593
+ // 文件被别的软件写坏过(非法编码、混进 NUL)时,Node 不报错,
594
+ // 只把这些字节换成替换字符。以前它就这样静静当成一份正常剧本显示出来。
595
+ if (text.includes('\uFFFD') || text.includes('\u0000')) {
596
+ return { ok: false, error: '这份剧本的内容坏了(可能被别的软件改过)。可以用访达打开那个文件看一眼,或者删掉重新改一份。' }
597
+ }
598
+ return { ok: true, path: rel, text }
599
+ } catch (error) {
600
+ if (error?.code === 'ENOENT') {
601
+ // `scripts/1.md` 这种没补零的名字也算这一章(章列表里会显示「有剧本」)。
602
+ // 只按规范名读的话,列表说有、打开却是空的——人只会以为剧本丢了。
603
+ // 所以规范名读不到时,退回去找同章号的别的写法(只在读不到时才多一次目录读)。
604
+ const fallback = await findScriptFile(root, id, index)
605
+ if (fallback !== null) {
606
+ try {
607
+ const other = await fs.readFile(path.join(root, fallback.rel), 'utf8')
608
+ if (other.includes('\uFFFD') || other.includes('\u0000')) {
609
+ return { ok: false, error: '这份剧本的内容坏了(可能被别的软件改过)。可以用访达打开那个文件看一眼,或者删掉重新改一份。' }
610
+ }
611
+ return { ok: true, path: fallback.rel, text: other, alias: true }
612
+ } catch {
613
+ // 退路也读不到,就还是当没有。
614
+ }
615
+ }
616
+ return { ok: true, path: rel, text: '', missing: true }
617
+ }
618
+ return { ok: false, error: '这份剧本读不出来。检查一下文件权限。' }
619
+ }
620
+ }
621
+
622
+ /** 找这一章剧本的另一种文件名(`1.md`、`001.MD`)。找不到回 null。 */
623
+ async function findScriptFile(root, id, index) {
624
+ const n = chapterIndexOf(chapterFileName(index))
625
+ if (n === 0) return null
626
+ const dir = path.join(root, bookRelPath(id), SCRIPT_DIR)
627
+ const names = await fs.readdir(dir).catch(() => null)
628
+ if (names === null) return null
629
+ const candidates = names
630
+ .filter((name) => chapterIndexOf(name) === n && name !== chapterFileName(n))
631
+ .sort()
632
+ if (candidates.length === 0) return null
633
+ return { file: candidates[0], rel: path.posix.join(bookRelPath(id), SCRIPT_DIR, candidates[0]) }
634
+ }
635
+
636
+ /** 写一份剧本(整份覆盖,先写临时文件再改名)。 */
637
+ export async function writeScript(root, id, index, text) {
638
+ if (isValidChapterIndex(index) !== true) {
639
+ return { ok: false, error: '章号不对,没法知道你说的是哪一章。' }
640
+ }
641
+ const book = await readBook(root, id)
642
+ if (book.ok !== true) return book
643
+ const n = chapterIndexOf(chapterFileName(index))
644
+ // 库函数也要自己看一眼这一章在不在:路由层会先过 scriptTarget,
645
+ // 但别处(批量导入、模板复制)直接调这里就会写出一份永远显示不出来、
646
+ // 删章也删不掉的孤儿剧本。
647
+ if (!Array.isArray(book.chapters) || !book.chapters.some((c) => Number(c.index) === n)) {
648
+ return { ok: false, error: `这本书没有第 ${n} 章。先翻到真正的那一章再存。` }
649
+ }
650
+ // 库函数自己也要挡一道:路由层会先拦空白,但别处直接调这里
651
+ // 会安安静静写出一个 0 字节的文件,之后读回来是空的,人以为剧本没了。
652
+ if (typeof text !== 'string' || text.trim() === '') {
653
+ return { ok: false, error: '这一份是空的,没往里存。' }
654
+ }
655
+ const rel = scriptRelPath(id, n)
656
+ const abs = path.join(root, rel)
657
+ // 模型把整份剧本包在 ``` 里,界面又把这份原样交回来存。
658
+ // 不剥就落盘,下一章 draft 会把上一章最后一场(带着围栏)带进去,
659
+ // 那份新剧本第一行就成了「```」,扫描器一路报「没归位」。
660
+ const body = stripFence(String(text))
661
+ if (body.trim() === '') return { ok: false, error: '这一份是空的,没往里存。' }
662
+ const tmp = `${abs}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 8)}`
663
+ try {
664
+ await fs.mkdir(path.dirname(abs), { recursive: true })
665
+ await fs.writeFile(tmp, body, 'utf8')
666
+ await fs.rename(tmp, abs)
667
+ } catch (error) {
668
+ // 写失败会把半截临时文件留在那儿,下次列剧本时又被当成 `名字.md.tmp-xxx` 混过去。
669
+ await fs.unlink(tmp).catch(() => null)
670
+ if (error?.code === 'ENOSPC') return { ok: false, error: '磁盘满了,这份剧本没存下来。' }
671
+ if (error?.code === 'EACCES' || error?.code === 'EPERM') return { ok: false, error: '这个文件夹不让写。用访达看一眼它的权限。' }
672
+ if (error?.code === 'EISDIR' || error?.code === 'ENOTDIR') return { ok: false, error: '那个位置上被别的东西占着,这份剧本没存下来。' }
673
+ return { ok: false, error: '这份剧本没能存下来。再试一次;还是不行就先关掉重开。' }
674
+ }
675
+ // 字数跟报告、跟列表一个口径:去掉空白以后的字数。
676
+ // 用 body.length 的话,同一份剧本存的时候一个数、列的时候另一个数、报告里第三个。
677
+ return { ok: true, index: n, path: rel, chars: body.replace(/\s/g, '').length }
678
+ }
679
+
680
+ /** 删一份剧本。章不删,只删改出来的这份。 */
681
+ export async function deleteScript(root, id, index) {
682
+ const rel = scriptRelPath(id, index)
683
+ try {
684
+ await fs.unlink(path.join(root, rel))
685
+ } catch (error) {
686
+ if (error?.code === 'ENOENT') return { ok: true, gone: true }
687
+ return { ok: false, error: '这份剧本没能删掉。检查一下文件权限。' }
688
+ }
689
+ return { ok: true }
690
+ }
691
+
692
+ /** 列这本书已经改出来的剧本(按章号排)。 */
693
+ export async function listScripts(root, id) {
694
+ const dir = path.join(root, bookRelPath(id), SCRIPT_DIR)
695
+ let names
696
+ try {
697
+ names = await fs.readdir(dir)
698
+ } catch (error) {
699
+ if (error?.code === 'ENOENT') return { ok: true, scripts: [] }
700
+ return { ok: false, error: '剧本目录读不出来。检查一下文件夹权限。' }
701
+ }
702
+ const scripts = []
703
+ // `1.md`、`001.md`、`002.MD` 会被读成同一个章号(章号正则不区分大小写、不要求补零)。
704
+ // 同一个章号只报一条,按「名字最规范」的那份算:先比是不是三位补零,再比是不是小写。
705
+ const seen = new Map()
706
+ for (const name of names) {
707
+ const index = chapterIndexOf(name)
708
+ if (index === 0) continue
709
+ const stat = await fs.stat(path.join(dir, name)).catch(() => null)
710
+ if (stat === null || !stat.isFile()) continue
711
+ const canonical = name === chapterFileName(index)
712
+ const prev = seen.get(index)
713
+ if (prev !== undefined) {
714
+ // 已经有更好的那份就不换;都是非规范名时留字典序靠前的,至少两次结果一样。
715
+ if (prev.canonical === true) continue
716
+ if (canonical !== true && prev.file <= name) continue
717
+ }
718
+ let scenes = 0
719
+ let chars = 0
720
+ try {
721
+ const text = await fs.readFile(path.join(dir, name), 'utf8')
722
+ scenes = parseScriptScenes(text).scenes.length
723
+ // 字数要和报告、和界面上那个数字一个口径:去掉空白以后的字数。
724
+ // 以前这里用的是文件字节数(UTF-8 一个汉字三字节),
725
+ // 同一份剧本在三个地方显示三个数字,人不知道该信哪个。
726
+ chars = text.replace(/\s/g, '').length
727
+ } catch {
728
+ scenes = 0
729
+ chars = 0
730
+ }
731
+ seen.set(index, {
732
+ index,
733
+ file: name,
734
+ canonical,
735
+ path: path.posix.join(bookRelPath(id), SCRIPT_DIR, name),
736
+ chars,
737
+ scenes,
738
+ mtime: stat.mtime.toISOString(),
739
+ })
740
+ }
741
+ for (const entry of seen.values()) scripts.push({ ...entry })
742
+ scripts.sort((a, b) => a.index - b.index)
743
+ return { ok: true, scripts }
744
+ }
745
+
746
+ /**
747
+ * 拆一行场头:`客厅 日 内` → `{place:'客厅', dayNight:'日', inOut:'内'}`。
748
+ *
749
+ * 认不出来就回 null,不要硬拆。失败一次只是「这场没读到场头」,硬拆出来的
750
+ * 假场头会让人以为分场错了——`林小雨(低声)说:"走吧。"` 那行就曾经被当成
751
+ * 一个叫「林小雨(低声)说」的地方。
752
+ */
753
+ function parseSceneHeadLine(line) {
754
+ // 这一支是公开导出的(`export { parseSceneHeadLine }`),别处会直接把
755
+ // `**客厅 日 内**` 这样的行递进来。`scanScript` 入口先剥过壳,所以界面看不出来;
756
+ // 两个入口行为不一致迟早出事,干脆在这里自己剥一次。
757
+ // 场号和场头写在同一行很常见(`## 第3场 门外 夜 外`),
758
+ // 别处直接把整行递进来时,场号得先摘掉,否则地名会变成「第3场 门外」。
759
+ const raw = String(line ?? '').trim()
760
+ // 整行套一层方括号(`【第1场 客厅 日 内】`、`[第2场 门外 夜 外]`)也要剥:
761
+ // 只剥行首的「【第1场」会把行尾的「内】」留在地名里。
762
+ .replace(/^[【\[]\s*/, '')
763
+ .replace(/\s*[】\]]$/, '')
764
+ .replace(/^[#>*_\s]+/, '')
765
+ .replace(/[#>*_\s]+$/, '')
766
+ .replace(/^(?:[【\[]?\s*第\s*[0-90-9一二三四五六七八九十百零〇两]+\s*[场幕]\s*[】\]]?\s*[::·.、]?|场景\s*[0-90-9]+\s*[::·.、]?|场次\s*[0-90-9]+\s*[::·.、]?)\s*/, '')
767
+ if (raw === '') return null
768
+ if (/^[△▲→▵Δ]/.test(raw) || raw.startsWith('【')) return null
769
+ // 有冒号或引号的都是台词,不是地点。直角引号(「」『』)也算引号——
770
+ // 台词写成 `林小雨:「走吧。」` 时,这一行照样不是场头。
771
+ if (/[::]/.test(raw) || /["“”「」『』]/.test(raw)) return null
772
+ // 「客厅(日)内」「会议室(白天)内」:括号里只写时间/内外的,把它拽出来
773
+ // 当分隔符用。其它括号(`客厅(二楼)`)留给下面的判据——那是地名的一部分,
774
+ // 现在一律当「不是场头」,宁可漏也不瞎猜。
775
+ // 行尾的括注(`客厅 日 内(回忆场,可加旧滤镜)`)是备注,不是地名的一部分。
776
+ // 先整个剪掉;剪完还带括号的,才走下面「括号在地名中间」那条判据。
777
+ const trimmedTail = raw.replace(/\s*[((][^(())]{0,60}[))]\s*$/g, ' ').replace(/\s*【[^【】]{0,40}】\s*$/g, ' ').trim()
778
+ const unwrapped = trimmedTail.replace(/[((]\s*(日|夜|晨|清晨|黎明|早晨|上午|中午|下午|午后|黄昏|傍晚|晚上|深夜|半夜|凌晨|白天|内|外|内景|外景|室内|室外)\s*[))]/g, ' $1 ')
779
+ // 不拆 `·`:`旧书店·门厅`「省城·外滩」是地名的一部分,拆开会把地名改掉。
780
+ // 全角斜杠和全角竖线要当分隔符:中文输入法下「客厅/日/内」是最常见的写法之一。
781
+ const parts = unwrapped.split(/[\s/|、/|]+/).filter((x) => x !== '')
782
+ let dayNight = ''
783
+ let inOut = ''
784
+ // 「院子里面 夜 外」:`里面` 是内外词,后面又明写了「外」。
785
+ // 明写的那个说了算——早先按先后顺序取第一个,地名成了「院子」、内外成了「内」,
786
+ // 人明明写的是屋外,读出来是屋里,还一条不报。
787
+ let inOutStrict = ''
788
+ let inOutTail = ''
789
+ const rest = []
790
+ for (const part of parts) {
791
+ if (isDayNightPart(part)) {
792
+ // 第二个「日」「夜」是多余的,丢掉,不许掉进地名里。
793
+ if (dayNight === '') dayNight = part
794
+ continue
795
+ }
796
+ // 内景/室内 统一记成「内」;「里面 / 里边 / 室内」这类写法也认。
797
+ // 「院子里面」这种:里面是内外词,院子是地名,得留下——
798
+ // 早先整段都当内外词吞掉,一场戏的地点就变成空的,而且日夜内外都写了,
799
+ // 一条提示都不报。
800
+ const innerTail = /^(.*?)(?:里面|里边|里头)$/.exec(part)
801
+ const outerTail = /^(.*?)(?:外面|外边|外头)$/.exec(part)
802
+ const inner = /^(内|内景|室内|里面|里边|里头|室内景)$/.test(part) || innerTail !== null
803
+ const outer = /^(外|外景|室外|外面|外边|外头|室外景)$/.test(part) || outerTail !== null
804
+ if (inner || outer) {
805
+ // 第二个「内」「外」也是多余的:以前它会被当成地名,
806
+ // 「室内 日 内」读出来地点就成了「内」。
807
+ // 单独的「内/外」最可信;「院子里面」这种带地名的只当备选,
808
+ // 后面只要出现明写的「外」,就按「外」算。
809
+ if (inner && part === '内' || part === '内景' || part === '室内' || part === '室内景') {
810
+ if (inOutStrict === '') inOutStrict = '内'
811
+ } else if (part === '外' || part === '外景' || part === '室外' || part === '室外景') {
812
+ if (inOutStrict === '') inOutStrict = '外'
813
+ } else if (inOutTail === '') {
814
+ inOutTail = inner ? '内' : '外'
815
+ }
816
+ const leftover = innerTail !== null ? innerTail[1] : (outerTail !== null ? outerTail[1] : '')
817
+ if (leftover !== '') rest.push(leftover)
818
+ continue
819
+ }
820
+ rest.push(part)
821
+ }
822
+ inOut = inOutStrict !== '' ? inOutStrict : inOutTail
823
+ const place = rest.join(' ')
824
+ // 只写了「室内 日 内」、没写是哪儿:日夜内外认下来了,地点留空
825
+ // (后面会报「没写清在哪儿」,但不该把整行丢掉)。
826
+ if (place === '') {
827
+ if (dayNight === '' && inOut === '') return null
828
+ return { place: '', dayNight, inOut }
829
+ }
830
+ // 行尾的括注(`客厅 日 内(回忆场,可加旧滤镜)`)是给人看的备注。
831
+ // 先把一个个「(…)」拿掉再判;拿完还带括号,说明括号在名字中间,才判不是场头。
832
+ if (/[(())]/.test(place)) return null
833
+ // 地名不会带句读:「他推开门,外面天黑了 夜 内」不是场头。
834
+ if (/[,。!?;]/.test(place)) return null
835
+ // 既没写日夜也没写内外,那就得短到像个地名;一句叙述肯定不是场头。
836
+ if (dayNight === '' && inOut === '' && place.length > 16) return null
837
+ return { place, dayNight, inOut }
838
+ }
839
+
840
+ /**
841
+ * 这一小段是不是「白天还是夜里」。
842
+ *
843
+ * 白名单以前只有「日 夜 晨 清晨 … 白天」这一串,模型把 `日间`、`晚间` 直接当
844
+ * 场头写进来(`客厅 日间 内`),整段被当地名,于是报「没写清是白天还是夜里」——
845
+ * 人明明写了。时刻写法(`深夜两点`、`凌晨三点`)一起认。
846
+ */
847
+ function isDayNightPart(part) {
848
+ const text = String(part ?? '').trim()
849
+ if (text === '') return false
850
+ if (/^(日|夜|日间|夜间|晨|清晨|黎明|早晨|早|早上|早间|上午|中午|午|午间|下午|午后|黄昏|傍晚|晚|晚上|晚间|深夜|半夜|凌晨|白天|白昼|夜晚|夜里|黑天|晴|阴|阴天|雨天|雨夜|雪天|月夜)$/.test(text)) return true
851
+ // 深夜两点 / 凌晨三点半 / 早上七点
852
+ return /^(?:凌晨|深夜|清晨|早晨|早上|上午|中午|下午|傍晚|晚上)?[0-90-9一二三四五六七八九十百零〇两]{1,3}\s*点(?:半|一刻|[0-90-9]{1,2}\s*分)?$/.test(text)
853
+ }
854
+
855
+ /**
856
+ * 这些「说话人」其实不是人:旁白、画外音、字幕。
857
+ *
858
+ * 提示词里写着不许用旁白,可模型还是会写 `旁白:"三年后。"`。以前这一行被
859
+ * 当成合法台词,说话人「旁白」还被并进出场人物,整场演员表就多一个人。
860
+ */
861
+ const NARRATOR_NAMES = ['旁白', '画外音', '画外', '字幕', '字幕卡', '说明字幕', '解说']
862
+
863
+ /**
864
+ * 冒号左边这些字不是说话人,是场记标签。
865
+ *
866
+ * `音乐:轻快的钢琴。` `光线:偏暗。` 这种行以前会被读成「一个叫音乐的人在说话」:
867
+ * 演员表里凭空多出「音乐」「光线」两个角色,占掉一句台词,
868
+ * 而且因为台词正文里没有镜头词,扫描器一条不报——写了不该写的东西,却查不出来。
869
+ *
870
+ * 这里把它挡在台词之外:交给主循环按标签处理(收进备注,或者照常报成镜头话)。
871
+ */
872
+ const STAGE_LABELS = [
873
+ '时间', '地点', '场景', '场次时间', '服装', '化妆', '备注', '说明', '注', '天气',
874
+ '氛围', '基调', '音效', '声音', '音乐', '配乐', '光线', '色温',
875
+ '镜头', '景别', '机位', '特写', '分镜', '时长', '转场',
876
+ '场记', '注意', '提示', '调度', '动作提示', '表演提示',
877
+ ]
878
+
879
+ /**
880
+ * 拆一行台词:`林小雨(把伞推回去)说:"雨停了。"`
881
+ *
882
+ * 也认不带引号的写法:`甲:走吧。`(中文剧本和话剧台本最标准的样子)。
883
+ */
884
+ export function parseDialogueLine(line, opts) {
885
+ // `**甲(没抬头)说:"走。"**`:模型爱给台词加粗,不剥壳整行就作废、台词消失。
886
+ let raw = String(line ?? '').trim().replace(/^[*_`#>\s]+/, '').replace(/[*_`\s]+$/, '')
887
+ if (raw === '' || /^[△▲→▵Δ]/.test(raw) || raw.startsWith('【')) return null
888
+ // `甲:(低声)"走吧。"` —— 括号写在冒号后面。标准写法是 `甲(低声):"…"`,
889
+ // 但这么写的剧本不少,整行作废太浪费:把括号挪到冒号前面再走同一条路。
890
+ const afterColon = /^(.{1,30}?)\s*[::]\s*([((][^))]{0,200}[))])\s*(["“「『].*)$/.exec(raw)
891
+ if (afterColon !== null) raw = `${afterColon[1]}${afterColon[2]}:${afterColon[3]}`
892
+ // 冒号左边是「名字」或「名字(括号里一句)」,名字后面可以带一个说法词。
893
+ // 名字放宽到 20 字:`角落里那个一直没说话的男人说` 这种写法在戏里很常见,
894
+ // 卡在 12 字会整行作废,最后落进「没归位」。
895
+ // 括号里那句可以很长(「把伞往回一推,声音低下去」)。
896
+ // 引号三种都收:中文弯引号(“…”)、直角引号(「…」)、普通引号("…")。
897
+ // 引号里的台词允许再套引号(`甲说:"他说"好"就挂断了。"`),所以取到最后一个引号为止。
898
+ // 台词后面还可以再跟一个括注(`甲说:"走。"(把门带上)`):那也是动作,不是台词的一部分。
899
+ //
900
+ // 括注放宽到 200 字:模型给一个动作写长括注(「从门边退开半步,把湿透的头发
901
+ // 别到耳后,又像是想起什么似的停住」)非常常见,卡在 60 字整行就作废、台词消失。
902
+ // 名字放宽到 30 字同理。半角括号也收(`甲(低声)说` 以前把「甲(低声)」整个人名收下)。
903
+ //
904
+ // 引号也可以没有:中文剧本、话剧台本最标准的写法就是 `甲:走吧。`。
905
+ // 只是无引号这一支要求行尾有句末标点,否则一句描述会被当成台词。
906
+ const SAYING = '(?:说|道|问|答|喊|叫|念|嚷|吼|应|叹|回|接|嘟囔|嘀咕|笑道|低声道|轻声道|冷笑道)?'
907
+ const quoted = new RegExp('^([^::((]{1,30}?)\\s*(?:[((]([^))]{0,200})[))])?\\s*' + SAYING + '\\s*[::]\\s*["“「『](.*?)["”」』]\\s*(?:[((]([^))]{0,200})[))])?\\s*$').exec(raw)
908
+ let hit = quoted
909
+ if (hit === null) {
910
+ // 台词后面紧跟一句没改成动作的叙述:`甲说:"好。"他转身走了。`
911
+ // 严格那一支会把整行判废、台词一起丢掉。这一支只要求「引号后面那段里没有引号」,
912
+ // 才不会把套引号的台词(`甲说:"他说"好"就挂断了。"`)切错。
913
+ const tailed = new RegExp('^([^::((]{1,30}?)\\s*(?:[((]([^))]{0,200})[))])?\\s*' + SAYING + '\\s*[::]\\s*["“「『](.*?)["”」』]\\s*([^"“”「」『』]{1,120})$').exec(raw)
914
+ if (tailed !== null) hit = [tailed[0], tailed[1], tailed[2], tailed[3], undefined, tailed[4]]
915
+ }
916
+ if (hit === null) {
917
+ // 不带引号:冒号后面直接是话,且话说到句末。
918
+ // 这一支最容易闯祸:`他想起一句话:雨停了。` `那年冬天:雪下得很大。`
919
+ // 都是小说正文,冒号左边一长串全是叙述。照单收下的话,最该被指出来的那种行
920
+ // 反而成了「合法台词」,演员表里还多出一个叫「他想起一句话」的人。
921
+ // 所以名字要过一道「像不像一个人」的检验。
922
+ const bare = /^([^::((]{1,30}?)\s*(?:[((]([^))]{0,200})[))])?\s*(?:说|道|问|答|喊|叫|念|嚷|吼|应|叹|回|接|嘟囔|嘀咕)?\s*[::]\s*([^"“”「」『』]{1,200}?[。!?…~]+)\s*$/.exec(raw)
923
+ if (bare !== null) {
924
+ const candidate = stripSaying(String(bare[1] ?? '').trim())
925
+ if (looksLikeSpeaker(candidate, String(bare[1] ?? '').trim(), opts?.names)) {
926
+ hit = [bare[0], candidate, bare[2], bare[3], undefined]
927
+ }
928
+ }
929
+ }
930
+ if (hit === null) return null
931
+ const body = String(hit[3] ?? '').trim()
932
+ // 台词前后的括注(`甲(低声)说` 与 `甲说:"…"(把门带上)`)都算这一句的表演提示。
933
+ const parenText = [String(hit[2] ?? '').trim(), String(hit[4] ?? '').trim()].filter((x) => x !== '').join(';')
934
+ // 先留一份没剥过的:剥后缀会顺手把「慢慢」「低声」这类副词吃掉,
935
+ // 之后再看「逗号后面是不是叙述」就看不出来了(`才慢慢说` 剥完只剩「才」)。
936
+ const rawWho = String(hit[1] ?? '').trim()
937
+ let who = stripSaying(rawWho)
938
+ // 「这时候门开了,林小雨说:」——冒号左边塞了半句叙述,
939
+ // 以前整串被当成说话人,演员表里就多出一个叫「这时候门开了,林小雨」的人。
940
+ // 逗号后面才是名字。
941
+ const afterComma = /[,,。;;!?]\s*([^,,。;;!?]{1,20})$/.exec(rawWho)
942
+ // 「他顿了顿,看向窗外,才开口说:」——逗号后面那截是叙述,不是名字。
943
+ // 以前这类会被当成一个叫「才开口」的人,演员表里多一个幽灵角色,
944
+ // 真正的问题(这行还没改成动作或台词)反而查不出来。
945
+ if (afterComma !== null && !NARRATION_TAIL.test(afterComma[1])) who = stripSaying(afterComma[1])
946
+ if (who === '') return null
947
+ // 名字里不许有句读:有就说明冒号左边不是名字,是叙述。
948
+ if (/[,,。;;!?::]/.test(who)) return null
949
+ // 名字里也不许有连续的空白(「他把碗放下 又拿起来」)。
950
+ if (/\s{2,}/.test(who)) return null
951
+ // 旁白不是人,不进台词、更不进演员表。
952
+ if (NARRATOR_NAMES.includes(who) || STAGE_LABELS.includes(who)) return null
953
+ // 「甲说:"走。"乙说:"等等。"」写在一行里:只认第一句,
954
+ // 后面那半句跟着走,让上层报「这行没归位」,别把两个人的话拼成一句。
955
+ // 判据要看「引号后面紧跟一个『某人说:』」——台词里套引号
956
+ // (`甲说:"他说"好"就挂断了。"`)没有那个冒号,不能误切。
957
+ const second = /["”」』]\s*([^"“”「」『』\n]{1,20}?(?:说|道|问|喊|答|叫|嘟囔|嘀咕)[::])\s*["“「『]/.exec(body)
958
+ const text = second === null ? body : body.slice(0, second.index).trim()
959
+ const rest = second === null
960
+ ? String(hit[5] ?? '').trim()
961
+ : `${second[1]} ${body.slice(second.index + second[0].length).trim()}`.trim()
962
+ return {
963
+ who,
964
+ paren: parenText,
965
+ text: text.trim(),
966
+ rest,
967
+ line: String(line ?? '').trim(),
968
+ }
969
+ }
970
+
971
+ /** 「没人」的几种写法。它们不是人名。 */
972
+ const PLACEHOLDER_NAMES = ['无', '沒有', '-', '—', '–', '-', '略', '空', '暂无', '没有', '无人物', 'N/A', 'n/a', 'NA']
973
+
974
+ /**
975
+ * 逗号后面那截是叙述、不是名字:「才开口」「终于开口」「才慢慢」「回头看」。
976
+ *
977
+ * 这些词出现在名字的位置上,说明冒号左边整句都是散文,主角还没开口。
978
+ * 认错了会凭空多出一个演员(叫「才开口」),而这行本该被报成「还没归位」,
979
+ * 检查就失效了。
980
+ */
981
+ const NARRATION_TAIL = /(?:开口|继续|终于|忽然|突然|然后|于是|只好|这才|顿了顿|想了想|愣了一下|叹了口气|回过神|抬|低|转|笑|看|停|沉默|慢慢|轻声|低声)/
982
+
983
+ /** 明显是叙述里那种泛称主语,不是人名。 */
984
+ const PRONOUN_SPEAKERS = /^(?:他|她|我|你|它|谁|有人|某人|大家|众人|所有人|两人|三个人|他们|她们|我们|你们)$/
985
+
986
+ /**
987
+ * 不带引号的那一支要不要认这行台词:冒号左边得像一个人。
988
+ *
989
+ * `甲:走吧。` 是台词;`他想起一句话:雨停了。` 是小说还没改过来。
990
+ * 区别不在有没有冒号,在冒号左边那一串是不是一个人名。三条判据从宽到严:
991
+ *
992
+ * 1. 已经在【出场人物】里登记过的名字(`names`)一律认——作者自己写了这张表;
993
+ * 2. 两到四个字、不含「说写想念问答的了吗着过」、不含空白,按人名认;
994
+ * 3. 其余一律不认,让这行照常落进「没归位」,由人自己看要不要改。
995
+ */
996
+ function looksLikeSpeaker(candidate, original, names) {
997
+ const name = String(candidate ?? '').trim()
998
+ if (name === '') return false
999
+ const pool = Array.isArray(names) ? names : []
1000
+ if (pool.length > 0 && (pool.includes(name) || pool.includes(stripSaying(name)))) return true
1001
+ if (PRONOUN_SPEAKERS.test(name)) return false
1002
+ // 带这些字的多半是整句散文的主语:「母亲在信里写」「他想起一句话」。
1003
+ if (/[说写想念问答喊叫的了吗着过]/.test(name)) return false
1004
+ // 「那年冬天:雪下得很大。」「广播里说:列车晚点。」冒号左边是时间、地点,
1005
+ // 不是人。按时间起头、按方位收尾的那种一律不认。
1006
+ if (/^(?:那|这|此|其|当)[年月日天夜早晚]/.test(name)) return false
1007
+ if (name.length <= 4 && /(?:里|中|上|下|内|外|前|后|边|旁|间)$/.test(name)) return false
1008
+ // 单字(`甲:走吧。`、`乙说:"等等。"`)在剧本里就是主角本人,得认。
1009
+ if (name.length < 1 || name.length > 4) return false
1010
+ // 剥之前那串比名字长太多,说明冒号左边还有别的字,是句子不是名字。
1011
+ if (String(original ?? '').trim().length > name.length + 1) return false
1012
+ return true
1013
+ }
1014
+
1015
+ /**
1016
+ * 拆一行「心里想的」:`(心里想:他不会回来了。)`。
1017
+ *
1018
+ * 用户那份《小说改剧本》里,心理戏的最后一道口子是「最多一句心里想的」。
1019
+ * 这一行要单独认出来,否则它会被人当成出场人物(括号里那串全被 splitNames 收进 cast)。
1020
+ */
1021
+ export function parseThoughtLine(line) {
1022
+ const raw = String(line ?? '').trim()
1023
+ if (raw === '') return null
1024
+ // 括号里那句心里话本身可能还带括号(「(心里想:他走了。(真的走了))」),
1025
+ // 所以取到最后一个右括号为止,而不是第一个。
1026
+ const bracketed = /^[((]\s*([^((]{0,6}?)\s*(?:心里想|心想|内心|心里|暗自)[::]\s*([\s\S]*)[))]\s*$/.exec(raw)
1027
+ if (bracketed !== null) {
1028
+ return { text: String(bracketed[2] ?? '').trim(), line: raw }
1029
+ }
1030
+ // 也有人不带括号,就这么写一行「心里想:他走了。」
1031
+ const bare = /^(?:心里想|心想|内心独白|内心|暗自)[::]\s*([\s\S]*)$/.exec(raw)
1032
+ if (bare !== null) return { text: String(bare[1] ?? '').trim(), line: raw }
1033
+ return null
1034
+ }
1035
+
1036
+ /**
1037
+ * 把「林小雨道」「老周问」「她喊着说」里那个说法词剥掉。
1038
+ *
1039
+ * 剧本里「谁说」和「怎么说的」常常粘在名字后面;不剥,统计出场人物时
1040
+ * 「林小雨道」和「林小雨」会被当成两个人。
1041
+ */
1042
+ function stripSaying(name) {
1043
+ // 名字后面常粘着一串说法词:「林小雨低声说」「林小雨冷冷地说」
1044
+ // 「老周叹了口气说」。不剥干净,同一个人会在演员表里出现两次
1045
+ // (「林小雨」和「林小雨低声」),出场统计就跟着不对。
1046
+ // 一层剥一层会剩下「冷冷」,所以要一直剥到不再变短为止。
1047
+ const SAY = /(?:说|道|问|答|喊|叫|念|嚷|吼|笑|哭|应|叹|回|接|嘟囔|嘀咕)$/
1048
+ // 只剩两个字的时候不能照上面那串剥:「道」「问」「笑」「念」「应」「回」「叹」
1049
+ // 在中文姓名里到处都是(张道、苏问、王笑、白念、陈应、沈回、郑叹),
1050
+ // 剥掉就把一个人变成另一个人。只有这几个几乎不做名字末字的才敢剥。
1051
+ const SAFE_SAY = /(?:说|喊|叫|答|嚷|吼|哭)$/
1052
+ // 「甲又说」「乙接着说」:这几个字是连接,不是名字。
1053
+ const LINK = /(?:又|再|接着|然后|继续|随后|补了?一句|转了?头|回过?头)$/
1054
+ const ADVERB = /(?:低声|轻声|大声|高声|小声|冷冷|淡淡|慢慢|轻轻|急急|忙忙|缓缓|沉沉|咬着牙|皱着眉|瞪着眼|叹口气|叹了口气|没抬头|抬起头|转过身|别过头)$/
1055
+ let out = String(name ?? '').trim()
1056
+ for (let round = 0; round < 6; round++) {
1057
+ const before = out
1058
+ // 剥之前先看名字还剩多长:两个字的名字差不多就是全名了,
1059
+ // 除了「说/喊/叫」这一类,一个字都不动(`白念` 不许变成 `白`)。
1060
+ const mayStrip = out.length > 2
1061
+ if (mayStrip) out = out.replace(ADVERB, '')
1062
+ if (out.length > 2) out = out.replace(/[的地]$/, '')
1063
+ if (out.length > 2 || SAFE_SAY.test(out)) out = out.replace(SAY, '')
1064
+ if (out.length > 2) out = out.replace(/[的了着]$/, '')
1065
+ // 连接词紧跟单字人名(`甲又说` → `甲`)也得剥:正则先把「说」吃掉,
1066
+ // 剩下「甲又」已经只有两个字,光看长度就不敢动了,人就多一个「甲又」。
1067
+ if (out.length > 1) out = out.replace(LINK, '')
1068
+ if (out === before) break
1069
+ }
1070
+ // 行首的数字编号(`1. 甲说:…`)是清单号,不是名字的一部分。
1071
+ out = out.replace(/^[0-90-9一二三四五六七八九十]{1,3}\s*[..、]\s*/, '')
1072
+ return out.trim()
1073
+ }
1074
+
1075
+ /** 把 `甲、乙 丙` 拆成名字数组。 */
1076
+ function splitNames(text) {
1077
+ const src = String(text ?? '')
1078
+ // 「林 小雨、甲」:名字里带空格的人(复姓加名、外文名)很常见。
1079
+ // 一旦见到顿号或逗号,就说明作者已经在用分隔符了,空格只当作名字内部的分隔。
1080
+ const seps = /[、,,/]/.test(src) ? /[、,,/]+/ : /[、,,/\s]+/
1081
+ return src
1082
+ .split(seps)
1083
+ // 括注(「甲(主角)」「乙(配音:老周)」)是说明,不是名字的一部分;
1084
+ // 留着它跟人名表对不上,统计里就成了两个不同的人。
1085
+ .map((x) => x.trim().replace(/[((][^))]*[))]/g, '').trim())
1086
+ // 「无」「—」「略」是没人的意思,不是一个人。留着它,演员表里就多一个幽灵角色。
1087
+ .filter((x) => x !== '' && !PLACEHOLDER_NAMES.includes(x))
1088
+ }
1089
+
1090
+ /**
1091
+ * 把一份剧本读成「场」。
1092
+ *
1093
+ * 只认形式,不判好坏:哪几场、每场在哪儿、白天还是夜里、里面谁在、
1094
+ * 有几行动作、几句台词、有没有没归位的散行。判断交给 `scanScript`,
1095
+ * 改不改交给人。
1096
+ */
1097
+ export function parseScriptScenes(text) {
1098
+ const lines = String(text ?? '').split(/\r?\n/)
1099
+ const total = lines.length
1100
+ // 剧名一行。模型常常顺手加个 markdown 井号(`# 《雨里的门》`),也是剧名。
1101
+ const titleLine = lines.find((line) => /^\s*(?:#+\s*)?《.+》\s*$/.test(line))
1102
+ const title = titleLine === undefined
1103
+ ? ''
1104
+ : String(titleLine).trim().replace(/^#+\s*/, '').replace(/^《/, '').replace(/》$/, '')
1105
+ const scenes = []
1106
+ let preamble = []
1107
+ let current = null
1108
+ let mode = ''
1109
+
1110
+ // 用下标循环:跨行续词那一段要把下面几行吞掉,吞完得能把游标往前挪。
1111
+ for (let index = 0; index < lines.length; index++) {
1112
+ // 模型爱把整份剧本写成 markdown 列表(`- △她把伞靠在门边。`、`- 陈默:伞放门边。`)。
1113
+ // 行首那个圆点是排版,不是戏;不剥掉的话每一行都落进「没归位」,
1114
+ // 连演员表里都会多出一个叫「- 陈默」的人。
1115
+ const raw = String(lines[index] ?? '').trim().replace(/^[-*+•·]\s+/, '')
1116
+ // 场号前面可能是「【第1场】」「场景1」「1.」,后面可能是「:旧书店」。
1117
+ // 模型和人都爱写成这几种,只认「第N场」会把一份好剧本读成 0 场。
1118
+ // 场号的写法就是这些:第3场 / 第 3 场 / 【第3场】/ 场景3 / 场3 / SCENE 3 / 三、
1119
+ // 还有 markdown 和加粗壳子(`## 第3场`、`**第3场**`)——模型爱把标题加粗。
1120
+ // 一起认了,不然从别处粘回来的剧本整份读成 0 场。
1121
+ const sceneHit = SCENE_NO_RE.exec(raw)
1122
+ // 「1.」「2、」这种要先看后面是不是真场头。
1123
+ // 场内容里模型的编号行(`1. 他推开门。`、`1. 甲说:"走。"`、人物清单)到处都是,
1124
+ // 一律当场号会把一份好剧本切成十几个假场,再连报三条误报。
1125
+ // 判据只有一条:点后面得真像一行场头(写了日夜或内外),
1126
+ // 或者这一行只剩编号、场头写在下一行。
1127
+ // 捕获组:1 第N场/第N幕、2 场景N、3 场次N、4 场N/幕N、5 SCENE N、6 N.、7 中文数字、8 同行场头。
1128
+ // `1.` 单独一行、场头写在下一行(`## 第3场` 那种只差一个 #):
1129
+ // 下一行真像场头的话,这一行的编号就认。
1130
+ const nextIsHead = sceneHit !== null
1131
+ && String(sceneHit[8] ?? '').trim() === ''
1132
+ && looksLikeSceneHead(String(lines[index + 1] ?? '').trim())
1133
+ // 阿拉伯数字和中文数字这两种「编号 + 标点」写法一样要形状校验:
1134
+ // 正文里 `1. 他推开门。` 到处都是,`三、他把碗放下,转身往门口走。` 也一样,
1135
+ // 一律当场号会把叙述整行吞掉(还只报一句「第 3 场没有场头」)。
1136
+ const numberedOk = sceneHit === null
1137
+ || (sceneHit[6] === undefined && sceneHit[7] === undefined)
1138
+ || looksLikeSceneHead(sceneHit[8])
1139
+ || nextIsHead
1140
+ if (sceneHit !== null && numberedOk) {
1141
+ current = {
1142
+ no: sceneNumber(firstFilled(sceneHit[1], sceneHit[2], sceneHit[3], sceneHit[4], sceneHit[5], sceneHit[6], sceneHit[7])),
1143
+ place: '', dayNight: '', inOut: '',
1144
+ // 自己写没写【出场人物】。台词里出现的人也会并进 cast,但那是「说过话的」,
1145
+ // 不等于「写清楚谁在这一场」——两个概念要分开,否则 no-cast 永远不报。
1146
+ declared: false,
1147
+ cast: [], props: [], actions: [], dialogues: [], thoughts: [], beats: [], other: [], notes: [],
1148
+ // 原始行留着:上一章改出来的剧本,最后一场要整段带进下一章,
1149
+ // 靠「动作 + 台词」重建会丢掉场头那一行(客厅 日 内)。
1150
+ raw: [],
1151
+ }
1152
+ scenes.push(current)
1153
+ mode = ''
1154
+ // 加粗/标题壳子里的场头(`**第1场 客厅 日 内**`、`## 第3场 门外 夜 外`):
1155
+ // 行尾的 `**` 会把「内」粘成「内**」,日夜内外就认不出来了。
1156
+ let inline = String(sceneHit[8] ?? '').trim().replace(/^[#>*_\s]+/, '').replace(/[#>*_\s]+$/, '').trim()
1157
+ // 场号同行还带着标签(`第2场 客厅 夜 内 【关键道具】红伞`):
1158
+ // 把 【…】 那几段先切出来分派,剩下才是场头。
1159
+ // 以前整行当场头,标签进了地名,红伞这个道具就无声无息地没了。
1160
+ // 标签名可能带后缀(`【人物表】`、`【道具清单】`),标签后面也可能紧跟内容
1161
+ // (`【关键道具】红伞`),两截都要收。
1162
+ const tagRe = /[【\[]([^】\]]{0,40})[】\]]([^【\[]*)/g
1163
+ let tagHit = tagRe.exec(inline)
1164
+ while (tagHit !== null) {
1165
+ const tagName = String(tagHit[1] ?? '').trim()
1166
+ const tagBody = String(tagHit[2] ?? '').trim()
1167
+ inline = inline.replace(tagHit[0], ' ').trim()
1168
+ const body = tagBody.replace(/^[::]/, '').trim()
1169
+ // 标签后面那截得真像几个名字。`【人物简介】林小雨是女一。` 后面是一句话,
1170
+ // 不是名字;以前整句会被塞进演员表,表里就多一个十一字长的「人」。
1171
+ if (!looksLikeNameList(body) && body !== '') {
1172
+ current.other.push(body)
1173
+ } else if (/^(?:出场人物|出场人员|人物|登场人物|角色)/.test(tagName)) {
1174
+ for (const name of splitNames(body)) {
1175
+ if (!current.cast.includes(name)) current.cast.push(name)
1176
+ }
1177
+ if (current.cast.length > 0) current.declared = true
1178
+ } else if (/^(?:关键道具|道具)/.test(tagName)) {
1179
+ for (const prop of splitNames(body)) {
1180
+ if (!current.props.includes(prop)) current.props.push(prop)
1181
+ }
1182
+ }
1183
+ tagHit = tagRe.exec(inline)
1184
+ }
1185
+ const head = inline === '' ? null : parseSceneHeadLine(inline)
1186
+ if (head !== null && (head.dayNight !== '' || head.inOut !== '' || head.place !== '')) {
1187
+ current.place = head.place
1188
+ current.dayNight = head.dayNight
1189
+ current.inOut = head.inOut
1190
+ } else if (inline !== '') {
1191
+ // 场号后面跟的不是场头,是一句叙述(`第2场 她跑进雨里,没回头。`)。
1192
+ // 以前整段就这么扔了:不进动作、不进散行、一条提示都没有,
1193
+ // 用户永远不会知道自己少了半句。留进散行,让扫描器报「没归位」。
1194
+ current.other.push(inline)
1195
+ }
1196
+ continue
1197
+ }
1198
+ if (current === null) {
1199
+ // 第一个场号之前的行(剧名下面的说明、人物表、「本剧改编自…」)
1200
+ // 以前直接 continue,静默丢掉,谁也不知道少了几行。
1201
+ // 剧名那一行不算「没进戏」,它是标题,上面已经认出来了。
1202
+ if (raw !== '' && !/^\s*(?:#+\s*)?《.+》\s*$/.test(raw)) preamble.push(raw)
1203
+ continue
1204
+ }
1205
+ if (raw === '') { mode = ''; current.raw.push(''); continue }
1206
+ current.raw.push(raw)
1207
+
1208
+ // 这一栏的写法五花八门:【出场人物】、出场人物:、【 出场人物 】、【人物】、【登场人物】。
1209
+ // 只认一种,剩下的都读成「这场没写人」,演员表就排不出来。
1210
+ // 标签外面可能套一层加粗(`**【出场人物】** 林小雨、陈默`),一起剥。
1211
+ const castHit = /^\*{0,2}\s*[【\[]?\s*\*{0,2}\s*(?:出场人物|出场人员|人物|登场人物|角色)[^【\[\]】\n]{0,6}\s*\*{0,2}\s*[】\]]?\s*[::]?\s*\*{0,2}\s*(.*)$/.exec(raw)
1212
+ if (castHit !== null) {
1213
+ const body = String(castHit[1] ?? '').trim()
1214
+ // `【人物简介】林小雨是女一。` 后面是一句话,不是名字。
1215
+ // 以前整句被当成一个演员,表里就多一个十一字长的「人」。
1216
+ if (body === '' || looksLikeNameList(body)) {
1217
+ mode = 'cast'
1218
+ for (const name of splitNames(body)) {
1219
+ if (!current.cast.includes(name)) current.cast.push(name)
1220
+ }
1221
+ // 标签后面一个名字都没有(空着、或者写「无」)不算写清了谁在这场。
1222
+ // 早先只要出现这四个字就算,这条检查于是只查「有没有写标签」。
1223
+ if (current.cast.length > 0) current.declared = true
1224
+ } else {
1225
+ mode = ''
1226
+ current.other.push(body)
1227
+ }
1228
+ continue
1229
+ }
1230
+ const propHit = /^\*{0,2}\s*[【\[]?\s*\*{0,2}\s*(?:关键道具|道具)[^【\[\]】\n]{0,6}\s*\*{0,2}\s*[】\]]?\s*[::]?\s*\*{0,2}\s*(.*)$/.exec(raw)
1231
+ if (propHit !== null) {
1232
+ const body = String(propHit[1] ?? '').trim()
1233
+ if (body === '' || looksLikeNameList(body)) {
1234
+ mode = 'props'
1235
+ for (const prop of splitNames(body)) {
1236
+ if (!current.props.includes(prop)) current.props.push(prop)
1237
+ }
1238
+ } else {
1239
+ mode = ''
1240
+ current.other.push(body)
1241
+ }
1242
+ continue
1243
+ }
1244
+ // 「时间:深夜。」「地点:客厅。」这类场记信息。
1245
+ // 它们是正经剧本里有的东西,但**不是台词**——以前会被读成「一个叫时间的
1246
+ // 人在说话」,演员表里凭空多出「时间」「地点」两个角色,还占掉一句台词。
1247
+ // 这里单独收着,不报「没归位」(人写的是对的东西,只是不在我们认的五种行里)。
1248
+ // 注意别把「音乐:」「光线:」「音效:」收进来——那几样提示词里明写着不许写,
1249
+ // 收进备注等于把它们藏起来,扫描器就再也报不出来了。
1250
+ const noteHit = /^\*{0,2}\s*[【\[]?\s*\*{0,2}\s*(?:时间|地点|场景|场次时间|服装|化妆|备注|说明|注|天气|场记|注意|提示|调度|动作提示|表演提示)\s*\*{0,2}\s*[】\]]?\s*[::]\s*\*{0,2}\s*(.*)$/.exec(raw)
1251
+ if (noteHit !== null) {
1252
+ const noteText = String(noteHit[1] ?? '').trim()
1253
+ if (noteText !== '') current.notes.push(noteText)
1254
+ mode = ''
1255
+ continue
1256
+ }
1257
+
1258
+ // 动作行里夹着一句心里话(`△ 他站着。(心里想:他不回来了。)`):
1259
+ // 把动作那段留下,心里那段拆出去单独算一条。这一条要在「△ 开头」那条之前,
1260
+ // 否则整行都进 actions,心里话就没人数了。
1261
+ // 行首记号三种都认:△(标准)、▲(模型偶尔写)、→(中文输入法里打得出)。
1262
+ const inlineThought = /^[△▲→]\s*([\s\S]*?)\s*[((]\s*(?:[^((]{0,6}?\s*)?(?:心里想|心想|内心|心里|暗自)[::]([\s\S]*)[))]\s*$/.exec(raw)
1263
+ if (inlineThought !== null) {
1264
+ const actionText = String(inlineThought[1] ?? '').trim()
1265
+ if (actionText !== '') current.actions.push(actionText)
1266
+ current.thoughts.push({ text: String(inlineThought[2] ?? '').trim(), line: raw })
1267
+ mode = ''
1268
+ continue
1269
+ }
1270
+ if (/^[△▲→▵Δ]/.test(raw)) {
1271
+ current.actions.push(raw.slice(1).trim())
1272
+ mode = ''
1273
+ continue
1274
+ }
1275
+ // 整行就是一个括注、又短(「(沉默)」「(他站起来)」):那是节拍,不是没归位的行。
1276
+ // 心里话走下面的 parseThoughtLine,别在里被截走。
1277
+ // 整行就是一个括注:不管多长都是表演提示。
1278
+ // 早先限了 20 字,写得细一点的舞台提示(`(他把碗放下,转身往门口走,走到一半又停下来)`)
1279
+ // 就同时被判成「没归位」和「这一场没有动作」,两遍都错。
1280
+ const beat = /^[((][^(())]{1,120}[))]$/.exec(raw)
1281
+ if (beat !== null && parseThoughtLine(raw) === null) {
1282
+ current.beats.push(raw)
1283
+ mode = ''
1284
+ continue
1285
+ }
1286
+ // 「(心里想:……)」单独是一种行:不算动作、不算台词,更不能当人名。
1287
+ const thought = parseThoughtLine(raw)
1288
+ if (thought !== null) {
1289
+ current.thoughts.push(thought)
1290
+ mode = ''
1291
+ continue
1292
+ }
1293
+ // 一个人连着说两段、换行写的那种:
1294
+ // 甲说:"我跟你说,
1295
+ // 这事儿没完。"
1296
+ // 第一行只有开引号、没有闭引号,整行就废了。合并到出现闭引号那一行为止。
1297
+ // 只在「行里有名字 + 冒号 + 开引号,但没有闭引号」时才合并,
1298
+ // 否则会把一整段正常的动作行吞进来。
1299
+ // 「已经闭了引号」就不算跨行——哪怕后面还跟着一个括注(`甲说:"走。"(转身)`)。
1300
+ // 那是完整的一句加一个动作注释,下面单行分支自己处理得了。
1301
+ const hasClosedQuote = /["”」』]\s*(?:([^)]{0,60}))?\s*$/.test(raw)
1302
+ if (current !== null && /[::]\s*["“「『]/.test(raw) && !hasClosedQuote) {
1303
+ // 往下找闭引号,但**只许在同一段台词里找**:碰到场号、动作行、标签行、
1304
+ // 或者下一句台词的开口(又是一个「名字+冒号+引号」),立刻停手。
1305
+ // 早先没有这条边界,一路吞下去,最多吞掉整整一场(场号、场头、出场人物全没了),
1306
+ // 而且吞掉的东西不进任何一栏,扫描器一条都不报——这是唯一一类
1307
+ // 「用户永远不会知道自己少了什么」的错。
1308
+ let merged = raw
1309
+ let next = index + 1
1310
+ let closed = false
1311
+ while (next < lines.length && next <= index + 6) {
1312
+ const more = String(lines[next] ?? '').trim()
1313
+ if (more === '') break
1314
+ if (looksLikeSceneStart(more)) break
1315
+ if (/^[△▲→▵Δ]/.test(more)) break
1316
+ if (/^[【\[]/.test(more)) break
1317
+ // 续行里又出现「名字 + 冒号 + 开引号」:那是下一句台词,不是这句的续行。
1318
+ // (续行本身长这样也会被误停,但台词里再套「某某说:」的情况比丢一句台词罕见得多,
1319
+ // 而且被停下的那一行后面照常走正常分支,不会丢东西。)
1320
+ if (/[::]\s*["“「『]/.test(more)) break
1321
+ merged = `${merged}\n${more}`
1322
+ next += 1
1323
+ if (/["”」』]\s*(?:([^)]{0,60}))?\s*$/.test(more)) { closed = true; break }
1324
+ }
1325
+ if (closed) {
1326
+ const joined = parseDialogueLine(merged.replace(/\n/g, ''), { names: current.cast })
1327
+ if (joined !== null) {
1328
+ // 行号跳过合并掉的那几行。
1329
+ index = next - 1
1330
+ current.dialogues.push(joined)
1331
+ if (joined.who !== '' && !current.cast.includes(joined.who)) current.cast.push(joined.who)
1332
+ // 合并进来的后半句(或者后头那句别人的话)照单行分支的规矩留一条原文,
1333
+ // 让扫描器报「这行没归位」。以前这里直接扔掉,整句台词就无声消失了。
1334
+ if (String(joined.rest ?? '') !== '') current.other.push(joined.rest)
1335
+ mode = ''
1336
+ continue
1337
+ }
1338
+ }
1339
+ }
1340
+ // 一个人连着说两段、第二段没写名字,只有一句引号:
1341
+ // 甲说:"走。"
1342
+ // "顺便把伞还了。"
1343
+ // 第二行整行只是一个引号句。当成「没归位」太亏——它明显还是甲在说。
1344
+ // 归到上一句的说话人,两句并成一句(中间留一个空格)。
1345
+ // 只紧跟上一条台词(`mode === 'dialogue'`)时才算:中间隔了一个动作,
1346
+ // 这句引号可能是另一个人在说话,也可能是引用一件东西上的字。
1347
+ const onlyQuote = /^["“「『]([\s\S]+)["”」』]\s*(?:[((][^))]{0,60}[))])?\s*$/.exec(raw)
1348
+ if (onlyQuote !== null && mode === 'dialogue' && current.dialogues.length > 0) {
1349
+ const last = current.dialogues[current.dialogues.length - 1]
1350
+ const extra = String(onlyQuote[1] ?? '').trim()
1351
+ if (extra !== '' && String(last?.text ?? '') !== '') {
1352
+ last.text = `${last.text} ${extra}`.trim()
1353
+ mode = 'dialogue'
1354
+ continue
1355
+ }
1356
+ }
1357
+ const said = parseDialogueLine(raw, { names: current.cast })
1358
+ if (said !== null) {
1359
+ current.dialogues.push(said)
1360
+ // 说这句话的人也算出场的人:写没写【出场人物】是另一件事,扫的时候分开算。
1361
+ if (said.who !== '' && !current.cast.includes(said.who)) current.cast.push(said.who)
1362
+ // 一行里塞了两个人的话(`甲说:"走。"乙说:"等等。"`):
1363
+ // 第二句原样留下,让扫描器报「这行没归位」,别让它悄悄消失。
1364
+ if (String(said.rest ?? '') !== '') current.other.push(said.rest)
1365
+ mode = 'dialogue'
1366
+ continue
1367
+ }
1368
+ // 场号下面紧跟的那一行常常就是「客厅 日 内」。
1369
+ if (headless(current)) {
1370
+ // `**客厅 日 内**` / `## 客厅 日 内` 单独占一行:跟同行写法一样先剥壳。
1371
+ const head = parseSceneHeadLine(raw.replace(/^[#>*_\s]+/, '').replace(/[#>*_\s]+$/, ''))
1372
+ // parseSceneHeadLine 认不出来会回 null(带句读的句子、台词、道具行都可能)。
1373
+ // 这里要求「写了白天夜里或屋里屋外」:只有地名的一行很可能是叙述
1374
+ // (「他把碗放下」只有五个字,看着也像地名),吞掉就再没人报了。
1375
+ if (head !== null && (head.dayNight !== '' || head.inOut !== '')) {
1376
+ current.place = head.place === '' ? current.place : head.place
1377
+ current.dayNight = head.dayNight === '' ? current.dayNight : head.dayNight
1378
+ current.inOut = head.inOut === '' ? current.inOut : head.inOut
1379
+ continue
1380
+ }
1381
+ }
1382
+ // 【出场人物】下面那行默认是名字,但模型经常直接接着写叙述。
1383
+ // 带句读的一律不算名字——否则「他把碗放下。」会被当成一个人,
1384
+ // 这一行也就再不会出现在「没归位」里。
1385
+ // 标签下面那几行默认是名字,可模型经常直接把下一场的场头、或者一句叙述
1386
+ // 接着写下去。这里先试场头:认得出就是下一场,别把它吞成演员名
1387
+ // (`【出场人物】甲` 紧跟 `厨房 夜 内`,以前第二场连场头一起被当成人名,
1388
+ // 一场戏整个消失,零提示)。
1389
+ if (mode === 'cast' || mode === 'props') {
1390
+ const maybeHead = parseSceneHeadLine(raw)
1391
+ if (maybeHead !== null && (maybeHead.dayNight !== '' || maybeHead.inOut !== '')) {
1392
+ // 它不是名字,是场头。
1393
+ // 这一场还没写场头 → 就地补上(别让这一场永远「没写场头」)。
1394
+ if (current.place === '' && current.dayNight === '' && current.inOut === '') {
1395
+ current.place = maybeHead.place
1396
+ current.dayNight = maybeHead.dayNight
1397
+ current.inOut = maybeHead.inOut
1398
+ mode = ''
1399
+ continue
1400
+ }
1401
+ // 这一场的场头已经齐了,标签下面又冒出一个场头:那是下一场,
1402
+ // 只是作者没写「第 2 场」这几个字。开一个新的空场号接着写,
1403
+ // 不然这一整场(连同后面的动作)都会被当成人名吞掉,一条提示都不报。
1404
+ current = {
1405
+ no: (scenes.length > 0 ? Number(scenes[scenes.length - 1].no) || scenes.length : scenes.length) + 1,
1406
+ place: maybeHead.place, dayNight: maybeHead.dayNight, inOut: maybeHead.inOut,
1407
+ declared: false,
1408
+ cast: [], props: [], actions: [], dialogues: [], thoughts: [], beats: [], other: [], notes: [],
1409
+ raw: [raw],
1410
+ }
1411
+ scenes.push(current)
1412
+ mode = ''
1413
+ continue
1414
+ } else if (looksLikeNameList(raw)) {
1415
+ if (mode === 'cast') {
1416
+ for (const name of splitNames(raw)) {
1417
+ if (!current.cast.includes(name)) current.cast.push(name)
1418
+ }
1419
+ if (current.cast.length > 0) current.declared = true
1420
+ } else {
1421
+ for (const prop of splitNames(raw)) {
1422
+ if (!current.props.includes(prop)) current.props.push(prop)
1423
+ }
1424
+ }
1425
+ continue
1426
+ } else {
1427
+ // 标签下面写了句叙述(`【关键道具】菜刀` 换行 `她把刀放在案板上`):
1428
+ // 它不是名字。以前这条整行被当成人名/道具名塞进去,画面上少了这个动作,
1429
+ // 演员表里还多一个九字长的人。退出这一栏,让这行照常落进散行。
1430
+ mode = ''
1431
+ }
1432
+ }
1433
+ current.other.push(raw)
1434
+ }
1435
+
1436
+ for (const scene of scenes) {
1437
+ // 空场只看有没有动作和台词。心里话和「(沉默)」不算——
1438
+ // 一场戏里只有一句「(心里想:他不会回来了。)」,拍出来就是一个
1439
+ // 站着不动的空镜头,配音也没台词可念。以前这两种算作不空,
1440
+ // 于是「只有一句心里话」的场一条提示都没有。
1441
+ scene.empty = scene.actions.length === 0 && scene.dialogues.length === 0
1442
+ scene.lines = scene.actions.length + scene.dialogues.length + scene.thoughts.length + scene.beats.length + scene.other.length
1443
+ }
1444
+ return {
1445
+ title,
1446
+ scenes,
1447
+ // 第一个场号之前那些行。不算问题,但要在报告里说一句「有几行没进戏」,
1448
+ // 免得人以为它们凭空不见了。
1449
+ preamble,
1450
+ counts: {
1451
+ scenes: scenes.length,
1452
+ actions: scenes.reduce((n, s) => n + s.actions.length, 0),
1453
+ dialogues: scenes.reduce((n, s) => n + s.dialogues.length, 0),
1454
+ thoughts: scenes.reduce((n, s) => n + s.thoughts.length, 0),
1455
+ beats: scenes.reduce((n, s) => n + s.beats.length, 0),
1456
+ notes: scenes.reduce((n, s) => n + s.notes.length, 0),
1457
+ scenesWithoutHead: scenes.filter((s) => s.dayNight === '' || s.inOut === '').length,
1458
+ emptyScenes: scenes.filter((s) => s.empty).length,
1459
+ },
1460
+ lines: total,
1461
+ }
1462
+ }
1463
+
1464
+ /**
1465
+ * 场号:`1` 和 `一` 都认。
1466
+ *
1467
+ * 中文剧本里「第一场」写得比「第1场」还多;不认的话整份剧本会被读成
1468
+ * 「一场都没有」,后面的检查一条也跑不起来。
1469
+ */
1470
+ function sceneNumber(text) {
1471
+ // 全角数字(「1」)经常从别的软件里粘过来,先归一成半角。
1472
+ const raw = String(text ?? '').trim().replace(/[0-9]/g, (c) => String.fromCharCode(c.charCodeAt(0) - 0xFEE0))
1473
+ if (/^\d+$/.test(raw)) return Number(raw)
1474
+ const DIGIT = { 零: 0, 〇: 0, 一: 1, 二: 2, 两: 2, 三: 3, 四: 4, 五: 5, 六: 6, 七: 7, 八: 8, 九: 9 }
1475
+ if (raw === '十') return 10
1476
+ let total = 0
1477
+ let section = 0
1478
+ let digit = 0
1479
+ for (const ch of raw) {
1480
+ if (DIGIT[ch] !== undefined) { digit = DIGIT[ch]; continue }
1481
+ if (ch === '十') { section += (digit === 0 ? 1 : digit) * 10; digit = 0; continue }
1482
+ if (ch === '百') { section += (digit === 0 ? 1 : digit) * 100; digit = 0; continue }
1483
+ }
1484
+ total = section + digit
1485
+ return total > 0 ? total : 1
1486
+ }
1487
+
1488
+ /**
1489
+ * `1. 客厅 日 内` 这种带编号的场头:点后面得真像一行场头(有日夜或内外)。
1490
+ *
1491
+ * 只凭「数字 + 点」当场号太宽——`1. 他推开门。` 会被切成一场。
1492
+ */
1493
+ function looksLikeSceneHead(inline) {
1494
+ const text = String(inline ?? '').trim()
1495
+ if (text === '') return false
1496
+ const head = parseSceneHeadLine(text)
1497
+ return head !== null && (head.dayNight !== '' || head.inOut !== '')
1498
+ }
1499
+
1500
+ /**
1501
+ * 场号那一行。捕获组 1–6 是场号本身(数字或中文数字),7 是同一行后面带的场头。
1502
+ *
1503
+ * 认的写法:`第3场` / `【第3场】` / `第3幕` / `场景3` / `场3` / `场次3` / `幕3` /
1504
+ * `SCENE 3` / `3.`(后面点后面真像场头才算)/ `三、`。前面可以有 `第一章`、
1505
+ * markdown 壳子(`##`、`-`、`>`、`**`)、箭头。
1506
+ */
1507
+ const SCENE_NO_RE = /^(?:[-–—•·*>#_\s→]*)(?:(?:第\s*[0-90-9一二三四五六七八九十百零〇两]+\s*[章集卷幕]|Chapter\s*\d+|幕\s*[0-90-9一二三四五六七八九十百零〇两]+)[\s·、::.-]*)?(?:[【\[]?第\s*([0-90-9一二三四五六七八九十百零〇两]+)\s*[场幕][】\]]?|场景\s*([0-90-9一二三四五六七八九十百零〇两]+)|场次\s*([0-90-9一二三四五六七八九十百零〇两]+)|[场幕]\s*([0-90-9一二三四五六七八九十百零〇两]+)|(?:SCENE|Scene|scene)\s*([0-90-9]+)|([0-90-9]{1,3})\s*[..、))](?![0-90-9])|([一二三四五六七八九十百零〇两]{1,4})\s*[、])\s*[*_\s]*[::]?\s*(.*)$/
1508
+
1509
+ /**
1510
+ * 这一行是不是「场号行」——判断合并台词要不要停手时用。
1511
+ *
1512
+ * 比主循环宽:只要看起来是个场号就行,不管后面跟的是不是场头。
1513
+ * 少认一行的代价是「把下一场吞进这句台词里」,那种错没人会发现。
1514
+ */
1515
+ function isSceneNumberLine(line) {
1516
+ const raw = String(line ?? '').trim()
1517
+ if (raw === '') return false
1518
+ const hit = SCENE_NO_RE.exec(raw)
1519
+ if (hit === null) return false
1520
+ // 只要认出了场号(任何一支)就算。`SCENE 3` 那支是英文字,也照样算。
1521
+ return hit[1] !== undefined || hit[2] !== undefined || hit[3] !== undefined
1522
+ || hit[4] !== undefined || hit[5] !== undefined || hit[6] !== undefined || hit[7] !== undefined
1523
+ }
1524
+
1525
+ /** 合并台词时的停手判据。 */
1526
+ function looksLikeSceneStart(line) {
1527
+ return isSceneNumberLine(line)
1528
+ }
1529
+
1530
+ /** 几个捕获组里取第一个有字的。 */
1531
+ function firstFilled(...values) {
1532
+ for (const value of values) if (value !== undefined && String(value).trim() !== '') return String(value).trim()
1533
+ return ''
1534
+ }
1535
+
1536
+ /** 这行看着像一串名字吗(短、不带句读、不带动作)。 */
1537
+ function looksLikeNames(line) {
1538
+ const raw = String(line ?? '').trim()
1539
+ if (raw === '' || raw.length > 40) return false
1540
+ if (/[。!?,;:]/.test(raw)) return false
1541
+ return true
1542
+ }
1543
+
1544
+ /**
1545
+ * 标签**下面**紧接的一行是不是还在继续报名字。
1546
+ *
1547
+ * `looksLikeNames` 只要求「短、没句读」,可中文句子本来就可以不带句号:
1548
+ * `【关键道具】菜刀` 下面写「她把刀放在案板上」,它照样通过,
1549
+ * 于是这一行动作被当成道具名塞进清单,画面上少了这个动作,
1550
+ * 道具表里多一个九字长的东西。
1551
+ *
1552
+ * 判据换成「一个个数出来都像名字」:拆出来的每一段不超过六个字,
1553
+ * 而且要么分段多于一段、要么整行本来就短。一整句九个字没分隔的,
1554
+ * 按散文算。
1555
+ */
1556
+ function looksLikeNameList(line) {
1557
+ const raw = String(line ?? '').trim()
1558
+ if (!looksLikeNames(raw)) return false
1559
+ const parts = raw.split(/[、,,/\s]+/).filter((x) => x !== '')
1560
+ if (parts.length === 0) return false
1561
+ if (parts.some((x) => x.length > 6)) return false
1562
+ return parts.length > 1 || raw.length <= 6
1563
+ }
1564
+
1565
+ /** 这一场还没认出「在哪儿 / 日还是夜 / 内还是外」。 */
1566
+ function headless(scene) {
1567
+ return scene.place === '' && scene.dayNight === '' && scene.inOut === ''
1568
+ }
1569
+
1570
+ /**
1571
+ * 剧本里不该出现的东西。
1572
+ *
1573
+ * 这几组词不是文风问题:写进剧本就没人能拍。有一半来自用户给的
1574
+ * 《小说改剧本》:不写秒数时长、不写镜号景别机位运镜、不写成分镜、
1575
+ * 不用旁白代替对话。台词里出现「等我一秒」是正常的,所以只扫
1576
+ * 动作行和没归位的散行,不扫台词。
1577
+ */
1578
+ // 「镜头」「特写」这些词在戏里也会当普通名词用:他举起相机,镜头对准窗外;
1579
+ // 桌上一叠特写照片;院里的老式机位还架在那儿。所以不能见到就报,
1580
+ // 得看写成什么样子——见 CAMERA_PATTERNS。
1581
+ // 「旁白似的念白」「画外音一样的声音」是比喻,不是说明。所以不裸配,看写法。
1582
+ const CAMERA_WORDS = []
1583
+
1584
+ /**
1585
+ * 真写成镜头说明的样子。命中才算问题。
1586
+ *
1587
+ * 分成几条是有意的:单纯出现「镜头」两个字不算,`镜头推近`「镜头摇过」
1588
+ * 「特写:」这种才是有人在写分镜。
1589
+ */
1590
+ const CAMERA_PATTERNS = [
1591
+ // 「旁白」只认写成说明口吻的:`旁白:`、行首「旁白说」、或者「加了一段旁白」。
1592
+ // 裸的「旁白」不算——`△ 旁白的声音从隔壁传过来。` 是收音机里的声音,是戏。
1593
+ { word: '旁白', re: /旁白\s*[::]|^\s*(?:△\s*)?旁白\s*(?:说|念|道|:|响起|响起来|\s*[,。])|(?:加|配|打上|插入|补)\s*(?:一段|段)?\s*旁白/ },
1594
+ { word: '画外音', re: /画外音\s*[::]|^画外音|[,。!?]\s*画外音(?:响起|传来)|(?:加|配|插入)\s*画外音/ },
1595
+ { word: '画外', re: /画外\s*[::]|(画外)|\(画外\)/ },
1596
+ // 「镜头慢慢拉开」「镜头缓缓推近」:副词夹在中间也要算。
1597
+ // 但「他对着镜头笑了一下」「拉开镜头盖」是戏,不是分镜——「笑」「盖」都不在动词表里。
1598
+ // 行首那个字是「镜头」才按分镜算:「镜头对准窗外」是分镜,
1599
+ // 「他举起相机,镜头对准窗外」是戏里那个人手里正好有台相机。
1600
+ { word: '镜头', re: /^\s*△?\s*镜头\s*(?:一路|慢慢|缓缓|轻轻|猛地|突然|迅速|远远)?\s*.{0,10}?(?:一\s*(?:转|推|拉|晃|摇)|推|拉|摇|移|跟|升|降|切|转|给|带到|扫过|停在|停住|定格|对准)|(?:推|拉|摇|移|跟|升|降)镜(?:头)?|镜头[::]/ },
1601
+ // `切到陈默翻账本的手`:行首一个「切到/转到」就是分镜,戏里没人这么说话。
1602
+ { word: '切镜', re: /^(?:△\s*)?(?:切|转|划|摇|推|拉)到[^,。!?]{0,12}[。!?]?$|^(?:△\s*)?(?:切|转|划)到|(?:^|[,。;])\s*(?:后|再|又|直)?切到/ },
1603
+ // 「摄像机」在戏里是道具:婚礼上有人扛着、监控装在墙角。
1604
+ // 只有当这句话是在说「给到哪台机器」时才算分镜。
1605
+ { word: '摄像机', re: /^(?:△\s*)?(?:摄像机|摄影机|摇臂)\s*[::]|(?:机位|镜头|特写|拍到|摇到|切到|摇臂)\s*(?:对准|给到|推到)?\s*(?:摄像机|摄影机|摇臂)|(?:摄像机|摄影机)\s*(?:推|拉|摇|跟|升|降)/ },
1606
+ // 景别写在行首就是分镜:`△中景,两个人在桌前。`「大远景」「远镜头」都算。
1607
+ // 但「远处的全景照片」这种是戏里的话,所以要求它落在行首。
1608
+ { word: '景别', re: /景别\s*[::==]|(?:大远景|大特写|远镜头|中镜头|近镜头)|^(?:△\s*)?(?:远|全|中|近|特)景别?(?:\s*[::,,。!?]|$)|^(?:△\s*)?(?:远|全|中|近|特)景[^,。!?]{0,8}[。!?]?$|^(?:△\s*)?空镜\s*[::]/ },
1609
+ // `镜头A:`「镜号3:」「镜头一:」——分镜表里的编号写法,戏里没人这么写。
1610
+ // 只认后面跟冒号的,`他对着镜头笑了一下` 不算。
1611
+ { word: '镜号', re: /^(?:△\s*)?(?:镜头|镜号)\s*[A-Za-z0-9一二三四五六七八九十]{1,3}\s*[::]|镜号\s*[A-Za-z0-9一二三四五六七八九十]{1,3}/ },
1612
+ // 「3号机位」「手持跟拍」「肩扛」都是拍摄说明。
1613
+ { word: '机位标记', re: /\d+\s*号机位|手持|肩扛|跟拍|稳定器/ },
1614
+ // 「特写她的手」就是分镜写法,不需要冒号。
1615
+ { word: '特写', re: /特写\s*[::]|(?:给|来个|推到|切到)(?:一个|个)?特写|特写镜头|特写[^,。!?]{0,6}[她他它脸眼手嘴脚]/ },
1616
+ { word: '机位', re: /机位\s*[::]|机位(?:在|从|放到|架在)|换个机位/ },
1617
+ // 「他不懂运镜,也不懂剪辑」是在说那个人不懂,不是分镜写法。
1618
+ { word: '运镜', re: /运镜\s*[::]|^\s*(?:△\s*)?运镜/ },
1619
+ // 俯拍/仰拍/越轴/定格 当普通动词用的概率极低,直接裸认。
1620
+ { word: '机位角度', re: /俯拍|仰拍|越轴|航拍|俯视镜头|仰视镜头/ },
1621
+ { word: '定格', re: /定格\s*[::]|(?:加|来|给|插)(?:一个|个)?定格|画面定格|定格画面|^(?:△\s*)?定格\s*(?:[,。!?;]|$)/ },
1622
+ { word: '闪回', re: /闪回\s*[::]|(?:插|加|来)(?:一个|个)?(?:回忆)?闪回|闪回镜头/ },
1623
+ // 「婚礼录像里音乐响起来」「乐队起了一个调子,音乐响起」是现场的声音,是戏。
1624
+ // 只有在写成提示口吻时才报:`配乐:`、`背景音乐渐弱`、`插入一段配乐`。
1625
+ { word: '配乐', re: /(?:配乐|音乐|音效|声音)\s*[::]|^(?:△\s*)?(?:配乐|音乐)\s*(?:起|响起|淡入|淡出)|(?:背景音乐|插曲)\s*(?:渐弱|渐强|起|响起|淡入|淡出)|插入?(?:一段)?(?:配乐|音乐)|(?:配乐|音乐)\s*(?:渐弱|渐强)/ },
1626
+ { word: '光线', re: /光线\s*[::]|色温\s*[::]|(?:打光|布光)\s*[::]/ },
1627
+ // 「黑场」「淡入」「淡出」都是戏里也可能出现的词(院子里的黑场子、像淡入的夜)。
1628
+ // 跟转场动词搭配才算分镜。
1629
+ // 「画面渐暗,转场。」「转场。」单独一句也是分镜台词,不是戏。
1630
+ // 「画面转为黑白」也是在写调色说明。单写「画面暗下来」是戏,不管。
1631
+ { word: '调色', re: /画面\s*(?:转为|变成|切成|渐暗|渐亮|定格)|色调\s*[::]|黑白画面|慢速快门|幻灯片式的?回忆/ },
1632
+ { word: '转场', re: /转场\s*[::]|(?:淡入|淡出|叠化|黑场)\s*(?:转场|过场)?\s*[::]|(?:切|转|划|叠)\s*(?:到|入|出)?\s*(?:黑场|下一场)|转场(?:特效|方式)|叠化|(?:^|[,。;])\s*转场\s*(?:$|[。!?])/ },
1633
+ { word: '分镜', re: /分镜\s*[::]|分镜头?脚本|画分镜|分镜稿(?:是|谁|给)/ },
1634
+ // 「升格成」「规格升格」是常用词;只有写成素材处理才是分镜。
1635
+ // 「把性子升格成了一种沉默」「规格升格」都是日常说法。只有明摆着在说素材/镜头才算。
1636
+ { word: '升格', re: /升格(?:镜头|素材|处理)|素材升格|降格(?:镜头|素材|处理)|高帧率|(?:^|[,。;])\s*(?:升格|降格)\s*[,。!?;]|^(?:△\s*)?(?:升格|降格)\s*[::]/ },
1637
+ // 「他放慢动作」是戏(动词「放」+ 宾语「慢动作」),
1638
+ // 「用了个慢动作」「慢动作镜头」才是分镜写法。
1639
+ { word: '慢动作', re: /慢动作\s*[::]|用了?(?:一个|个)?慢动作|慢动作(?:镜头|特效|处理)|高帧率|慢镜头/ },
1640
+ { word: '时长', re: /时长\s*[::==]|本场.{0,6}时长|(?:总|全片)时长/ },
1641
+ ]
1642
+
1643
+ /**
1644
+ * 这几个词可能只是戏里出现的东西:「电视上滚过一行字幕」「隔壁在放背景音乐」
1645
+ * 「门外有人说话,像旁白」。只有写成说明口吻(后面跟冒号、或者前面是「加/配/打上」)
1646
+ * 才按镜头词算。
1647
+ */
1648
+ // 旁白 / 画外音 / 画外 不在这一组:它们不会在现场出现成一样东西,写上就是镜头话。
1649
+ const AMBIGUOUS_WORDS = ['字幕', '背景音乐', 'BGM']
1650
+ // 「电视上在打上字幕,一行一行往上滚」是现场画面里的事,不是在写分镜。
1651
+ // 所以「打上」只认宾语紧跟的那种写法(`打上字幕:`、`配上字幕`),
1652
+ // 而且允许中间隔一个「在」:`在打上字幕` 里那个「上」是动词补语,不是数字幕。
1653
+ const AMBIGUOUS_HINT = /(?:加|配|配上|插入|叠)\s*(?:字幕|背景音乐|BGM|旁白|画外音|画外)|^(?:字幕|背景音乐|BGM|旁白|画外音|画外)[::]/
1654
+
1655
+ /**
1656
+ * 「秒」单独拿出来按样子判。
1657
+ *
1658
+ * 动作行里写「他愣了两秒」是正常的——那是戏,不是镜头说明。真正不许的是
1659
+ * 「第 3 秒」「停留 2 秒」「本场 30 秒」这种把表掐在纸上。所以只在它跟
1660
+ * 这些词搭在一起时才报。
1661
+ */
1662
+ // 「秒」的判据全都绑单位:`停留 3 分钟` 是戏,`停留 3 秒` 才是时长。
1663
+ // 「秒」这一档最难:剧本里的「他愣了两秒」是戏,不是镜头话。
1664
+ // 判据是「谁在停」——主语是镜头/画面/黑场/定格这一类的,才是在写时长。
1665
+ // 顺带认中文数字(「画面停住两秒」比「停住 2 秒」写得更常见)。
1666
+ const SECONDS_NUM = '[0-90-9一二三四五六七八九十百两半]+'
1667
+ const SECONDS_HINT = new RegExp(
1668
+ '(?:'
1669
+ + `第\\s*${SECONDS_NUM}\\s*秒` // 第3秒
1670
+ + `|${SECONDS_NUM}\\s*秒(?:钟)?(?:时|处|的镜头|后切)` // 三秒处、5秒后切
1671
+ + `|停留\\s*${SECONDS_NUM}\\s*秒` // 停留 2 秒
1672
+ + `|本场.{0,6}${SECONDS_NUM}\\s*秒` // 本场大约 30 秒
1673
+ + `|(?:镜头|画面|黑场|黑屏|定格|转场|字幕|空镜|特写|全景|近景|中景|远景|画外音)[^。!?\\n]{0,10}?${SECONDS_NUM}\\s*秒` // 画面停住两秒
1674
+ + `|(?:时长|片长|长度)\\s*[::]\\s*[^。!?\\n]{0,8}${SECONDS_NUM}` // 时长:15 秒
1675
+ + `|(?:长达|持续|一共|共)\\s*${SECONDS_NUM}\\s*秒` // 长达三秒钟
1676
+ + ')'
1677
+ )
1678
+
1679
+ /** 这行里有没有镜头话。有就说中的是哪个词,没有回空串。 */
1680
+ function cameraWordIn(line) {
1681
+ // 行首那对括号要先剥掉:`△(镜头拉远)`、`(特写:她的手)` 里的「镜头」「特写」
1682
+ // 就这么被括号挡在行首之外,判据一条也命中不了。
1683
+ const text = String(line ?? '').replace(/^\s*[((]\s*/, '').replace(/\s*[))]\s*$/, '')
1684
+ for (const word of CAMERA_WORDS) {
1685
+ if (text.includes(word)) return word
1686
+ }
1687
+ for (const rule of CAMERA_PATTERNS) {
1688
+ if (rule.re.test(text)) return rule.word
1689
+ }
1690
+ for (const word of AMBIGUOUS_WORDS) {
1691
+ if (text.includes(word) && AMBIGUOUS_HINT.test(text)) return word
1692
+ }
1693
+ const hit = SECONDS_HINT.exec(text)
1694
+ return hit === null ? '' : '秒'
1695
+ }
1696
+
1697
+ /**
1698
+ * 数一遍这份剧本(只数,不评价)。
1699
+ *
1700
+ * `scanScript` 的活是「让作者一眼看见自己没注意到的东西」:哪一场没写日夜内外、
1701
+ * 哪一场是空的、哪句话写了机位、有多少行叙述还停在小说里没转成动作。
1702
+ */
1703
+ export function scanScript(text) {
1704
+ // 自己先剥一层围栏:别人(测试、界面里粘回来的东西)未必先剥过。
1705
+ // 不剥的话,` ``` ` 那一行会被算成「第 1 场之前还有 1 行」外加一行没归位。
1706
+ const clean = stripFence(text)
1707
+ const parsed = parseScriptScenes(clean)
1708
+ const chars = String(clean ?? '').replace(/\s/g, '').length
1709
+ const issues = []
1710
+
1711
+ if (parsed.scenes.length === 0) {
1712
+ issues.push({
1713
+ kind: 'no-scene',
1714
+ label: '没有认出任何一场',
1715
+ detail: '场次要单独一行写成「第1场」,后面一行写「客厅 日 内」。',
1716
+ })
1717
+ }
1718
+
1719
+ const cameraHits = []
1720
+ const stray = []
1721
+ const narrators = []
1722
+ for (const scene of parsed.scenes) {
1723
+ for (const action of scene.actions) {
1724
+ // 动作行里夹了一句心里话(`△ 他站着。(心里想:…)`):报出来,
1725
+ // 心里话该单独占一行,不然配音的时候没人知道这段话谁来念。
1726
+ if (/[((]\s*(?:心里想|心想|内心|心里|暗自)\s*[::]/.test(action)) {
1727
+ stray.push({ scene: scene.no, sample: `心里话跟动作写在一行了,拆开单独写一行:${action}` })
1728
+ }
1729
+ const word = cameraWordIn(action)
1730
+ if (word !== '') cameraHits.push({ scene: scene.no, word, sample: `△${action}` })
1731
+ }
1732
+ // 台词正文不再扫镜头词。角色张嘴说「你懂什么运镜」「旁白还没录呢」
1733
+ // 是在说话,不是有人在写分镜;把这种句子报成「写了拍不出来的东西」,
1734
+ // 人会以为这个检查在瞎报。真正不该出现的是「旁白:」这种当成台词写的说明行,
1735
+ // 那条在上面的 narrators 里单独管。
1736
+ // 「(镜头推近到她的脸)」「(心里想:镜头慢慢拉远)」一样是在写分镜。
1737
+ // 以前这两栏一条都不扫,写了也零提示——最容易被当成「写对了」。
1738
+ for (const beat of scene.beats) {
1739
+ // 节拍本身就是一整行括注(`(镜头拉远)`)。剥掉外层那对括号再看,
1740
+ // 不然「镜头」永远不在行首,判据一条也命中不了。
1741
+ const inner = String(beat).replace(/^[((]\s*/, '').replace(/\s*[))]$/, '')
1742
+ const word = cameraWordIn(inner)
1743
+ if (word !== '') cameraHits.push({ scene: scene.no, word, sample: beat })
1744
+ }
1745
+ for (const thought of scene.thoughts) {
1746
+ const word = cameraWordIn(String(thought?.text ?? ''))
1747
+ if (word !== '') cameraHits.push({ scene: scene.no, word, sample: `(心里想:${thought.text})` })
1748
+ }
1749
+ for (const line of scene.other) {
1750
+ // 旁白 / 画外音 / 字幕行:解析器已经不把它当台词了,这里单独说一句为什么不行,
1751
+ // 不再重复报成镜头话、也不再重复报「没归位」——同一行数三遍只会让人不信这个检查。
1752
+ if (/^(?:旁白|画外音|画外|字幕|字幕卡|说明字幕|解说)\s*[::]/.test(line)) {
1753
+ narrators.push({ scene: scene.no, sample: line })
1754
+ continue
1755
+ }
1756
+ const word = cameraWordIn(line)
1757
+ if (word !== '') {
1758
+ // 同一行不再报「没归位」:人写的是镜头话,说清这一件就够了。
1759
+ // 一行数两遍只会让他觉得这个检查在瞎报。
1760
+ cameraHits.push({ scene: scene.no, word, sample: line })
1761
+ continue
1762
+ }
1763
+ stray.push({ scene: scene.no, sample: line })
1764
+ }
1765
+ }
1766
+
1767
+ if (Array.isArray(parsed.preamble) && parsed.preamble.length > 0) {
1768
+ issues.push({
1769
+ kind: 'preamble',
1770
+ label: `第 1 场之前还有 ${parsed.preamble.length} 行没进戏`,
1771
+ detail: '剧名下面写注释、或者先列一张人物表,这些行不算场里的内容。想留就放进动作行,不想留就删掉。',
1772
+ samples: parsed.preamble.slice(0, 3).map((line) => String(line).slice(0, 40)),
1773
+ })
1774
+ }
1775
+
1776
+ if (narrators.length > 0) {
1777
+ issues.push({
1778
+ kind: 'narrator',
1779
+ label: `有 ${narrators.length} 处用的是旁白`,
1780
+ detail: '旁白一出来,画面上就得有人念;看戏的人也就从戏里出来了。能让人物说就让人物说,能用一个动作演出来更好。',
1781
+ samples: narrators.slice(0, 3).map((n) => `第 ${n.scene} 场:${n.sample}`),
1782
+ })
1783
+ }
1784
+
1785
+ if (cameraHits.length > 0) {
1786
+ issues.push({
1787
+ kind: 'camera',
1788
+ label: `有 ${cameraHits.length} 处写了拍不出来的东西`,
1789
+ detail: '秒数、镜号、景别、机位、运镜、音乐、字幕都不进剧本。要么删,要么改成现场看得见的动作。',
1790
+ samples: cameraHits.slice(0, 3).map((h) => `第 ${h.scene} 场「${h.word}」:${h.sample}`),
1791
+ })
1792
+ }
1793
+
1794
+ const noHead = parsed.scenes.filter((s) => s.dayNight === '' || s.inOut === '')
1795
+ if (noHead.length > 0) {
1796
+ issues.push({
1797
+ kind: 'no-head',
1798
+ label: `有 ${noHead.length} 场没写清是白天还是夜里、是屋里还是屋外`,
1799
+ detail: '排班、找场地、配光都靠这一行。写成「客厅 日 内」就够了。',
1800
+ samples: noHead.slice(0, 3).map((s) => `第 ${s.no} 场${s.place === '' ? '' : ` ${s.place}`}`),
1801
+ })
1802
+ }
1803
+
1804
+ const noCast = parsed.scenes.filter((s) => s.declared !== true)
1805
+ if (noCast.length > 0) {
1806
+ issues.push({
1807
+ kind: 'no-cast',
1808
+ label: `有 ${noCast.length} 场没写谁在这场里`,
1809
+ detail: '【出场人物】空着,演员表就排不出来。',
1810
+ samples: noCast.slice(0, 3).map((s) => `第 ${s.no} 场`),
1811
+ })
1812
+ }
1813
+
1814
+ // 场号重复:两场都叫「第1场」,排班和配音会直接对上错的那一场。
1815
+ // 解析器不替人改号(改了就不是作者写的号了),但要说出来。
1816
+ const seenNo = new Set()
1817
+ const dupNo = []
1818
+ for (const sc of parsed.scenes) {
1819
+ if (seenNo.has(sc.no)) dupNo.push(sc.no)
1820
+ seenNo.add(sc.no)
1821
+ }
1822
+ if (dupNo.length > 0) {
1823
+ issues.push({
1824
+ kind: 'dup-scene',
1825
+ label: `有 ${dupNo.length} 个场号重了`,
1826
+ detail: '场号是拿来对场次的:重了,排班和配音就会对上另一场。往下顺一遍号。',
1827
+ samples: dupNo.slice(0, 3).map((n) => `第 ${n} 场`),
1828
+ })
1829
+ }
1830
+
1831
+ // 心里话一场最多一句:提示词里明写着,可一直没人查。
1832
+ // 三句心里话连着排,演员只能站在那儿不动,把心里的事念出来——
1833
+ // 那就不是戏了,是有声书。
1834
+ const tooManyThoughts = parsed.scenes.filter((sc) => sc.thoughts.length > 1)
1835
+ if (tooManyThoughts.length > 0) {
1836
+ issues.push({
1837
+ kind: 'too-many-thoughts',
1838
+ label: `有 ${tooManyThoughts.length} 场心里话超过一句`,
1839
+ detail: '心里话一场留一句就够,多出来的要么改成让人物说出来,要么改成一个动作演出来。',
1840
+ samples: tooManyThoughts.slice(0, 3).map((sc) => `第 ${sc.no} 场:${sc.thoughts.length} 句`),
1841
+ })
1842
+ }
1843
+
1844
+ const empty = parsed.scenes.filter((s) => s.empty)
1845
+ if (empty.length > 0) {
1846
+ issues.push({
1847
+ kind: 'empty-scene',
1848
+ label: `有 ${empty.length} 场是空的`,
1849
+ detail: '一场里既没有动作也没有台词,这一场就什么也没发生。',
1850
+ samples: empty.slice(0, 3).map((s) => `第 ${s.no} 场`),
1851
+ })
1852
+ }
1853
+
1854
+ // 按场看,不是看整份:第十章有动作,不代表第三场也有。
1855
+ // 只有台词没有动作的那一场,念出来就行,画面上什么也没有。
1856
+ // 「(他把碗放下)」是舞台提示,中文剧本传统里就是动作行。
1857
+ // 早先只认 △,于是写了动作的人被提示「这一场只有台词、没有动作」,
1858
+ // 他会去再补一个 △ 把同一件事写一遍。
1859
+ // 「括号里写了动作」也算动作:`甲(把碗放下,站起来)说:"我走了。"`
1860
+ // 中文剧本里这就是在写动作,只不过写在了说的人旁边。
1861
+ // 早先只认 △ 和整行括注,于是这种场被提示「只有台词、没有动作」,
1862
+ // 人会去再补一个 △ 把同一件事写第二遍。
1863
+ const noAction = parsed.scenes.filter((sc) => sc.actions.length === 0
1864
+ && sc.beats.length === 0
1865
+ && !sc.dialogues.some((d) => String(d?.paren ?? '').trim() !== '')
1866
+ && sc.dialogues.length > 0)
1867
+ if (noAction.length > 0) {
1868
+ issues.push({
1869
+ kind: 'no-action',
1870
+ label: `有 ${noAction.length} 场只有台词、没有动作`,
1871
+ detail: '人在哪儿、手里拿着什么、说完做了什么,一句都没有的话,配音出来是一片空白。每场至少给一个 △ 动作。',
1872
+ samples: noAction.slice(0, 3).map((sc) => `第 ${sc.no} 场${sc.place === '' ? '' : ` ${sc.place}`}`),
1873
+ })
1874
+ }
1875
+
1876
+ if (stray.length > 0) {
1877
+ issues.push({
1878
+ kind: 'stray',
1879
+ label: `有 ${stray.length} 行没归位`,
1880
+ detail: '这些行既不是场号、不是「△动作」、也不是「谁(…)说:"…"」,多半是小说里的叙述还没改过来。',
1881
+ samples: stray.slice(0, 3).map((s) => `第 ${s.scene} 场:${s.sample}`),
1882
+ })
1883
+ }
1884
+
1885
+ return {
1886
+ ok: parsed.scenes.length > 0,
1887
+ title: parsed.title,
1888
+ chars,
1889
+ counts: parsed.counts,
1890
+ scenes: parsed.scenes,
1891
+ issues,
1892
+ total: issues.length,
1893
+ }
1894
+ }
1895
+
1896
+ /**
1897
+ * 剥掉外面的三引号围栏。
1898
+ *
1899
+ * 模型就算被要求「只给剧本本身」,也常把它包进 ``` 里。那一行进了剧本,
1900
+ * 第一场就没了场头,扫描器一路报「没归位」。剥的时候连语言标记一起去掉。
1901
+ */
1902
+ export function stripFence(text) {
1903
+ let body = String(text ?? '').replace(/^\uFEFF/, '').trim()
1904
+ // 语言标记不一定是英文:模型写过 ```剧本、```txt、```markdown。
1905
+ // 只认 [a-zA-Z]* 的话,`剧本` 会留在正文第一行,整份剧本就多一行「第 1 场之前还有 1 行没进戏」。
1906
+ // 反引号围栏和波浪号围栏(`~~~`)都剥。早先只认反引号,
1907
+ // 模型用 `~~~` 围起来的那份剧本一行都没剥掉,第一场之前凭空多一行。
1908
+ const opened = /^(?:```|~~~)[^\n]{0,20}\r?\n?/.exec(body)
1909
+ if (opened === null) return body
1910
+ body = body.slice(opened[0].length)
1911
+ // 闭合围栏后面模型常补一句「以上是第 1 场,需要我再展开吗?」。
1912
+ // 那句不是剧本,但围栏本身会留下来变成一行「看起来像台词又不是」的东西。
1913
+ // 围栏闭上的那一刻,剧本就结束了;后面再说什么都不是剧本
1914
+ // (「以上是第 1 场,需要我再展开吗?」留在正文里,扫描器会把它算成一行没归位的东西)。
1915
+ const closed = /\r?\n?(?:```|~~~)(?:[\s\S]*)$/.exec(body)
1916
+ if (closed !== null) body = body.slice(0, closed.index)
1917
+ body = body.replace(/^(?:```|~~~)[^\n]{0,20}$/gm, '')
1918
+ // 万一模型在围栏里又套了一层,末尾剩下的围栏也剪掉。
1919
+ body = body.replace(/\r?\n?(?:```|~~~)\s*$/, '')
1920
+ return body.trim()
1921
+ }
1922
+
1923
+ /** 把 `scanScript` 的结果说成人话(附在模型意见后面,不改它的话)。 */
1924
+ export function scriptReportText(scan) {
1925
+ if (scan === null || scan === undefined) return ''
1926
+ const c = scan.counts ?? {}
1927
+ const lines = [`共 ${c.scenes ?? 0} 场,台词 ${c.dialogues ?? 0} 句,动作 ${c.actions ?? 0} 行。`]
1928
+ for (const issue of scan.issues ?? []) {
1929
+ lines.push(`· ${issue.label}${issue.detail === undefined ? '' : `:${issue.detail}`}`)
1930
+ for (const sample of issue.samples ?? []) lines.push(` ${sample}`)
1931
+ }
1932
+ return lines.join('\n')
1933
+ }
1934
+
1935
+ /**
1936
+ * 拆一行场头:`客厅 日 内`。
1937
+ *
1938
+ * 单独导出:测试和界面都要用同一条判据,别一边认「夜里」一边不认。
1939
+ */
1940
+ export { parseSceneHeadLine }
1941
+
1942
+ /**
1943
+ * 把一章小说改成剧本。
1944
+ *
1945
+ * 提示词是照着用户那份《小说改剧本》蒸馏的:留下**改的时候真会出错的地方**
1946
+ * (分场、台词干活、心理不外露、叙述转动作、连续性、拍不出来的东西不写),
1947
+ * 丢掉那些只能当口号念的条款。全塞进去会让模型顾着数条款,一句也写不好。
1948
+ */
1949
+ export function buildScriptPrompt({
1950
+ title, genre, idea, chapterNo, chapterTitle, chapterBody,
1951
+ cast, worldEntries, previousTail, ask, sceneHint,
1952
+ }) {
1953
+ const lines = []
1954
+ lines.push(`你在把一部小说改成剧本。不是写小说,也不是写分镜。`)
1955
+ lines.push('')
1956
+ lines.push(`这本书叫《${String(title ?? '').trim() === '' ? '没起名' : title}》。`)
1957
+ if (String(genre ?? '').trim() !== '') lines.push(`题材:${String(genre).trim()}`)
1958
+ if (String(idea ?? '').trim() !== '') lines.push(`这本书讲的是:${String(idea).trim()}`)
1959
+ if (String(previousTail ?? '').trim() !== '') {
1960
+ lines.push('', '【上一章改出来的剧本,最后一场】(接着它的东西继续:谁站在哪、手上有什么、有没有伤)', String(previousTail).trim())
1961
+ }
1962
+ if (Array.isArray(worldEntries) && worldEntries.length > 0) {
1963
+ lines.push('', '【设定】', worldEntries.join('\n\n'))
1964
+ }
1965
+ if (Array.isArray(cast) && cast.length > 0) {
1966
+ lines.push('', '【人】', cast.join('\n'))
1967
+ }
1968
+ lines.push('', `【要改的是第 ${Number(chapterNo) || 1} 章${String(chapterTitle ?? '').trim() === '' ? '' : `:${String(chapterTitle).trim()}`}】`)
1969
+ lines.push(String(chapterBody ?? '').trim())
1970
+ if (String(ask ?? '').trim() !== '') lines.push('', `这一章改的时候注意:${String(ask).trim()}`)
1971
+
1972
+ lines.push(
1973
+ '',
1974
+ '【怎么改】',
1975
+ '- 只改这一章。这一章写到哪儿就改到哪儿,不许替作者往下编——没写出来的情节、没交代的结局,就是没有,不要自己补。',
1976
+ '- 不加原著里没有的人和事,不改结局,不提前把后面的底说出来。原著里的关键台词、伏笔、反转、道具,一件都不许丢。',
1977
+ '- 分场只看两件事:地方变了,或者时间跳了(隔了很久、进了回忆、跟着另一拨人走了)。同一个地方只是换了人说话、换了个动作,不换场。别一人一句就换一场,也别把一整场揉成一大段。',
1978
+ `- 一场里得有事:谁想要什么、被什么挡住、这一场结束时局面跟开始时不一样。${Number(sceneHint) > 0 ? `这一章大约 ${Number(sceneHint)} 场。` : '场数由内容决定,别为了凑数拆。'}`,
1979
+ '- 开场晚一点进(从第一句有用的话或第一个动作开始),结尾早一点走(说完就走,做完就切)。',
1980
+ '- 每一句台词都要干活:推进、顶人、透露、遮掩、试探、拒绝、下决心、改主意。不干活的删掉,或者并进别的句子里。同一件事不说两遍。',
1981
+ '- 人物只能说自己知道的事。不许替作者解释设定——「她不知道,这个家族三百年来……」这种话不许出现在台词里。',
1982
+ '- 心理按这个顺序处理:先看能不能用表情和动作演出来(把碗放下、往门口看一眼),演不出来就让人物自己说出来,实在不行才给一句心里想的,写成「(心里想:……)」,最多一句。不用旁白念心理。',
1983
+ '- 小说里的叙述改成动作行:以「△」开头,一行一个连续的动作或画面,写清位置、朝向、谁对谁、手上拿着什么、结果怎么样。',
1984
+ '- 环境只留看得见听得见的几样(光、天气、声音、手上的东西),不写大段景物;拍不出来的比喻和气氛一律不写(「他感觉命运正在转动」这种不许出现)。',
1985
+ '- 台词格式:`角色名(情绪或动作)说:"台词。"`。括号里写演得出来的东西(把伞推回来、盯着碗),不写「心里一沉」。',
1986
+ '- 标点有分工,别混着用:`!` 喊着说,`?` 问,`!?` 又惊又怒,`……` 话没说完或者停住,`~` 拖着音说(软、哄、玩笑)。',
1987
+ '- 连续性:上一场结束时谁站在哪、手上有什么、身上有没有伤、门开着还是关着、信在谁兜里——下一场要接得住,不能凭空消失。',
1988
+ '- 不写:秒数、时长、镜号、景别、机位、运镜、转场特效、音乐、字幕、旁白。',
1989
+ '- 每场结尾落在明确的地方:一句话说完、一个动作做完、一个决定下了。别在这场的半句台词还没落地时就换场。',
1990
+ '- 交之前自己过一遍:有没有谁说了他不该知道的事、道具断没断、原著里的情节漏没漏。发现就改,这些检查的话不要写出来。',
1991
+ '',
1992
+ '【输出格式】(照这个样子写。地名、人名、台词换成你这一章的,格式别改。)',
1993
+ '《剧本名》',
1994
+ '第1场',
1995
+ '旧书店·门厅 夜 内',
1996
+ '【出场人物】林小雨、陈默',
1997
+ '【关键道具】红伞、那封信',
1998
+ '△她把伞靠在门边,伞尖还在滴水。',
1999
+ '陈默(没抬头)说:"伞放门边。"',
2000
+ '△林小雨没动,手还搭在门把上。',
2001
+ '林小雨(声音很低)说:"我等了三个钟头。"',
2002
+ '',
2003
+ '第2场',
2004
+ '门外 夜 外',
2005
+ '【出场人物】林小雨',
2006
+ '【关键道具】红伞',
2007
+ '△她站在雨里,把伞举过头顶,又放下。',
2008
+ '(心里想:他不会回来了。)',
2009
+ '',
2010
+ '只给剧本本身。不要解释怎么改的,不要目录,不要写「以上是第 1 场」,也不要在最后问我满不满意。',
2011
+ )
2012
+ return lines.join('\n')
2013
+ }
2014
+
2015
+ /**
2016
+ * 「改成剧本」这件事的系统提示。
2017
+ *
2018
+ * 单独一句:模型很容易滑回写小说的位置(于是全是景物和心理),
2019
+ * 或者滑到分镜剧本那边去(于是满页镜号)。先把位置钉住。
2020
+ */
2021
+ export function buildScriptSystemNote() {
2022
+ return [
2023
+ '你是一个把小说改成剧本的编剧。改出来的东西要能直接拿去配音、拿去拍。',
2024
+ '你不写小说,不写分镜,也不写镜头说明。',
2025
+ '你只做一件事:把这一章的叙述换成动作行和台词,把它切成一串场。',
2026
+ ].join('\n')
2027
+ }
2028
+
2029
+ /** 取一段结尾的若干字(给下一章当「上一章结尾」)。 */
544
2030
  export function tailOf(body, chars = 600) {
545
2031
  const text = String(body ?? '').trim()
546
2032
  if (text.length <= chars) return text
@@ -553,6 +2039,7 @@ export default {
553
2039
  MAX_CHAPTERS,
554
2040
  bookIdOf,
555
2041
  bookRelPath,
2042
+ isValidChapterIndex,
556
2043
  chapterFileName,
557
2044
  chapterIndexOf,
558
2045
  renderBookMarkdown,
@@ -571,5 +2058,20 @@ export default {
571
2058
  parseOutline,
572
2059
  readOutline,
573
2060
  writeOutline,
2061
+ SCRIPT_DIR,
2062
+ scriptRelPath,
2063
+ readScript,
2064
+ writeScript,
2065
+ deleteScript,
2066
+ listScripts,
2067
+ parseDialogueLine,
2068
+ parseThoughtLine,
2069
+ parseSceneHeadLine,
2070
+ parseScriptScenes,
2071
+ scanScript,
2072
+ scriptReportText,
2073
+ stripFence,
2074
+ buildScriptPrompt,
2075
+ buildScriptSystemNote,
574
2076
  tailOf,
575
2077
  }