@eintrek/erp-shell 0.1.74 → 0.1.75

package/dist/guide/core.d.ts

@@ -10,9 +10,11 @@
  * The main entry re-exports the same modules, so a tour defined against
  * either entry is the same data, and the bus and the "?" entry are shared.
  */
-export type { GuideAbortAction, GuideAnchorKey, GuideApiFailure, GuideApiMatch, GuideAppId, GuideCaptureEvent, GuideConfig, GuideContext, GuideFacts, GuideGate, GuideMission, GuideNothingToSave, GuideOnMissing, GuidePage, GuideStep, GuideStepKind, GuideSuite, GuideText, GuideTrigger, } from "./types";
+export type { GuideAbortAction, GuideAnchorKey, GuideApiFailure, GuideApiMatch, GuideAppId, GuideCaptureEvent, GuideConfig, GuideContext, GuideFacts, GuideGate, GuideMission, GuideNothingToSave, GuideOnMissing, GuidePage, GuideSection, GuideStep, GuideStepKind, GuideSuite, GuideText, GuideTrigger, } from "./types";
 export { API_EVENT as GUIDE_API_EVENT, GUIDE_EVENT_PREFIX, GUIDE_LAYER_ATTRIBUTE, apiCallDetail, emitGuideEvent, guideAnchor, reportApiCall, reportApiEvent, type ApiCallReport, type ApiEventDetail, type GuideAnchorProps, } from "./events";
-export { guideMenuItems, guideMenuShown, openGuidePanel, openPageGuide, openPagesPanel, useGuideEntry, usePageGuideEntry, usePageGuides, type GuideEntry, type GuideMenuItem, type PageGuidesEntry, } from "./guide-store";
+export { guideMenuItems, guideMenuShown, openGuidePanel, openPageGuide, openPagesPanel, openSectionGuide, setSectionGuideValues, useGuideEntry, usePageGuideEntry, usePageGuides, useSectionGuideValues, type GuideEntry, type GuideMenuItem, type PageGuidesEntry, } from "./guide-store";
+export { SectionGuideButton, type SectionGuideButtonProps } from "./section-button";
+export { THAI_MONTHS_SHORT, formatBaht, thaiMonth, thaiMonthYear } from "./format";
 export { GuideRuntime, type GuideMenu, type GuideRouting, type GuideRuntimeProps, } from "./guide-runtime";
 export { GuideProgressConflict, loadGuides, storeGuides, type GuideProgressAdapter, type GuideProgressRequest, type GuideProgressResponse, } from "./progress-sync";
 export type { GuideAudience, GuideMode, PagesMode } from "./progress";

package/dist/guide/format.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Small formatters for section guides' copy (shell 0.1.75): the app passes
+ * its own computed numbers, and the copy says them the way the page does —
+ * "ม.ค. รับ 500,000 − จ่าย 320,000 = คงเหลือ 180,000".
+ *
+ * Pure: the tests run it in Node.
+ */
+export declare const THAI_MONTHS_SHORT: readonly ["ม.ค.", "ก.พ.", "มี.ค.", "เม.ย.", "พ.ค.", "มิ.ย.", "ก.ค.", "ส.ค.", "ก.ย.", "ต.ค.", "พ.ย.", "ธ.ค."];
+/**
+ * A baht amount with thousands separators, no currency sign: 500000 →
+ * "500,000"; 1234.5 → "1,234.50"; -320000 → "-320,000". Whole amounts
+ * have no decimals unless `decimals` says so; others have two. Not a
+ * finite number → "" (a step whose value is missing is skipped anyway).
+ */
+export declare function formatBaht(n: unknown, opts?: {
+    decimals?: number;
+}): string;
+/** "2026-01" (or a Date, or 1) → "ม.ค."; "" when it is not a month. */
+export declare function thaiMonth(m: unknown): string;
+/**
+ * "2026-01" → "ม.ค. 69" (the Buddhist year's last two digits), or with
+ * `{ year: "full" }` "ม.ค. 2569"; just the month when no year is known.
+ */
+export declare function thaiMonthYear(m: unknown, opts?: {
+    year?: "short" | "full";
+}): string;

package/dist/guide/guide-store.d.ts

