feat(846-2): 기계 줄 시간당 작업량 화면 — 산출근거 「시간당 작업량」 줄 먼저 · 비목 ÷ 시간당 작업량 · 제어 구역 일당 / 시간당 식 고르기 · 변수 칸 · 기계 보기 작업량 식

- 산출근거: 일당 「시간당 작업량 = 시공량 560 ㎥/일 ÷ (1 대 × 8 시간) = 70 ㎥/시간」 · 시간당 식 = q · K · f · E · cm 값 줄 + 한 층 분수 Q 식 · 비목 줄 「59,020 원/시간 ÷ 70 ㎥/시간 = 843.1 원」(금액 그대로)
- 제어 구역: 「시간당 작업량」 묶음 맨 위 — 방식 고르기(식 없는 기계 = 잠김 + 까닭) · 시간당 = 작업량 틀 변수 칸(고침 · 원래 값) · 덮음 = 기계덮음.<기계>.작업량
- 기계 보기: 왼쪽 작업량 카드(기계 정본 변수) · 오른쪽 풀이 · 서버가 작업량 틀 연결을 실음(M02_MyMachine_Sheet._work)
- 시험: test_846_2_work_view 새로 · test_845_2 GC000088 비목 줄 기대값을 새 꼴로 고침(846-2 표시 변경) · 헬퍼 가짜 DOM 이 진짜 DOM 처럼 요소를 옮김(같은 요소 두 줄 재사용 흠을 잡게)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

A00_Common/line_stack.css

@@ -530,3 +530,20 @@
 .lstk-mctl .lstk-line.k-ctl > :last-child {
   margin-inline-start: auto;
 }
+
+/* 846-2 시간당 작업량 줄 — 방식 작은 글 + 풀이(왼쪽 제어 구역 · 기계 보기) */
+.lstk-work {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--spacing-4) var(--spacing-8);
+  min-width: 0;
+}
+
+.lstk-work.packs {
+  column-gap: var(--spacing-24);
+}
+
+.lstk-out tr.work .lstk-h {
+  gap: var(--spacing-8);
+}

A00_Common/line_stack_edit.ts

@@ -51,6 +51,7 @@ import { shownUnitOf, type TableLook } from "../common_util/common_util_line_sta
 import { createUnitPick, NO_UNIT } from "../M02_MasterTemplete/DataFlow/M02_DF_UnitPick";
 import { reach } from "./formula_doc_render";
 import { attachDrag } from "./line_stack_drag";
+import type { WorkSpec } from "../common_util/common_util_formula_doc_work";
 import { openMachineWindow, type MachineCtx } from "./line_stack_machine";
 import { buildMachineCtl, machineOfLine } from "./line_stack_machine_ctl";
 import { openStackPick, type StackTake } from "./line_stack_pick";
