rvlib-shipkit 2.2.0 → 2.3.0

package/src/serve/hub-runtime.ts

@@ -58,6 +58,7 @@ import { hubHandler, type CheckTap, type HubDeps, type HubHandler } from './serv
 import type { projectGutter } from './project-gutter-route.ts'
 import { defaultHubPort } from './hub-port.ts'
 import { LAYOUT } from '../core/layout.ts'
+import { storeDir, storeStamp } from '../review/store.ts'
 export { defaultHubPort }
 
 export type ServeIo = { print: (l: string) => void; printErr: (l: string) => void }
@@ -347,9 +348,10 @@ export async function resolveHubDeps(root: string, boot: RepoConfig, io: ServeIo
         graphs,
         studio,
         refresh,
-        // the config and the run record, by their stats: what the warm rows
-        // and the runs page read besides the tracked files the watch sees
-        stamp: () => `${configStamp(root)}|${record === '' ? '' : recordStamp(record)}`,
+        // the config, the run record and the review store (gitignored, its
+        // own watch counts its writes): what the warm rows and the runs page
+        // read besides the tracked files the watch sees
+        stamp: () => `${configStamp(root)}|${record === '' ? '' : recordStamp(record)}|${storeStamp(storeDir(root))}`,
         runCli,
         // the run happens IN THIS PROCESS, so every check result reaches the
         // page as it finishes. A shelled run could only ever deliver one wall

package/src/serve/same-origin.ts

@@ -10,5 +10,9 @@ export function sameOrigin(req: Request): boolean {
     if (site != null && site !== 'same-origin' && site !== 'none') return false
     const origin = req.headers.get('origin')
     if (origin == null) return true
-    try { return new URL(origin).host === new URL(req.url).host } catch { return false }
+    // behind a proxy that frames the page under its own origin (pkm-multi's admin), the host the browser asked is the
+    // proxy's, which it passes on. A browser cannot forge the header: a page of another site that sets it is held at
+    // its preflight, which this server never answers
+    const host = req.headers.get('x-forwarded-host') ?? new URL(req.url).host
+    try { return new URL(origin).host === host } catch { return false }
 }

package/src/serve/serve-hub.ts

@@ -32,6 +32,8 @@ import { sameOrigin } from './same-origin.ts'
 import { LAYOUT } from '../core/layout.ts'
 import { WarmCell } from './warm-cell.ts'
 import { readmeRoutes } from './readme-route.ts'
+import { reviewRoutes } from '../review/routes.ts'
+import { embedRoute } from './embed.ts'
 
 export { sameOrigin }
 
@@ -338,6 +340,12 @@ export function hubHandler(d: HubDeps, o: { base?: string; projects?: Gutter } =
             // the empty page shows the README, its images served from the repo
             const readme = await readmeRoutes(d.root, path)
             if (readme != null) return readme
+            // the review or trailer page alone, for another tool's frame (embed.ts)
+            const embed = await embedRoute(path)
+            if (embed != null) return embed
+            // the one feedback store and the trailer view (review/routes.ts)
+            const review = await reviewRoutes(d.root, req, path)
+            if (review != null) return review
             if (path === '/api/status.json') {
                 const p = join(d.root, LAYOUT.status)
                 return Response.json({ statusMd: existsSync(p) ? await Bun.file(p).text() : null })

package/src/shipkit-files.ts

@@ -8,15 +8,19 @@
 //                         on the home page
 //   trailer({...})        what `sk trailer` cannot read from a file: the
 //                         sounds the repo resolves by id (trailer/adapter.ts)
+//   review({...})         the repo's parts of the review store: its subject
+//                         kinds, topics, sources, auto rules, the dispatcher
+//                         (review/unit.ts)
 //
 // the one constraint a reader breaks first: every kind is IMPORTED by the
 // process that reads it (discovery, pm's config child, the daemon), so a file
 // keeps its top level cheap and puts heavy work inside a function.
 import { check, type CheckDef } from './check.ts'
+import { review, type AutoRule, type KindDef, type ReviewDef, type ReviewSource, type ReviewUnit } from './review/unit.ts'
 import { trailer, type TrailerDef, type TrailerUnit } from './trailer/adapter.ts'
 
-export { check, trailer }
-export type { TrailerDef, TrailerUnit }
+export { check, review, trailer }
+export type { AutoRule, KindDef, ReviewDef, ReviewSource, ReviewUnit, TrailerDef, TrailerUnit }
 
 /** one button beside a global process: a command, or a function of the file */
 export type ProcessAction = {
@@ -73,7 +77,7 @@ export type WidgetDef = {
 export type GlobalProcessUnit = GlobalProcessDef & { kind: 'globalProcess' }
 export type WidgetUnit = WidgetDef & { kind: 'widget' }
 
-export const UNIT_KINDS = ['globalProcess', 'widget', 'trailer'] as const
+export const UNIT_KINDS = ['globalProcess', 'widget', 'trailer', 'review'] as const
 
 const KEBAB = /^[a-z0-9][a-z0-9-]*$/
 const words = (v: unknown): boolean => Array.isArray(v) && v.length > 0 && v.every((w) => typeof w === 'string')
@@ -127,9 +131,9 @@ export function widget(d: WidgetDef): WidgetUnit {
 }
 
 /** the kind a default export says it is: a unit, else a check */
-export function unitKind(d: unknown): 'globalProcess' | 'widget' | 'trailer' | 'check' {
+export function unitKind(d: unknown): (typeof UNIT_KINDS)[number] | 'check' {
     const k = (d as { kind?: unknown } | null)?.kind
-    return k === 'globalProcess' || k === 'widget' || k === 'trailer' ? k : 'check'
+    return UNIT_KINDS.includes(k as (typeof UNIT_KINDS)[number]) ? (k as (typeof UNIT_KINDS)[number]) : 'check'
 }
 
 export type { CheckDef }

package/src/trailer/adapter.ts

@@ -1,6 +1,9 @@
-// what a repo adds to the trailer core, all optional. Filming is never here: a film line calls the project CLI's
-// film rows (vocab.ts). A `trailer({...})` unit in any `<name>.shipkit.ts` resolves the sounds that are not files.
-// Discovered like every unit file (load-unit.ts), and read only when a cut names such a sound
+// what a repo adds to the trailer core, all optional (wiki build/trailer.md, The trailer unit). Filming is never here:
+// a film line calls the project CLI's film rows (vocab.ts). A `trailer({...})` unit in any `<name>.shipkit.ts`
+// resolves the sounds that are not files, names the paths a take's world is, checks the content the language cannot
+// know, refines one film line's take, and turns on the guards that read the repo's own words. Discovered like every
+// unit file (load-unit.ts)
+import type { TakeLength } from './grammar.ts'
 
 export interface TrailerSounds {
     /** a music id to an audio file of at least `seconds`, cached by the repo */
@@ -11,13 +14,65 @@ export interface TrailerSounds {
     voice?(text: string): Promise<string>
 }
 
+/** a film line of the project CLI as the unit sees it: its words as written, the text of each `@<file>` word */
+export interface TrailerFilmLine {
+    line: number
+    /** the shot or footage block it films */
+    shot: string
+    argv: string[]
+    output: 'still' | 'clip'
+    files: Record<string, string>
+}
+
+/** what `check` reads: the cut's film lines and the sounds it names by id */
+export interface TrailerCheckInput {
+    file: string
+    dir: string
+    size: [number, number]
+    fps: number
+    films: TrailerFilmLine[]
+    /** each music cue that names an id; `opening`: the header's, the one the cut starts on */
+    music: { line: number; id: string; take?: string; from: number; opening: boolean }[]
+    sfx: { line: number; id: string }[]
+    voices: { line: number; text: string }[]
+}
+
+/** an error at its line; `warn`: said, never blocking */
+export interface TrailerFinding {
+    line: number
+    message: string
+    warn?: true
+}
+
+/** one film line's take over its row's defaults: its version, how long it films, a fixed world, what its key reads */
+export interface TakeAnswer {
+    version?: number | string
+    length?: TakeLength
+    /** the take's world for good (`rev:<commit>`): never stale */
+    world?: string
+    /** what the key reads instead of the words */
+    recipe?: unknown
+}
+
 export interface TrailerDef {
     sound?: TrailerSounds
+    /** the paths a take's world is (`['src', 'public']`); default the whole tree, trailer/ and .shipkit/ left out */
+    stamp?: string[]
+    /** in process, before filming, in a few ms: the content the language cannot know */
+    check?(c: TrailerCheckInput): TrailerFinding[] | Promise<TrailerFinding[]>
+    /** one film line's take, when its words change what its row says */
+    take?(f: TrailerFilmLine & { version: number | string | null; length: TakeLength }): TakeAnswer | undefined
+    /** the `states` a film prints: parts a cut may land on (`ignore`), parts a shot never opens or ends on (`underWay`) */
+    states?: { ignore?: string[]; underWay?: string[] }
+    /** a clip take that drops its picture for a few frames is filmed again once, then refused (holes.ts) */
+    holes?: boolean
 }
 
 export type TrailerUnit = TrailerDef & { kind: 'trailer' }
 
 export function trailer(d: TrailerDef): TrailerUnit {
     for (const [k, f] of Object.entries(d.sound ?? {})) if (typeof f !== 'function') throw new Error(`trailer: sound.${k} is a function returning an audio file`)
+    for (const k of ['check', 'take'] as const) if (d[k] !== undefined && typeof d[k] !== 'function') throw new Error(`trailer: ${k} is a function`)
+    if (d.stamp !== undefined && (!Array.isArray(d.stamp) || d.stamp.some((p) => typeof p !== 'string' || p === '' || p.startsWith('/')))) throw new Error('trailer: stamp is a list of repo relative paths')
     return { ...d, kind: 'trailer' }
 }