@@ -21,11 +21,19 @@ export interface PageGuidesEntry {
     } | null;
     /** Page guides with an `href` this person has (the panel's list). */
     listed: number;
+    /**
+     * Section guides on screen here that this person has ("อธิบายส่วนนี้ ·
+     * <title>"), in the suite's order. Shell ≥ 0.1.75.
+     */
+    sections?: ReadonlyArray<{
+        key: string;
+        title: string;
+    }>;
 }
-/** Called by the host: this page's guide and the listed count, and how to open them. */
-export declare function publishPageGuides(next: PageGuidesEntry | null, openPage: (() => void) | null, openPages: (() => void) | null): void;
-/** The "?" menu's items, in order (pure: the menu and its tests share it). */
-export type GuideMenuItem = "page" | "missions" | "pages" | "help";
+/** Called by the host: this page's guide, the listed count, the sections on screen, and how to open them. */
+export declare function publishPageGuides(next: PageGuidesEntry | null, openPage: (() => void) | null, openPages: (() => void) | null, openSection?: ((key: string) => void) | null): void;
+/** The "?" menu's items, in order (pure: the menu and its tests share it). "sections": one entry per section guide. */
+export type GuideMenuItem = "page" | "sections" | "missions" | "pages" | "help";
 export declare function guideMenuItems(e: GuideEntry | null, p?: PageGuidesEntry): GuideMenuItem[];
 /**
  * Whether the "?" press opens a menu rather than the help dialog: a tour
@@ -55,3 +63,28 @@ export declare function usePageGuideEntry(): {
     title: string;
     open: () => void;
 } | null;
+/**
+ * Opens a section guide ("อธิบายส่วนนี้"), when it is on screen here for this
+ * person. The values it shows are the ones the app last rendered
+ * (`useSectionGuideValues`).
+ */
+export declare function openSectionGuide(key: string): void;
+type Values = Readonly<Record<string, unknown>>;
+/**
+ * Sets (or with undefined, clears) a section guide's live values. The
+ * engine reads the latest whenever it draws a step, so a page that
+ * re-renders mid-guide never leaves an old number on screen.
+ */
+export declare function setSectionGuideValues(key: string, values: Values | undefined): void;
+/** A section guide's live values now (empty when the app has given none). */
+export declare function getSectionGuideValues(key: string | null | undefined): Values;
+/** Re-renders when any section guide's values change (the engine's own use). */
+export declare function useSectionValuesVersion(): number;
+/**
+ * Hands a section guide the numbers its copy uses, from the component that
+ * computes them: `useSectionGuideValues("cash-flow", { month: "ม.ค.", cashIn,
+ * … })`. Call it on every render (the latest wins); they go when the
+ * component unmounts. undefined values: nothing.
+ */
+export declare function useSectionGuideValues(key: string, values: Values | undefined): void;
+export {};

package/dist/guide/machine.d.ts