@@ -82,6 +83,8 @@ export interface EditHooks {
   lists?: (given: Record<string, unknown>) => Record<string, unknown> | null;
   /** 845-2 표 한 칸 읽기(캐시) — 「줄 따름」 값의 고른 줄 단위 */
   look?: TableLook;
+  /** 846-2 그 기계 작업량 줄 */
+  work?: (machine: string) => WorkSpec[];
 }
 
 const field = (
@@ -513,6 +516,7 @@ export function buildEdit(h: EditHooks): HTMLElement {
         const zone = buildMachineCtl(
           { ...h, calc: h.calc, change: (fn) => h.change((d) => fn(d)), readOnly: !h.machine?.scope }, // prettier-ignore
           h.doc.변수?.find((x) => varId(x) === own)?.연결,
+          line.i,
         );
         if (zone) card.append(zone);
       }

A00_Common/line_stack_machine_ctl.ts

@@ -4,6 +4,7 @@
  *   ㉠ 값 칸 = 그 기계 식이 읽는 기계 칸(단위 · 기본 = 사본 값 · 고친 칸 = 「고침」 + [원래 값])
  *   ㉡ 조종원 = 인력 줄(노임 고르기 · 인/일 · 더하기 · 빼기 · 기본 = 기계 값 조종원 · 직종)
  *   ㉢ 잡품 = 재료 줄(재료 · 유가 고르기 · 수량 · 율 % · 기본 = 밑 재료 줄 · 품셈 잡재료율)
+ *   ㉣ 시간당 작업량(846-2 · 맨 위) = 일당 / 시간당 식 고르기 · 시간당 변수 칸(`line_stack_machine_work`)
  *   고침 = 문서 칸 `기계덮음`(캐시 · [저장] 때 서버가 정본으로 다시 셈) · 원본과 같으면 지움(`putCover`)
  *   기본값 = 덮음 없이 셈한 그 기계 식 답 + 기계 줄 인력 · 잡품 목록(`defaultsOf` · `rowEntry` · 842-3) ·
  *     읽기(M01 기초) = 칸 잠김 · 단추 없음
@@ -32,8 +33,11 @@ import {
 import { subInputs, type StackDoc } from "../common_util/common_util_line_stack";
 import type { Picked } from "../common_util/common_util_line_stack_pick";
 import { machineUnit } from "../common_util/common_util_line_stack_unit";
+import { workAt, workOfMachine } from "../common_util/common_util_line_stack_work";
+import { sites, type WorkCover, type WorkSpec } from "../common_util/common_util_formula_doc_work";
 import { machineCellName } from "../common_util/common_util_machine_symbol_name";
 import { openFindPicker } from "../M02_MasterTemplete/M02_MasterTemplete_Find_Pick";
+import { buildWorkGroup } from "./line_stack_machine_work";
 import { openStackPick } from "./line_stack_pick";
 import { lt } from "./line_stack_text";
 
@@ -51,6 +55,8 @@ export interface CtlHooks {
   lists?: (given: Record<string, unknown>) => Record<string, unknown> | null;
   /** 잠긴 값 칸 */
   lock?: string[];
+  /** 846-2 그 기계 작업량 줄(기계 값 칸 `작업량`) */
+  work?: (machine: string) => WorkSpec[];
 }
 
 const FUELS = ["경유", "휘발유", "실내등유"];
@@ -80,7 +86,7 @@ const num = (t: string): number | null => {
 };
 
 /** 수 칸 — 빈 글 = 원래대로(null) · 음수 · 글 = 알림 · 단위 = 칸 바로 뒤(공식 묶음 값 칸과 같은 자리 · 845-2 ㉥) */
-function numBox(
+export function numBox(
   label: string,
   value: unknown,
   unit: string,
@@ -115,8 +121,12 @@ function numBox(
 
 const kind = (text: string): HTMLElement => el("span", { className: "lstk-kind", text });
 
-/** 기계 제어 구역 — `link` = 그 기계 줄 단가 기호 연결 */
-export function buildMachineCtl(h: CtlHooks, link: Link | undefined): HTMLElement | null {
+/** 기계 제어 구역 — `link` = 그 기계 줄 단가 기호 연결 · `at` = 그 금액 줄 차례(작업량) */
+export function buildMachineCtl(
+  h: CtlHooks,
+  link: Link | undefined,
+  at?: number,
+): HTMLElement | null {
   const got = ctlOf(h, link);
   if (!got) return null;
   const { machine, sub, vals, base } = got;
@@ -269,10 +279,27 @@ export function buildMachineCtl(h: CtlHooks, link: Link | undefined): HTMLElemen
             ]),
       ],
     });
+  // ㉣ 시간당 작업량(846-2)
+  const info = (at === undefined ? null : workAt(h.answer, at)) ?? workOfMachine(h.answer, machine);
+  const workNow = (entry as MachineCover & { 작업량?: WorkCover }).작업량;
+  const work = info
+    ? buildWorkGroup({
+        doc: h.doc,
+        info,
+        kind: info.꼴 === "시간당" ? (sites(h.doc, h.doc.금액?.[at ?? -1]?.수량)[0]?.꼴 ?? "일당") : info.꼴, // prettier-ignore
+        entry: workNow,
+        specs: h.work?.(machine) ?? [],
+        subDoc: h.subDoc,
+        vals: (h.answer.값 ?? {}) as Record<string, unknown>,
+        ro,
+        put: (w) => put({ ...entry, 작업량: w } as MachineCover),
+      })
+    : [];
   const box = el("div", {
     className: "lstk-mctl lstk-wide",
     attrs: { "data-mctl": machine },
     children: [
+      ...work,
       ...(values.length
         ? [el("div", { className: "lstk-fhead", children: [kind(lt("Ctl_Values"))] }), ...values]
         : []),

A00_Common/line_stack_machine_sheet.css

@@ -2,3 +2,12 @@
 .lstk-msheet-similar .ui-find__list {
   max-height: 240px;
 }
+
+/* 846-2 오른쪽 시간당 작업량 풀이(시간당 경비 아래) */
+.lstk-msheet-work {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-8);
+  margin-block-start: var(--spacing-16);
+  overflow-x: auto;
+}

A00_Common/line_stack_machine_sheet.ts

@@ -6,6 +6,7 @@
  *   오른쪽 = 그 기계 시간당 경비 산출근거(`line_stack_out` · 노 · 재 · 경 · 계 합계 상자) — 값을 바꾸면 브라우저 계산기로 즉시
  *   서버(`POST /api/m02/machine-sheet` · `M02_MyMachine_Sheet`) = 식 고름 + 처음 줄 값을 박은 식 문서 + 연결 기록 ·
  *     고친 값은 덮음(`기계덮음` 꼴)으로 얹어 셈 · 캐시에 없는 연결 · 식이 바뀔 칸만 뒤에서 다시 물음(옛 요청 끊음)
+ *   시간당 작업량(846-2) = 왼쪽 접이 카드(작업량 식 변수 = 기계 값) · 오른쪽 풀이(`line_stack_machine_sheet_work`)
  *   줄 = 저장 꼴(M01 기계 줄 · 내 기계 줄) — 덮음 ↔ 줄은 `common_util_machine_sheet` · 저장은 부르는 쪽(M01 상세 · 내 기계)
  * ========================================================================== */
 
@@ -63,6 +64,7 @@ import {
 import { machineCellName } from "../common_util/common_util_machine_symbol_name";
 import { docFoot } from "./formula_doc_foot";
 import { buildMachineCtl } from "./line_stack_machine_ctl";
+import { sheetWorkCard, sheetWorkOut, type SheetWorkOpts } from "./line_stack_machine_sheet_work";
 import { buildOut } from "./line_stack_out";
 import "./line_stack.css";
 import "./line_stack_machine_sheet.css";
@@ -158,6 +160,7 @@ export function createMachineSheet(o: MachineSheetOptions) {
   const warn = el("div");
   const ctlBox = el("div");
   const baseBox = el("div");
+  const workBox = el("div");
   const root = el("div", {
     className: "lstk",
     attrs: { "data-edit": "1", "data-machine-sheet": no },
@@ -528,8 +531,24 @@ export function createMachineSheet(o: MachineSheetOptions) {
         redraw: () => drawRight(),
       }),
     );
+    right.append(sheetWorkOut(work()));
+    if (cache.takeMissing()) ask();
     foot.replaceChildren(docFoot(a));
   };
+  // 846-2 시간당 작업량 — 지금 줄 `값.작업량`(고침 = 지금 줄 · 저장은 부르는 쪽)
+  const work = (): SheetWorkOpts => ({
+    cur,
+    orig,
+    ro,
+    links: cache.links,
+    miss: () => undefined,
+    changed: () => changed(),
+  });
+  const drawWork = (): void => {
+    const keep = workBox.firstElementChild?.classList.contains("is-collapsed") ?? false;
+    workBox.replaceChildren(sheetWorkCard(work(), keep));
+    if (cache.takeMissing()) ask();
+  };
   const drawWarn = (): void => {
     const vals: MachineValues = crewView({ ...engineVals(cur, mine), ...(cur.값 ?? {}) });
     if (unitOf("손료계수") !== machineUnit("손료계수")) delete vals.손료계수; // 일 단위 손료(임업) = 시간당 범위 아님
@@ -541,6 +560,7 @@ export function createMachineSheet(o: MachineSheetOptions) {
   };
   const drawLive = (): void => {
     drawCtl();
+    drawWork();
     drawRight();
     drawWarn();
   };
@@ -552,7 +572,7 @@ export function createMachineSheet(o: MachineSheetOptions) {
     notice.replaceChildren(...(t ? [createText(t, "warning")] : []));
   };
 
-  left.append(...similarBox(), notice, warn, ctlBox, baseBox);
+  left.append(...similarBox(), notice, warn, ctlBox, workBox, baseBox);
   drawAll();
   ask(true);
 

A00_Common/line_stack_machine_sheet_work.ts

@@ -0,0 +1,105 @@
+/* =============================================================================
+ * line_stack_machine_sheet_work.ts
+ * 기계 보기 시간당 작업량(PLAN 846-2 · 요구 883 「시간당 작업량 = 기계의 능력 → 기계에 둠」)
+ *   왼쪽 = 「시간당 작업량」 접이 카드 — 기계 줄 `값.작업량` 식마다 이름 + 변수 칸(기본 = 기계 값 › 식 문서 기본 ·
+ *     고친 칸 「고침」 + [원래 값] = 처음 줄 값으로) · 고침 = 지금 줄(저장은 부르는 쪽 — M01 기계 상세 · 내 기계)
+ *   오른쪽 = 시간당 경비 풀이 아래 「시간당 작업량」 — 그 식 풀이(값 줄 + 결과 식 · `hourlyRows` 산출근거와 같음)
+ *   식 없는 기계 = 「시간당 작업량 식 없는 기계」 · 작업량 틀 · 표 연결 = 기계 보기 서버(`M02_MyMachine_Sheet._work`)
+ * ========================================================================== */
+
+import { attachCollapsible, createPanelCard } from "@ui/ui_template_collapsible";
+import { el } from "@ui/ui_template_elements";
+import type { FormulaDoc } from "../common_util/common_util_formula_doc";
+import { calcDoc, type DocLinks } from "../common_util/common_util_formula_doc_calc";
+import { specsOf, workDefaults, type WorkSpec } from "../common_util/common_util_formula_doc_work";
+import type { MachineRow } from "../common_util/common_util_machine_sheet";
+import { lt } from "./line_stack_text";
+import { workVarRows } from "./line_stack_machine_work";
+import { hourlyRows, workTag } from "./line_stack_work";
+
+export interface SheetWorkOpts {
+  cur: MachineRow;
+  orig: MachineRow;
+  ro: boolean;
+  links: DocLinks;
+  /** 캐시에 없는 연결 — 뒤에서 서버 */
+  miss: () => void;
+  /** 지금 줄을 고친 뒤 */
+  changed: () => void;
+}
+
+const specsOfRow = (row: MachineRow): WorkSpec[] => specsOf(row.값?.작업량);
+
+const docOf = (o: SheetWorkOpts, key: string): FormulaDoc | null => {
+  try {
+    return o.links.doc(key) ?? null;
+  } catch {
+    o.miss();
+    return null;
+  }
+};
+
+const note = (text: string): HTMLElement => el("div", { className: "lstk-empty", text });
+
+/** 왼쪽 카드 — `keep` = 접힘 유지 */
+export function sheetWorkCard(o: SheetWorkOpts, keep: boolean): HTMLElement {
+  const card = createPanelCard(lt("Work_Head"), keep);
+  card.dataset.machineWork = "1";
+  const specs = specsOfRow(o.cur);
+  if (!specs.length) card.append(note(lt("Work_None")));
+  const was = specsOfRow(o.orig);
+  specs.forEach((spec, i) => {
+    const tpl = docOf(o, spec.식);
+    if (!tpl) return void card.append(note(`${spec.식} — ${lt("Work_Wait")}`));
+    const first = was.find((s) => s.식 === spec.식) ?? null;
+    const box = el("div", {
+      className: "lstk-mctl",
+      children: [
+        el("div", { className: "lstk-fhead", children: [workTag("시간당", spec.식), el("span", { className: "lstk-hint", text: tpl.이름 ?? spec.식 })] }), // prettier-ignore
+        ...workVarRows({
+          tpl,
+          now: workDefaults(tpl, spec),
+          base: workDefaults(tpl, first),
+          ro: o.ro,
+          set: (k, v) => {
+            const vars = { ...(spec.변수 ?? {}) };
+            const back = first?.변수?.[k];
+            if (v !== null) vars[k] = v;
+            else if (back !== undefined) vars[k] = back;
+            else delete vars[k];
+            const list = specsOfRow(o.cur).map((s, j) => (j === i ? { ...s, 변수: vars } : s));
+            if (!Object.keys(vars).length) delete list[i].변수;
+            (o.cur.값 ??= {}).작업량 = list;
+            o.changed();
+          },
+        }),
+      ],
+    });
+    card.append(box);
+  });
+  attachCollapsible(card);
+  return card;
+}
+
+/** 오른쪽 풀이 — 식마다 머리 + 값 줄 + 결과 식 */
+export function sheetWorkOut(o: SheetWorkOpts): HTMLElement {
+  const specs = specsOfRow(o.cur);
+  const box = el("div", { className: "lstk-msheet-work", attrs: { "data-machine-work-out": "1" } });
+  box.append(el("strong", { text: lt("Work_Head") }));
+  if (!specs.length) return (box.append(note(lt("Work_None"))), box);
+  for (const spec of specs) {
+    const tpl = docOf(o, spec.식);
+    if (!tpl) {
+      box.append(note(`${spec.식} — ${lt("Work_Wait")}`));
+      continue;
+    }
+    const a = calcDoc(tpl, o.links, workDefaults(tpl, spec), [], new Map(), {});
+    box.append(
+      el("div", { className: "lstk-work", children: [workTag("시간당", spec.식), el("span", { className: "lstk-hint", text: tpl.이름 ?? spec.식 })] }), // prettier-ignore
+      ...hourlyRows(tpl, a, (p) => o.links.table(p)).map((r) =>
+        el("div", { className: `lstk-work ${r.cls ?? ""}`.trim(), children: r.h }),
+      ),
+    );
+  }
+  return box;
+}

A00_Common/line_stack_machine_work.ts

@@ -0,0 +1,216 @@
+/* =============================================================================
+ * line_stack_machine_work.ts
+ * 기계 시간당 작업량 묶음(PLAN 846-2 · 요구 881 · 882 · 883) — 왼쪽 기계 제어 구역 · 기계 보기가 같이 씀
+ *   제어 구역(`buildWorkGroup`) = 방식 고르기(「품셈 일당」 · 「문서 식」 | 「시간당 식」 — 기계에 맞는 식 없으면 잠김 + 까닭)
+ *     일당 = 그 풀이 읽기 글(산출근거와 같은 줄) · 시간당 = 식 고르기(여럿일 때) + 그 식 변수 칸(기본 = 기계 값 ›
+ *     식 문서 기본 · 고친 칸 「고침」 + [원래 값]) + 시간당 작업량 값
+ *     고침 = `기계덮음.<기계>.작업량 {방식 시간당, 식, 변수?}`(기본과 같은 변수 뺌 · 일당 = 칸 지움) · 읽기 = 잠김
+ *   기계 보기(`workVarRows`) = 같은 변수 칸으로 기계 작업량 줄 변수(기계 정본 값)를 고침
+ * ========================================================================== */
+
+import { createBadge } from "@ui/ui_template_badge";
+import { createButton } from "@ui/ui_template_button";
+import { eqText } from "@ui/ui_template_equation";
+import { el } from "@ui/ui_template_elements";
+import { createSelectField } from "@ui/ui_template_input";
+import { createSegment } from "@ui/ui_template_segment";
+import type { FormulaDoc } from "../common_util/common_util_formula_doc";
+import { isNum } from "../common_util/common_util_formula_doc_calc";
+import {
+  HOURLY,
+  workDefaults,
+  type WorkCover,
+  type WorkInfo,
+  type WorkSpec,
+} from "../common_util/common_util_formula_doc_work";
+import type { Values } from "../common_util/common_util_formula_doc_view";
+import { varUnit } from "../common_util/common_util_line_stack_unit";
+import { workUnit } from "../common_util/common_util_line_stack_work";
+import { numBox } from "./line_stack_machine_ctl";
+import { lt } from "./line_stack_text";
+import { workRows } from "./line_stack_work";
+
+const KINDS = ["입력", "선택", "숫자"];
+const same = (a: unknown, b: unknown): boolean =>
+  typeof a === "number" && typeof b === "number"
+    ? Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a))
+    : String(a ?? "") === String(b ?? "");
+
+/** 기본과 같은 변수 뺌 */
+export const pruneVars = (
+  vals: Record<string, unknown>,
+  base: Record<string, unknown>,
+): Record<string, unknown> =>
+  Object.fromEntries(Object.entries(vals).filter(([k, v]) => !(k in base && same(v, base[k]))));
+
+export interface VarRowsOpts {
+  tpl: FormulaDoc;
+  /** 지금 값 */
+  now: Record<string, unknown>;
+  /** 원래 값(고침 표지 · [원래 값]) */
+  base: Record<string, unknown>;
+  ro: boolean;
+  /** null = 원래대로 */
+  set: (key: string, v: number | string | null) => void;
+}
+
+/** 작업량 틀 변수 칸(입력 · 선택) — 이름(품셈 기호는 칸 풍선) = 칸 단위 */
+export function workVarRows(o: VarRowsOpts): HTMLElement[] {
+  return (o.tpl.변수 ?? [])
+    .filter((v) => v.열쇠 && KINDS.includes(v.연결?.갈래 ?? ""))
+    .map((v) => {
+      const k = v.열쇠!;
+      const now = k in o.now ? o.now[k] : o.base[k];
+      const name = v.이름 || k;
+      const list = v.연결?.목록;
+      const box =
+        v.연결?.갈래 === "선택" && list?.length
+          ? createSelectField({
+              options: list.map((x) => ({ value: String(x), text: String(x) })),
+              value: String(now ?? ""),
+              compact: true,
+              size: 24,
+              disabled: o.ro,
+              ariaLabel: name,
+              onChange: (x) => o.set(k, (list.find((y) => String(y) === x) ?? x) as number | string), // prettier-ignore
+            }).root
+          : numBox(name, now, varUnit(v), o.ro, (n) => o.set(k, n));
+      const changed = !same(now, o.base[k]);
+      const sym = [v.기호, v.아래].filter(Boolean).join(" ");
+      const row = el("div", {
+        className: "lstk-frow",
+        attrs: { "data-work-var": k },
+        children: [
+          el("b", {
+            className: "lstk-sym",
+            attrs: {
+              title: [name, sym, (v as { 설명?: string }).설명].filter(Boolean).join(" — "),
+            },
+            // 품셈 기호(q · f)는 그대로 곁에
+            children: [name, ...(v.기호 && v.기호 !== "S" && !v.아래 ? [" ", el("span", { className: "lstk-hint", text: v.기호 })] : [])], // prettier-ignore
+          }),
+          "=",
+          box,
+        ],
+      });
+      if (changed) {
+        const tag = createBadge(lt("Ctl_Changed"), "info", { size: 18 });
+        tag.title = `${lt("Ctl_Was")} ${o.base[k] === undefined ? "—" : eqText(o.base[k])}`;
+        row.append(tag);
+        if (!o.ro)
+          row.append(
+            createButton({ label: lt("Ctl_Back"), variant: "ghost", size: 24, iconStart: "undo", onClick: () => o.set(k, null) }), // prettier-ignore
+          );
+      }
+      return row;
+    });
+}
+
+export interface WorkGroupOpts {
+  doc: FormulaDoc;
+  /** 지금 셈 답 작업량(그 기계 첫 줄) */
+  info: WorkInfo;
+  /** 덮음 없을 때 꼴(일당 · 식) — 고르기 첫 칸 이름 */
+  kind: string;
+  entry: WorkCover | undefined;
+  /** 그 기계 작업량 줄(기계 값 칸) */
+  specs: WorkSpec[];
+  subDoc: (key: string) => FormulaDoc | null;
+  /** 문서 값(일당 풀이 글) */
+  vals: Values;
+  ro: boolean;
+  put: (w: WorkCover | undefined) => void;
+}
+
+/** 제어 구역 「시간당 작업량」 묶음 */
+export function buildWorkGroup(o: WorkGroupOpts): HTMLElement[] {
+  const hourly = o.entry?.방식 === HOURLY;
+  const formulas = o.info.식들 ?? [];
+  const first = o.kind === "식" ? "식" : "일당";
+  const seg = createSegment({
+    options: [
+      { value: "일당", label: lt(first === "식" ? "Work_식" : "Work_일당") },
+      {
+        value: HOURLY,
+        label: lt("Work_시간당"),
+        disabled: !formulas.length && !hourly,
+        ...(formulas.length ? {} : { title: lt("Work_None") }),
+      },
+    ],
+    value: hourly ? HOURLY : "일당",
+    size: 24,
+    ariaLabel: lt("Work_Way"),
+    onChange: (v) => o.put(v === HOURLY ? { 방식: HOURLY, 식: formulas[0] } : undefined),
+  });
+  if (o.ro) seg.root.querySelectorAll("button").forEach((b) => (b.disabled = true));
+  seg.root.dataset.workWay = hourly ? HOURLY : first;
+  const head = el("div", {
+    className: "lstk-fhead",
+    children: [
+      el("span", { className: "lstk-kind", text: lt("Work_Head") }),
+      ...(o.entry ? [createBadge(lt("Ctl_Changed"), "info", { size: 18 })] : []),
+      ...(o.entry && !o.ro
+        ? [createButton({ label: lt("Ctl_Back"), variant: "ghost", size: 24, iconStart: "undo", onClick: () => o.put(undefined) })] // prettier-ignore
+        : []),
+    ],
+  });
+  const note = (text: string, cls = "lstk-empty"): HTMLElement => el("div", { className: cls, text }); // prettier-ignore
+  const locked = !formulas.length && !hourly ? [note(lt("Work_None"))] : []; // 식 없는 기계 = 잠김 까닭
+  const out: HTMLElement[] = [head, el("div", { className: "lstk-work", children: [seg.root, ...locked] })]; // prettier-ignore
+  if (!hourly) {
+    const rows = workRows(o.info, { doc: o.doc, vals: o.vals, miss: () => undefined });
+    // 방식 작은 글은 고르기가 보임 — 풀이만
+    const bare = (r: { h: (string | HTMLElement)[] }) => r.h.filter((x) => typeof x === "string" || !x.dataset.work); // prettier-ignore
+    out.push(...rows.map((r) => el("div", { className: "lstk-work", children: bare(r) })));
+    return out;
+  }
+  const pick = o.entry?.식 || o.info.율 || formulas[0] || "";
+  if (formulas.length > 1)
+    out.push(
+      el("div", {
+        className: "lstk-frow",
+        children: [
+          el("b", { className: "lstk-sym", text: lt("Work_Pick") }),
+          "=",
+          createSelectField({
+            options: formulas.map((k) => ({ value: k, text: o.subDoc(k)?.이름 ?? k })),
+            value: pick,
+            compact: true,
+            size: 24,
+            disabled: o.ro,
+            ariaLabel: lt("Work_Pick"),
+            onChange: (k) => o.put({ 방식: HOURLY, 식: k }),
+          }).root,
+        ],
+      }),
+    );
+  if (o.info.까닭) out.push(note(o.info.까닭, "lstk-miss"));
+  const tpl = pick ? o.subDoc(pick) : null;
+  if (!tpl) return [...out, note(lt("Work_Wait"))];
+  const base = workDefaults(tpl, o.specs.find((s) => s.식 === pick) ?? null);
+  const mine = o.entry?.변수 ?? {};
+  out.push(
+    el("div", { className: "lstk-work", children: [el("span", { className: "lstk-hint", text: tpl.이름 ?? pick })] }), // prettier-ignore
+    ...workVarRows({
+      tpl,
+      now: { ...base, ...mine },
+      base,
+      ro: o.ro,
+      set: (k, v) => {
+        const next = { ...mine };
+        if (v === null) delete next[k];
+        else next[k] = v;
+        const kept = pruneVars(next, base);
+        o.put({ 방식: HOURLY, 식: pick, ...(Object.keys(kept).length ? { 변수: kept } : {}) });
+      },
+    }),
+    el("div", {
+      className: "lstk-work",
+      children: [
+        el("b", { text: `${lt("Work_Head")} = ` }),
+        isNum(o.info.값) ? `${eqText(o.info.값)} ${workUnit(o.info.단위)}`.trim() : "—",
+      ],
+    }),
+  );
+  return out;
+}

A00_Common/line_stack_out.ts

@@ -6,6 +6,7 @@
  *   기계 · 단가산출 줄 = 비목마다 「노무비 : 59,020 × … = 금액」 — 제목 줄(「굴착기 0.6㎥」) 누름 = 그 문서(기계 시간당 경비 등)를
  *     같은 계산기로 셈해 같은 꼴로 펼침(손료 식 · 연료 · 운전사 · 노 · 재 · 경 · 계) · 비목 수는 글(링크 꼴 없음 · 요구 687-11) ·
  *     공식 줄 단가산출 결과 = 수 누름(▸) · 접으면 한 줄 · 출력엔 펼친 것만
+ *   기계 줄 작업량(846-2) = 「시간당 작업량 = …」 줄 먼저 · 비목 줄 「÷ 70 ㎥/시간」(`line_stack_work`)
  *   값 = 계산기 셈 답 그대로(`calcDoc` · 줄 `answer.줄` · 합 `노무비` …) — 여기서 다시 셈 안 함 · 조판 = KaTeX(`line_stack_tex.ts`)
  * ========================================================================== */
 
@@ -50,9 +51,11 @@ import {
   unitText,
   shownUnitOf,
 } from "../common_util/common_util_line_stack_unit";
+import { workAt } from "../common_util/common_util_line_stack_work";
 import { partName } from "../common_util/common_util_machine_symbol_name";
 import { katexNode, symTex, tex, txt, valTex, type TexCtx } from "./line_stack_tex";
 import { lt } from "./line_stack_text";
+import { workQty, workRows } from "./line_stack_work";
 
 type Cols = Partial<Record<"sum" | (typeof COSTS)[number], number>>;
 interface Row {
@@ -318,18 +321,30 @@ function rows(
     // 값 · 단위 한 덩이(좁은 폭에서 줄이 바뀌어도 단위가 떨어지지 않게)
     const glue = (...xs: (string | HTMLElement)[]): HTMLElement =>
       el("span", { className: "lstk-pack", children: xs.filter((x) => x !== "") });
+    // 846-2 작업량 — 「시간당 작업량」 줄 먼저 · 수량 = 「÷ 시간당 작업량」
+    const w = workAt(a, i);
+    const wq = (): HTMLElement[] | null => workQty(doc, qty, w, scope, alias); // 줄마다 새 요소
+    const byWork = wq() !== null;
+    const workHead = (): void => {
+      if (!w) return;
+      const got = workRows(w, { doc, vals: scope, links: h.cache.links, miss: () => undefined, look }); // prettier-ignore
+      if (h.cache.takeMissing()) h.miss();
+      for (const r of got) push(r);
+    };
     const qtyNode = (cost?: string): (string | HTMLElement)[] =>
       qty === null
         ? []
-        : [
-            glue(
-              " × ",
-              mu.wrap && qn
-                ? katexNode(`\\left(${tex(qn, { side: "val", vals: scope, inline: true, cost, alias })}\\right)`) // prettier-ignore
-                : exprNode(qty, "val", scope, true, cost, { alias }),
-              mu.qty ? ` ${mu.qty}` : "",
-            ),
-          ];
+        : byWork
+          ? [glue(" ", ...wq()!)]
+          : [
+              glue(
+                " × ",
+                mu.wrap && qn
+                  ? katexNode(`\\left(${tex(qn, { side: "val", vals: scope, inline: true, cost, alias })}\\right)`) // prettier-ignore
+                  : exprNode(qty, "val", scope, true, cost, { alias }),
+                mu.qty ? ` ${mu.qty}` : "",
+              ),
+            ];
     const priceUnit = mu.price ? ` ${mu.price}` : "";
     if (r.까닭 && r.금액 === null) {
       push({ h: [`${name} : — `, el("span", { className: "lstk-miss", text: r.까닭 })] });
@@ -341,6 +356,7 @@ function rows(
       const cols: Cols = {};
       const title = name || (s ? (subOf(s)?.이름 ?? s) : "");
       push({ h: s && subOf(s) ? fold(s, title) : [title], cls: "lname" });
+      workHead();
       for (const c of COSTS) {
         const part = r.비목?.[c];
         if (!isNum(part) || (!part && !bundle[c])) continue;
@@ -364,6 +380,7 @@ function rows(
         : [glue(exprNode(line.단가, "val", scope, true, undefined, { alias }), priceUnit)];
     const c = String(line.비목);
     const bare = !!line.합밖 && !line.비목; // 합 밖 소계(810-2) = 글에만 금액 · 비목 칸 빈칸
+    workHead();
     push({
       h: [`${name} : `, ...price, ...qtyNode(), ` = ${one(amt)} ${AMOUNT_UNIT}`],
       cols: bare ? {} : { sum: amt, [c]: amt },

A00_Common/line_stack_screen.ts

@@ -56,6 +56,7 @@ import { askRenew } from "./formula_doc_renew";
 import { buildOptions } from "./formula_doc_options";
 import { ft } from "./formula_doc_text";
 import { addTaken, type Taken } from "../common_util/common_util_line_stack_copy";
+import { machineWork } from "../common_util/common_util_line_stack_work";
 import type { Layer } from "../M02_MasterTemplete/M02_MasterTemplete_Api_Fetch";
 import { buildEdit } from "./line_stack_edit";
 import { openMachineWindow, type CopyAnswer, type MachineCtx } from "./line_stack_machine";
@@ -378,6 +379,7 @@ export function createStackScreen(opt: StackScreenOptions) {
               calc: calcSub,
               lists: (g) => listsOf((q) => cache.links.element(q), g),
               look: (p) => cache.links.table(p),
+              work: (m) => machineWork((q) => cache.links.element(q), m),
               before: saved ? lineMap(JSON.parse(saved) as StackDoc) : undefined,
             }),
           ]

A00_Common/line_stack_text.ts

@@ -90,7 +90,10 @@ const TEXT = {
     "이 값의 줄은 위 옵션이 고름(다른 줄은 옵션에서 바꿈 · 여기선 칸만)",
     "Row follows the option above (change it there; pick a column here)",
   ],
-  Ctl_Open: ["기계 값 · 조종원 · 잡품 고치기", "Edit machine values · operator · sundries"],
+  Ctl_Open: [
+    "기계 값 · 조종원 · 잡품 · 작업량 고치기",
+    "Edit machine values · operator · sundries · output",
+  ],
   Ctl_Values: ["기계 값", "Machine values"],
   Ctl_Crew: ["조종원", "Operator"],
   Ctl_Misc: ["잡품", "Sundries"],
@@ -104,6 +107,18 @@ const TEXT = {
   Ctl_Rate: ["율", "Rate"],
   Ctl_Follow: ["(따름)", "(follows)"],
   Ctl_None: ["없음", "None"],
+  Work_Head: ["시간당 작업량", "Output per hour"],
+  Work_일당: ["품셈 일당", "Daily output"],
+  Work_식: ["문서 식", "Doc formula"],
+  Work_시간당: ["시간당 식", "Hourly formula"],
+  Work_Way: ["작업량 방식", "Output method"],
+  Work_Pick: ["작업량 식", "Output formula"],
+  Work_Day: ["시공량", "Daily output"],
+  Work_Unit: ["대", "unit"],
+  Work_Hours: ["시간", "h"],
+  Work_None: ["시간당 작업량 식 없는 기계", "No hourly output formula for this machine"],
+  Work_Wait: ["작업량 식 불러오는 중", "Loading output formula"],
+  Work_Vars: ["작업량 변수", "Output variables"],
   Win_Ctl_Note: [
     "기계 내부 값(가격 · 연료 · 조종원 · 잡품)은 단가산출 왼쪽 기계 줄의 ▸ 에서 고침",
     "Edit machine internals from the ▸ on the left machine line",

A00_Common/line_stack_work.ts

@@ -0,0 +1,143 @@
+/* =============================================================================
+ * line_stack_work.ts
+ * 산출근거 시간당 작업량 줄(PLAN 846-2 · 요구 879 · 881 · 882 · 883) — 기계 줄은 「시간당 작업량」 을 먼저 보이고
+ *   비목 줄을 「노무비 : 59,020 원/시간 ÷ 70 ㎥/시간 = 843.1 원」 으로(금액 = 계산기 답 그대로 · 그리기만)
+ *   일당 = 「시간당 작업량 = 시공량 560 ㎥/일 ÷ (1 대 × 8 시간) = 70 ㎥/시간」
+ *   문서 식 = 「시간당 작업량 = Q_작업 = 24.89 ㎥/시간」(식 풀이는 위 공식 줄)
+ *   시간당 식 = 그 기계 작업량 틀 풀이 — 값 줄(q · K · f · E · cm) + 「Q = 3,600 × q × K × f × E ÷ cm = … ㎥/시간」
+ *     (원문 한 층 분수 · 겹분수 규칙 = 845-2 `frac` 1 층) · 기계 보기도 같은 줄(`hourlyRows`)
+ *   머리 작은 글 = 방식(「품셈 일당」 · 「문서 식」 · 「시간당 식」) · 자료 = `common_util_line_stack_work`
+ * ========================================================================== */
+
+import { createBadge } from "@ui/ui_template_badge";
+import { el } from "@ui/ui_template_elements";
+import { eqText } from "@ui/ui_template_equation";
+import { varId, type FormulaDoc, type Node } from "../common_util/common_util_formula_doc";
+import {
+  calcDoc,
+  isNum,
+  type DocAnswer,
+  type DocLinks,
+} from "../common_util/common_util_formula_doc_calc";
+import type { WorkInfo } from "../common_util/common_util_formula_doc_work";
+import type { Values } from "../common_util/common_util_formula_doc_view";
+import { nodeOf } from "../common_util/common_util_line_stack";
+import { shownUnitOf } from "../common_util/common_util_line_stack_unit";
+import {
+  dailyParts,
+  dayUnit,
+  hourlyParts,
+  restOfQty,
+  workUnit,
+} from "../common_util/common_util_line_stack_work";
+import { katexNode, symTex, tex, txt, valTex } from "./line_stack_tex";
+import { lt, type LsKey } from "./line_stack_text";
+
+export interface WorkRow {
+  h: (string | HTMLElement)[];
+  cls?: string;
+}
+
+/** 방식 작은 글 */
+export function workTag(kind: string, title = ""): HTMLElement {
+  const key = `Work_${kind}` as LsKey;
+  const b = createBadge(lt(key) || kind, "neutral", { size: 18 });
+  b.dataset.work = kind;
+  if (title) b.title = title;
+  return b;
+}
+
+/** 「a = b = c」 — 조각마다 조판(좁은 폭에서 조각 사이로 줄이 바뀜 · 공식 줄과 같음) */
+const chain = (...xs: string[]): (string | HTMLElement)[] =>
+  xs.flatMap((x, i) => (i ? [" = ", katexNode(x)] : [katexNode(x)]));
+const unitTex = (u: string): string => (u ? `\\ ${txt(u)}` : "");
+const amount = (v: unknown, u: string): string => `${valTex(v)}${unitTex(u)}`;
+
+/** 작업량 틀 풀이 — 값 줄 + 결과 식 줄(없으면 빈 목록) */
+export function hourlyRows(
+  tpl: FormulaDoc,
+  a: DocAnswer,
+  look?: (p: Values) => unknown,
+): WorkRow[] {
+  const parts = hourlyParts(tpl);
+  if (!parts) return [];
+  const vals = (a.값 ?? {}) as Values;
+  const vars = new Map((tpl.변수 ?? []).map((v) => [varId(v), v]));
+  const unit = (id: string): string => workUnit(shownUnitOf(vars.get(id), vals, look));
+  const pack = parts.uses.map((id) =>
+    katexNode(`${symTex(id)} = ${isNum(vals[id]) ? amount(vals[id], unit(id)) : txt("—")}`),
+  );
+  const res = vals[parts.id];
+  const sym = tex(parts.node, { side: "sym", vals, frac: 1 });
+  const val = tex(parts.node, { side: "val", vals, frac: 1 });
+  const end = isNum(res) ? amount(res, workUnit(tpl.결과단위)) : txt("—");
+  return [
+    ...(pack.length ? [{ h: pack, cls: "packs" }] : []),
+    { h: chain(symTex(parts.id), sym, val, end), cls: "work" },
+  ];
+}
+
+export interface WorkCtx {
+  doc: FormulaDoc;
+  vals: Values;
+  /** 시간당 식 풀이 때만(작업량 틀 · 표) */
+  links?: DocLinks;
+  /** 캐시에 없는 연결(작업량 틀) — 뒤에서 서버 */
+  miss: () => void;
+  look?: (p: Values) => unknown;
+}
+
+/** 시간당 작업량 줄(머리 + 풀이) — 값 없으면 빈 목록(까닭은 금액 줄이 보임) */
+export function workRows(w: WorkInfo, c: WorkCtx): WorkRow[] {
+  const head = lt("Work_Head");
+  const u = workUnit(w.단위);
+  if (w.꼴 === "시간당") {
+    let tpl: FormulaDoc | null = null;
+    try {
+      tpl = c.links?.doc(w.율) ?? null;
+    } catch {
+      c.miss();
+    }
+    const tag = workTag(w.꼴, tpl?.이름 ?? w.율);
+    if (!tpl) return [{ h: [tag, `${head} = `, isNum(w.값) ? `${eqText(w.값)} ${u}`.trim() : lt("Work_Wait")] }]; // prettier-ignore
+    const a = calcDoc(tpl, c.links!, w.변수 ?? {}, [], new Map(), {});
+    const name = el("span", { className: "lstk-hint", text: tpl.이름 ?? w.율 });
+    return [{ h: [tag, name] }, ...hourlyRows(tpl, a, c.look)];
+  }
+  if (!isNum(w.값)) return [];
+  const tag = workTag(w.꼴 || "일당");
+  const res = amount(w.값, u);
+  const parts = w.꼴 === "일당" ? dailyParts(w.율) : null;
+  if (parts) {
+    const val = (n: Node): string => tex(n, { side: "val", vals: c.vals, inline: true });
+    const dayName = parts.day[0] === "var" ? nameOf(c.doc, parts.day[1]) : "";
+    const day = `${dayName ? `${txt(dayName)}\\ ` : ""}${val(parts.day)}${unitTex(dayUnit(w.단위))}`;
+    const per = parts.per
+      .map((p) => `${val(p.node)}${unitTex(lt(p.hours ? "Work_Hours" : "Work_Unit"))}`)
+      .join(" \\times ");
+    const den = parts.per.length > 1 ? `\\left(${per}\\right)` : per;
+    return [{ h: [tag, ...chain(txt(head), `${day} \\div ${den}`, res)], cls: "work" }];
+  }
+  const n = nodeOf(w.율);
+  const body = n ? [tex(n, { side: "sym", vals: c.vals, inline: true })] : [];
+  return [{ h: [tag, ...chain(txt(head), ...body, res)], cls: "work" }];
+}
+
+/** 비목 줄 수량 자리 — 「÷ 70 ㎥/시간 (× 나머지)」 · 꼴이 다르면 null(지금 꼴 그대로) */
+export function workQty(
+  doc: FormulaDoc,
+  qty: unknown,
+  w: WorkInfo | null,
+  scope: Values,
+  alias?: Record<string, string>,
+): HTMLElement[] | null {
+  if (!w || !isNum(w.값) || w.값 <= 0) return null;
+  const got = restOfQty(doc, qty);
+  if (!got) return null;
+  const by = katexNode(`{}\\div ${amount(w.값, workUnit(w.단위))}`); // {} = 두 항 사이 ÷ 간격
+  if (!got.rest) return [by];
+  return [by, katexNode(`\\times ${tex(got.rest, { side: "val", vals: scope, inline: true, alias })}`)]; // prettier-ignore
+}
+
+const nameOf = (doc: FormulaDoc, id: string): string =>
+  (doc.변수 ?? []).find((v) => varId(v) === id)?.이름 ?? "";