@@ -58,6 +58,8 @@ export type GuideScreen = {
     replayNext: boolean;
     /** A page guide's step: the page key (the mission is `page:<key>`). Shell ≥ 0.1.74. */
     page?: string;
+    /** A section guide's step: the section key (the mission is `section:<key>`). Shell ≥ 0.1.75. */
+    section?: string;
 }
 /** The first-visit offer of this page's guide: a small card, not modal. */
  | {
@@ -98,24 +100,38 @@ export interface GuideState {
     pagesMode: PagesMode;
     /** Page rows by page key, as the server holds them (or as just written). */
     pages: Record<string, PageRow>;
+    /** Section rows by section key (`<app>.section.<key>`). Shell ≥ 0.1.75. */
+    sections: Record<string, PageRow>;
     /**
-     * The page guide being played: `write` when its row is still to be
-     * written (the offer was taken, or this person has never ended this
-     * version); a replay from "?" of a recorded page writes nothing.
+     * The page or section guide being played: `write` when its row is still
+     * to be written (the offer was taken, or this person has never ended this
+     * version); a replay of a recorded one writes nothing.
      */
     pageRun: {
         key: string;
         write: boolean;
+        kind?: ReadKind;
     } | null;
     /** What the panel shows: everything, or the page guides alone ("คู่มือทุกหน้า"). */
     panelSection: "all" | "pages";
+    /**
+     * Steps of the mission being played that passed by themselves (a click
+     * whose outcome already held): not counted in "ขั้นที่ x/y". Shell ≥ 0.1.75.
+     */
+    autoPassed: {
+        mission: string;
+        steps: number[];
+    } | null;
 }
 /** The page-guide part of the state, from the progress answer. */
 export interface GuidePagesInit {
     pageAudience: GuideAudience;
     pagesMode: PagesMode;
     pages: Record<string, PageRow>;
+    sections?: Record<string, PageRow>;
 }
+/** A read-only guide: a page guide or a section guide. */
+export type ReadKind = "page" | "section";
 export interface ReplayPage {
     mission: string;
     /** The mission's abort anchors that were on the page at the start. */
@@ -138,6 +154,8 @@ export interface GuideEnv {
     targetValue: () => string;
     /** An app dialog (not the tour's) is open. */
     dialogOpen?: () => boolean;
+    /** The running (or opening) section guide's live values (GuideContext.values). */
+    values?: Readonly<Record<string, unknown>>;
 }
 export type GuideSignal = {
     kind: "api";
@@ -269,6 +287,12 @@ export type GuideAction = {
     type: "pageRow";
     key: string;
     row: PageRow;
+    kind?: ReadKind;
+}
+/** "อธิบายส่วนนี้": a section guide on screen here (its button, or "?"). */
+ | {
+    type: "startSection";
+    section: string;
 };
 export type GuideEffect = {
     type: "save";
@@ -291,12 +315,13 @@ export type GuideEffect = {
     type: "abort";
     actions: GuideAbortAction[];
 }
-/** Write a page guide's row, once: `<app>.page.<key>`. */
+/** Write a page (or section) guide's row, once: `<app>.page.<key>` / `<app>.section.<key>`. */
  | {
     type: "savePage";
     key: string;
     version: number;
     status: "completed" | "skipped";
+    kind?: ReadKind;
 };
 export interface GuideResult {
     state: GuideState;
@@ -312,6 +337,7 @@ export declare const COPY: {
     readonly hiddenToast: "ซ่อนแล้ว";
     readonly aborted: "ไกด์ไปต่อไม่ได้ ลองอีกครั้งภายหลัง";
     readonly pageDone: "จบคู่มือหน้านี้";
+    readonly sectionDone: "จบคำอธิบายส่วนนี้";
     readonly bridgeTitle: "กดปุ่มเมนู";
     readonly bridgeWhy: (app: string) => string;
 };
@@ -389,10 +415,14 @@ export declare function chipVisible(state: GuideState, suite: GuideSuite, ctx: G
  * whose `requires` they lack or whose `skipIf` holds is left out (the step on
  * screen always counts).
  */
-export declare function stepPosition(mission: GuideMission, index: number, env: GuideEnv, context: Readonly<Record<string, string>>): {
+export declare function stepPosition(mission: GuideMission, index: number, env: GuideEnv, context: Readonly<Record<string, string>>, autoPassed?: readonly number[]): {
     no: number;
     total: number;
 };
+/** A step entered now would pass at once: a click or select step whose route or visible outcome holds. */
+export declare function wouldAutoPass(step: GuideStep, env: GuideEnv): boolean;
+/** The steps of this mission that passed by themselves in this run. */
+export declare function autoPassedOf(state: GuideState, mission: string): readonly number[];
 /** "กด [บันทึก]" → "กด บันทึก" (for screen readers). */
 export declare function plainTitle(t: string): string;
 /** The step's status line (GuideStep.status): trimmed text, or null. */
@@ -428,6 +458,13 @@ export declare function firstStepReady(suite: GuideSuite, pageKey: string, env:
  * route, a moment of nothing loading, the primary tab, not hidden.
  */
 export declare function pageOfferDue(state: GuideState, suite: GuideSuite, env: GuideEnv): string | null;
+/** The section guide's row says this person has ended this version of it. */
+export declare function sectionRecorded(state: GuideState, section: {
+    key: string;
+    version: number;
+}): boolean;
+/** The section guides on screen here that this person has (the "?" entries, the buttons). */
+export declare function sectionsAvailable(suite: GuideSuite, env: GuideEnv): string[];
 /** The step before this one that this person sees, or -1. */
 export declare function previousShownIndex(mission: GuideMission, index: number, env: GuideEnv, context: Readonly<Record<string, string>>): number;
 /**

package/dist/guide/pages.d.ts

@@ -6,7 +6,7 @@
  * A page guide runs through the missions' machinery as a synthetic mission
  * `page:<key>` in replay mode, so nothing it does writes tour progress.
  */
-import type { GuideContext, GuideMission, GuidePage, GuideSuite } from "./types";
+import type { GuideContext, GuideMission, GuidePage, GuideSection, GuideSuite } from "./types";
 /** The synthetic mission key of a page guide: `page:<key>`. */
 export declare const PAGE_PREFIX = "page:";
 export declare function isPageMissionKey(key: string | null | undefined): boolean;
@@ -54,3 +54,26 @@ export declare function pageShown(page: GuidePage, ctx: GuideContext): boolean;
 export declare function currentPage(suite: GuideSuite, where: PageWhere, ctx: GuideContext): GuidePage | null;
 /** The page guides this person has, for the panel's list (those with an `href`). */
 export declare function listedPages(suite: GuideSuite, ctx: GuideContext): GuidePage[];
+/** The synthetic mission key of a section guide: `section:<key>`. */
+export declare const SECTION_PREFIX = "section:";
+export declare function isSectionMissionKey(key: string | null | undefined): boolean;
+export declare function sectionKeyOf(missionKey: string | null | undefined): string | undefined;
+/** Why a section guide cannot run, or null when it can. */
+export declare function sectionProblem(app: string, section: GuideSection): string | null;
+/** The suite's section guides that can run (as validPages: the rest dropped, with a warning in development). */
+export declare function validSections(suite: GuideSuite): GuideSection[];
+export declare function findSection(suite: GuideSuite, key: string | null | undefined): GuideSection | undefined;
+/** A live value is missing: undefined, null, "" or a number that is not finite. */
+export declare function valueMissing(v: unknown): boolean;
+/**
+ * The section guide as a mission the machine plays: `section:<key>`, read
+ * steps only, checkpoints unless they say otherwise. A step is skipped while
+ * a value it `needs` is missing, or when its title comes out empty.
+ */
+export declare function sectionMission(section: GuideSection): GuideMission;
+/** Whether the section guide applies here: one of its routes matches and its root is on screen. */
+export declare function sectionApplies(section: GuideSection, where: PageWhere): boolean;
+/** Whether this person has the section guide: `visible` (only true) and `requires`. */
+export declare function sectionShown(section: GuideSection, ctx: GuideContext): boolean;
+/** The section guides on screen here that this person has, in the suite's order. */
+export declare function sectionsHere(suite: GuideSuite, where: PageWhere, ctx: GuideContext): GuideSection[];

package/dist/guide/progress-sync.d.ts

@@ -67,10 +67,11 @@ export declare function loadGuides(adapter: GuideProgressAdapter, suite: GuideSu
  */
 export declare function storeGuides(adapter: GuideProgressAdapter, suite: GuideSuite, progress: GuideProgress): Promise<GuideProgress | null>;
 /**
- * Writes a page guide's row (`<app>.page.<key>`) once: the minimal body,
+ * Writes a page guide's row (`<app>.page.<key>`), or a section guide's
+ * (`<app>.section.<key>`, kind "section"), once: the minimal body,
  * with the same 409 handling as the tour's row. Another tab that already
  * recorded this version wins (its row is returned, nothing is sent again);
  * an older version's row is replaced with its rev; a newer one stops. Returns
  * the stored row, or null when it could not be saved.
  */
-export declare function storePageRow(adapter: GuideProgressAdapter, app: string, key: string, version: number, status: "completed" | "skipped", rev: number): Promise<PageRow | null>;
+export declare function storePageRow(adapter: GuideProgressAdapter, app: string, key: string, version: number, status: "completed" | "skipped", rev: number, kind?: "page" | "section"): Promise<PageRow | null>;

package/dist/guide/progress.d.ts

@@ -55,6 +55,8 @@ export interface GuidesAnswer {
     pageAudience: GuideAudience;
     /** Page rows by page key (the part after `<app>.page.`). */
     pages: Record<string, PageRow>;
+    /** Section rows by section key (the part after `<app>.section.`). Shell ≥ 0.1.75. */
+    sections: Record<string, PageRow>;
     /** The suite's row; a fresh one when the user has none or an older version. */
     progress: GuideProgress;
     /** The server holds a newer version than this app's tour: do not run. */
@@ -72,10 +74,10 @@ export declare function parseGuidesAnswer(payload: unknown, suite: {
     version: number;
     app: string;
 }): GuidesAnswer | null;
-/** The row key of a page guide: `<app>.page.<key>`. */
-export declare function pageRowKey(app: string, key: string): string;
-/** Page rows among the list's rows, by page key. Off-shape rows are left out. */
-export declare function parsePageRows(rows: unknown[], app: string): Record<string, PageRow>;
+/** The row key of a page guide, `<app>.page.<key>`, or a section guide, `<app>.section.<key>`. */
+export declare function pageRowKey(app: string, key: string, kind?: "page" | "section"): string;
+/** Page (or section) rows among the list's rows, by key. Off-shape rows are left out. */
+export declare function parsePageRows(rows: unknown[], app: string, kind?: "page" | "section"): Record<string, PageRow>;
 /** One page row (a list entry, a PUT answer, a 409's `current`); null when off-shape. */
 export declare function parsePageRow(raw: unknown): PageRow | null;
 /**

package/dist/guide/section-button.d.ts

@@ -0,0 +1,12 @@
+export interface SectionGuideButtonProps {
+    /** The GuideSection's key. */
+    guideKey: string;
+    /**
+     * The numbers the guide's copy uses (`ctx.values`), from this render.
+     * Optional: the section may call `useSectionGuideValues` itself instead.
+     */
+    values?: Readonly<Record<string, unknown>>;
+    /** Replaces the default look (a 22px round icon button in the text colour). */
+    className?: string;
+}
+export declare function SectionGuideButton({ guideKey, values, className }: SectionGuideButtonProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/guide/types.d.ts

@@ -41,6 +41,12 @@ export interface GuideContext {
     can: (policyKey: string) => boolean;
     /** Whether an anchor is on screen now. */
     visible: (anchor: GuideAnchorKey) => boolean;
+    /**
+     * A section guide's live values, as the app last rendered them
+     * (`useSectionGuideValues` / `SectionGuideButton values`); empty
+     * elsewhere. Shell ≥ 0.1.75.
+     */
+    values?: Readonly<Record<string, unknown>>;
 }
 /** Text that may depend on the context. */
 export type GuideText = string | ((ctx: GuideContext) => string);
@@ -171,6 +177,12 @@ export interface GuideStep {
     status?: (ctx: GuideContext) => string | null | undefined;
     /** Skip the step (silently) when true. Runs every time it is entered. */
     skipIf?: (ctx: GuideContext) => boolean;
+    /**
+     * Section guides: the live values this step's copy uses
+     * (`ctx.values`). The step is skipped while any is missing (undefined,
+     * null, "" or a number that is not finite). Shell ≥ 0.1.75.
+     */
+    needs?: string[];
     /** A policy key the step needs (checked with `guides.can`); skipped when
      *  the user lacks it. */
     requires?: string;
@@ -378,6 +390,39 @@ export interface GuidePage {
      */
     steps: GuideStep[];
 }
+/**
+ * A section guide ("อธิบายส่วนนี้", shell ≥ 0.1.75): explains one section of
+ * a page — a number-heavy card or table — row by row, with the formula and
+ * this record's own numbers. Read-only ("view" steps only; a step may point
+ * at a row or cell inside the section with `targetId`), never offered by
+ * itself: it opens from the section's `SectionGuideButton` or from "?" →
+ * "อธิบายส่วนนี้ · <title>". Same switch and audience as page guides
+ * (`guides.<app>.pages` not off); one row per section guide per person,
+ * `<app>.section.<key>`, written once. Authors:
+ * _claude-work/guides-r4/GUIDE-PAGES.md §10.
+ */
+export interface GuideSection {
+    /** Stable, [a-z0-9-]: the row key is `${suite.app}.section.${key}` (≤ 64 characters). */
+    key: string;
+    version: number;
+    /** The page(s) the section is on, as GuidePage.route. */
+    route: string | string[];
+    /** The section's root: the guide is there only while it is on screen. */
+    anchor: GuideAnchorKey;
+    /** "สรุปกระแสเงินสด": the "?" entry and the bubble's heading. ≤ 40 characters. */
+    title: string;
+    /** Only `true` shows it (as GuideMission.visible). */
+    visible?: (ctx: GuideContext) => boolean | undefined;
+    /** A policy key the section needs (checked with `guides.can`). */
+    requires?: string;
+    /**
+     * "view" steps (the default here), about 12 at most; titles ≤ 40 and whys
+     * ≤ 90 characters (the app's tests check). Copy may be a function of
+     * `ctx.values`; list what it uses in `needs`, and a step whose value is
+     * missing is skipped (so is one whose title comes out empty).
+     */
+    steps: GuideStep[];
+}
 /** One app's whole tour: the welcome, the missions, the finish. */
 export interface GuideSuite {
     /** Progress key on the server, "<app>.<name>": "peoplx.first-run". */
@@ -423,6 +468,8 @@ export interface GuideSuite {
     missions: GuideMission[];
     /** Page guides ("คู่มือหน้านี้"), shell ≥ 0.1.74. */
     pages?: GuidePage[];
+    /** Section guides ("อธิบายส่วนนี้"), shell ≥ 0.1.75. */
+    sections?: GuideSection[];
 }
 /** AppLayoutShell's `guides` prop. */
 export interface GuideConfig {

package/dist/guide-core.cjs

@@ -1,7 +1,7 @@
 'use client';
 'use strict';
 
-var guideRuntime = require('./chunks/guide-runtime-YS2nUhwS.cjs');
+var format = require('./chunks/format-CVazK0hP.cjs');
 require('react/jsx-runtime');
 require('react');
 require('react-dom');
@@ -9,27 +9,35 @@ require('@floating-ui/dom');
 
 
 
-exports.GUIDE_API_EVENT = guideRuntime.API_EVENT;
-exports.GUIDE_EVENT_PREFIX = guideRuntime.GUIDE_EVENT_PREFIX;
-exports.GUIDE_LAYER_ATTRIBUTE = guideRuntime.GUIDE_LAYER_ATTRIBUTE;
-exports.GuideProgressConflict = guideRuntime.GuideProgressConflict;
-exports.GuideRuntime = guideRuntime.GuideRuntime;
-exports.apiCallDetail = guideRuntime.apiCallDetail;
-exports.emitGuideEvent = guideRuntime.emitGuideEvent;
-exports.fillRoute = guideRuntime.fillRoute;
-exports.guideAnchor = guideRuntime.guideAnchor;
-exports.guideMenuItems = guideRuntime.guideMenuItems;
-exports.guideMenuShown = guideRuntime.guideMenuShown;
-exports.loadGuides = guideRuntime.loadGuides;
-exports.matchApiPath = guideRuntime.matchApiPath;
-exports.matchRoute = guideRuntime.matchRoute;
-exports.openGuidePanel = guideRuntime.openGuidePanel;
-exports.openPageGuide = guideRuntime.openPageGuide;
-exports.openPagesPanel = guideRuntime.openPagesPanel;
-exports.reportApiCall = guideRuntime.reportApiCall;
-exports.reportApiEvent = guideRuntime.reportApiEvent;
-exports.storeGuides = guideRuntime.storeGuides;
-exports.useGuideEntry = guideRuntime.useGuideEntry;
-exports.usePageGuideEntry = guideRuntime.usePageGuideEntry;
-exports.usePageGuides = guideRuntime.usePageGuides;
+exports.GUIDE_API_EVENT = format.API_EVENT;
+exports.GUIDE_EVENT_PREFIX = format.GUIDE_EVENT_PREFIX;
+exports.GUIDE_LAYER_ATTRIBUTE = format.GUIDE_LAYER_ATTRIBUTE;
+exports.GuideProgressConflict = format.GuideProgressConflict;
+exports.GuideRuntime = format.GuideRuntime;
+exports.SectionGuideButton = format.SectionGuideButton;
+exports.THAI_MONTHS_SHORT = format.THAI_MONTHS_SHORT;
+exports.apiCallDetail = format.apiCallDetail;
+exports.emitGuideEvent = format.emitGuideEvent;
+exports.fillRoute = format.fillRoute;
+exports.formatBaht = format.formatBaht;
+exports.guideAnchor = format.guideAnchor;
+exports.guideMenuItems = format.guideMenuItems;
+exports.guideMenuShown = format.guideMenuShown;
+exports.loadGuides = format.loadGuides;
+exports.matchApiPath = format.matchApiPath;
+exports.matchRoute = format.matchRoute;
+exports.openGuidePanel = format.openGuidePanel;
+exports.openPageGuide = format.openPageGuide;
+exports.openPagesPanel = format.openPagesPanel;
+exports.openSectionGuide = format.openSectionGuide;
+exports.reportApiCall = format.reportApiCall;
+exports.reportApiEvent = format.reportApiEvent;
+exports.setSectionGuideValues = format.setSectionGuideValues;
+exports.storeGuides = format.storeGuides;
+exports.thaiMonth = format.thaiMonth;
+exports.thaiMonthYear = format.thaiMonthYear;
+exports.useGuideEntry = format.useGuideEntry;
+exports.usePageGuideEntry = format.usePageGuideEntry;
+exports.usePageGuides = format.usePageGuides;
+exports.useSectionGuideValues = format.useSectionGuideValues;
 //# sourceMappingURL=guide-core.cjs.map

package/dist/guide-core.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"guide-core.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"guide-core.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/guide-core.esm.js

@@ -1,5 +1,5 @@
 'use client';
-export { A as GUIDE_API_EVENT, G as GUIDE_EVENT_PREFIX, a as GUIDE_LAYER_ATTRIBUTE, c as GuideProgressConflict, d as GuideRuntime, e as apiCallDetail, f as emitGuideEvent, g as fillRoute, h as guideAnchor, i as guideMenuItems, j as guideMenuShown, l as loadGuides, m as matchApiPath, k as matchRoute, o as openGuidePanel, n as openPageGuide, p as openPagesPanel, r as reportApiCall, q as reportApiEvent, s as storeGuides, u as useGuideEntry, t as usePageGuideEntry, v as usePageGuides } from './chunks/guide-runtime-Dl8V1iy9.esm.js';
+export { A as GUIDE_API_EVENT, G as GUIDE_EVENT_PREFIX, a as GUIDE_LAYER_ATTRIBUTE, c as GuideProgressConflict, d as GuideRuntime, S as SectionGuideButton, T as THAI_MONTHS_SHORT, e as apiCallDetail, f as emitGuideEvent, g as fillRoute, h as formatBaht, i as guideAnchor, j as guideMenuItems, k as guideMenuShown, l as loadGuides, m as matchApiPath, n as matchRoute, o as openGuidePanel, p as openPageGuide, q as openPagesPanel, r as openSectionGuide, s as reportApiCall, t as reportApiEvent, u as setSectionGuideValues, v as storeGuides, w as thaiMonth, x as thaiMonthYear, y as useGuideEntry, z as usePageGuideEntry, B as usePageGuides, C as useSectionGuideValues } from './chunks/format-DCTuLpBU.esm.js';
 import 'react/jsx-runtime';
 import 'react';
 import 'react-dom';

package/dist/help/help-button.d.ts

@@ -6,7 +6,8 @@ export interface HelpButtonProps {
  * --header-* variables of the workspace chrome, white on the brand chrome).
  *
  * When this user has something to open here, it opens a small menu:
- * "คู่มือหน้านี้" (this page's guide), "ไกด์เริ่มต้น n/N" (the quest
+ * "คู่มือหน้านี้" (this page's guide), "อธิบายส่วนนี้ · <title>" for each
+ * section guide on screen, "ไกด์เริ่มต้น n/N" (the quest
  * panel), "คู่มือทุกหน้า" (the panel's page guides) and "ติดต่อทีมช่วยเหลือ"
  * (the help dialog), each only when it has something. Otherwise one press
  * opens the help dialog, as before.