@jtakeit/kit 0.5.1 → 0.6.0

package/README.md

@@ -31,7 +31,7 @@ shape, so the form says what it sends and the element sends nothing else.
 import { renderBookingForm } from '@jtakeit/kit/booking';
 
 const html = renderBookingForm({
-  services,                 // [{ slug, title, takes, costs, rates, group }], the entries with `takes`; `rates` instead of `costs` says «from …»
+  services,                 // [{ slug, title, takes, costs, rates, group }], the entries with `takes`; `rates` instead of `costs` says «from …»; `group` is a heading's words (a select's label, a category's title), and the services with none come after every heading
   resources,                // [{ slug, title }] — leave empty for a solo business
   locale: 'uk',             // uk, de or en: the words before the platform has spoken
   combine: settings.combine === true,   // jtk/bookings.json

package/elements/booking.js

@@ -636,6 +636,12 @@ export function wireBooking(form) {
         return;
       }
       hint.textContent = '';
+      // A price beside each time only where the times differ in price — a
+      // rate by the hour (wiki/68). Where every time costs the same, the
+      // price is the services' and is said beside them: «09:00 · CHF 95» on
+      // thirty pills is one number read thirty times (11 October 2026).
+      const slotPrices = new Set(data.slots.map((one) => one.costs_minor ?? 0));
+      const pricedByTime = slotPrices.size > 1;
       for (const slot of data.slots) {
         const button = document.createElement('button');
         button.type = 'button';
@@ -646,8 +652,8 @@ export function wireBooking(form) {
           ? slot.ends ? `${dayAndHour(slot.start, false)} — ${dayAndHour(slot.ends, false)}` : dayAndHour(slot.start, false)
           : clock(slot.start);
         // What the booking starting here costs — the platform's number, every
-        // hour by its own row (wiki/68) — beside the time, whenever one came.
-        if (slot.costs_minor > 0) button.textContent += ` · ${money(slot.costs_minor, currency, pageLang())}`;
+        // hour by its own row (wiki/68) — beside the time, where it varies.
+        if (pricedByTime && slot.costs_minor > 0) button.textContent += ` · ${money(slot.costs_minor, currency, pageLang())}`;
         button.dataset.start = slot.start;
         button.addEventListener('click', () => {
           chosen = slot.start;

package/lib/booking/render.mjs

@@ -48,7 +48,7 @@ export const SENDS = Object.freeze(['service', 'services', 'resource', 'class',
  * @property {number} [costs] minor units, for the same
  * @property {{ day: string, from: number, until: number, costs: number }[]} [rates] a price by the hour of the week instead of `costs`: the list says «from …», and the price is the slot's, printed beside the time
  * @property {string} [per]   `'person'` for a price times the party — a class per place, shoes; the list says so and the running total multiplies
- * @property {string} [group] a heading the services are listed under
+ * @property {string} [group] a heading the services are listed under — the words (an option's label, a category's title), not the stored value; services with none are listed after every heading
  * @property {string[]} [does] for a resource: the services they perform, by slug — the element greys the others out once they are chosen; empty or absent is everything
  */
 
@@ -123,6 +123,14 @@ export function renderBookingForm(props) {
     if (run) run.items.push(one);
     else runs.push({ group, items: [one] });
   }
+  // The services with no heading go after every run that has one, wherever
+  // the first of them came: drawn first, they read as the run above the first
+  // heading, and drawn between two they read as the one before. A group is
+  // the heading's words — an option's label, a category's title — never the
+  // stored value; the page that reads the catalogue resolves it (12 October
+  // 2026: the scaffold passed `entry.data.group` itself).
+  const loose = runs.findIndex((r) => r.group === '');
+  if (loose >= 0 && runs.length > 1) runs.push(...runs.splice(loose, 1));
 
   const today = now.toISOString().slice(0, 10);
   const last = new Date(now.getTime() + daysAhead * 86_400_000).toISOString().slice(0, 10);

package/lib/catalogue.mjs

@@ -51,6 +51,7 @@ import { dirname, join, relative, resolve, sep } from 'node:path';
 import { pathToFileURL } from 'node:url';
 
 import { E, isAdvice, isPlatformCode, LOCAL } from './codes.mjs';
+import { shownAt } from './schedule.mjs';
 
 // What this tool calls itself in a catalogue it writes. Bumped when the shape
 // it emits changes; the `contract` beside it moves only when the format does.
@@ -587,11 +588,49 @@ for (const collection of collections) {
     }
   }
 
+  /*
+   * What the entries are grouped by: a select, or a ref to another
+   * collection, and nothing else — the platform's validateEntryGroup, mirrored
+   * (12 October 2026, wiki/78). Free text would be a list of one-entry groups
+   * with three spellings of "manicure". A ref into the collection itself is a
+   * tree, which is a `parent` field and takes no part in grouping: an entry
+   * heading its own siblings is a listing nobody can order.
+   */
+  if (collection.group !== undefined && collection.group !== '') {
+    const groupWhere = `${where}.group`;
+    const by = field(collection.group);
+    if (by === undefined) {
+      fault(E.COLLECTION, groupWhere, `grouped by "${collection.group}", which ${collection.type} does not declare`);
+    } else if (by.kind === 'ref' && by.ref === collection.name) {
+      fault(E.COLLECTION, groupWhere, `grouped by ${collection.type}.${collection.group}, which points into "${collection.name}" itself — group by another collection, and make a tree with a parent field`);
+    } else if (by.kind !== 'select' && by.kind !== 'ref') {
+      fault(E.COLLECTION, groupWhere, `grouped by ${collection.type}.${collection.group}, which is "${by.kind}" — group by a select, or by a ref to another collection`);
+    }
+  }
+
   const perPage = collection.per_page ?? 0;
   if (!Number.isInteger(perPage) || perPage < 0 || perPage > 200) {
     fault(E.COLLECTION, where, 'per_page must be between 1 and 200, or absent for one page');
   }
 
+  /*
+   * A listing at the prefix, asked for (the platform's CollectionDef.Listing,
+   * 12 October 2026): the scaffold draws one only where a collection says
+   * `listing: true`, because a page nobody asked for is an address on a
+   * client's site nobody designed. Only for a collection whose entries have
+   * pages — one without is listed on its prefix's page already, which the
+   * repository writes.
+   */
+  if (collection.listing !== undefined && typeof collection.listing !== 'boolean') {
+    fault(E.COLLECTION, `${where}.listing`, `listing is ${JSON.stringify(collection.listing)} — true, or absent for no listing at the prefix`);
+  } else if (collection.listing === true && collection.pages === false) {
+    fault(
+      E.COLLECTION,
+      `${where}.listing`,
+      `collection "${collection.name}" has no pages of its own, so its prefix's page is the listing already — the repository writes it; \`listing\` is for a collection whose entries have pages`,
+    );
+  }
+
   /*
    * What a post may hold, and the one type it must.
    *
@@ -619,6 +658,30 @@ for (const collection of collections) {
   }
 }
 
+/*
+ * Every `ref`, wherever it is — a block's field, a row of a list, the page's
+ * SEO, the business facts — names a collection this catalogue declares. The
+ * platform's validateRefs, mirrored on 12 October 2026, when a ref became
+ * the way a site has categories and tags (wiki/78): `tags: list of { tag:
+ * ref tags }` with no `tags` collection is a field whose every value points
+ * nowhere, and the judge refused it while this said nothing.
+ */
+{
+  const names = new Set(collections.map((one) => one.name));
+  const walk = (where, fields) => {
+    for (const one of fields ?? []) {
+      const at = `${where}.${one.key}`;
+      if (one.kind === 'ref' && !names.has(one.ref)) {
+        fault(E.COLLECTION, `${at}.ref`, `${at} refers to collection ${JSON.stringify(one.ref ?? '')}, which this catalogue does not declare`);
+      }
+      walk(at, one.of);
+    }
+  };
+  catalogue.blocks.forEach((block, at) => walk(`blocks[${at}]`, block.fields));
+  walk('page_seo', catalogue.page_seo);
+  walk('business_facts', catalogue.business_facts);
+}
+
 /*
  * ── can the platform serve this at all ─────────────────────────────────────
  *
@@ -1346,6 +1409,21 @@ const sharedBlocks = existsSync(sharedFile)
 const byType = new Map(catalogue.blocks.map((block) => [block.type, block]));
 const disagreements = [];
 
+/*
+ * Which fields a page must carry a tap target for: the platform's own rule,
+ * `tappable()` in its sitebuild/annotation-lint.mjs, copied (12 October 2026).
+ *
+ * This used to ask it of every field but a bool or a `no_tap_target`, which
+ * is stricter than the judge in exactly the shapes wiki/78 made the way a
+ * site has categories and tags: a service's `category: ref categories`, a
+ * dish's `course` select, a work's `tags: [{ tag }]` were each reported as a
+ * control that edits nothing — they are edited in the panel beside the page,
+ * and the platform's build asks no element of them. A field outside the rule
+ * may still be annotated; it is accepted, never required.
+ */
+const TAPPABLE = new Set(['text', 'textarea', 'richtext_lite', 'markdown', 'media', 'money', 'duration']);
+const tappable = (field) => TAPPABLE.has(field.kind) && field.client_editable !== false && field.no_tap_target !== true;
+
 /** `/de/services/x` without its language: `/services/x`. The site's own language has no prefix. */
 function basePathOf(path, locales) {
   for (const locale of locales) {
@@ -1370,6 +1448,13 @@ for (const page of pages) {
       (c) => c.pages === false && (page.collection === c.name || bare.startsWith(`${c.prefix}/`)),
     );
     if (listedOnly) {
+      /*
+       * A hidden one is on no listing — `visible: false`, or a schedule not
+       * come or gone (schedule.mjs), which the platform writes `visible:
+       * false` before its build — and is owed nowhere, as the platform's
+       * lint says (`listable`). This asked it of a hidden one too.
+       */
+      if (!shownAt(page)) continue;
       /*
        * No page of its own, so its fields are annotated on the listing as
        * `page:<address>:<field>` — and the platform's lint fails a build
@@ -1389,7 +1474,7 @@ for (const page of pages) {
           const value = block[field.key];
           const empty = value === undefined || value === null || value === '' ||
             (Array.isArray(value) && value.length === 0);
-          if (empty || field.no_tap_target || field.kind === 'bool' || (field.kind === 'media' && field.multiple)) continue;
+          if (empty || !tappable(field) || (field.kind === 'media' && field.multiple)) continue;
           if (!everywhere.has(`page:${page.path}:blocks[${at}].${field.key}`)) {
             disagreements.push(
               `${page.path}: blocks[${at}].${field.key} is on no page — an entry without a page of its own is annotated on its listing as page:${page.path}:blocks[${at}].${field.key}`,
@@ -1419,6 +1504,12 @@ for (const page of pages) {
       if (empty || field.no_tap_target || field.kind === 'bool') continue;
 
       const path = `blocks[${at}].${field.key}`;
+      // Outside the platform's rule and not a list (whose rows are asked one
+      // by one below): accepted where it is annotated, asked for nowhere.
+      if (field.kind !== 'list' && !tappable(field)) {
+        onThePage.delete(path);
+        continue;
+      }
 
       /*
        * A gallery: one field, many pictures, and each picture is its own tap
@@ -1455,6 +1546,10 @@ for (const page of pages) {
           for (const sub of field.of ?? []) {
             if (sub.no_tap_target || !row[sub.key]) continue;
             const rowPath = `blocks[${at}].${field.key}[${i}].${sub.key}`;
+            if (!tappable(sub)) {
+              onThePage.delete(rowPath);
+              continue;
+            }
             if (!onThePage.has(rowPath)) {
               disagreements.push(`${rowPath} is declared and the page does not render it`);
             }

package/lib/content.mjs

@@ -10,6 +10,7 @@
  */
 import { readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
+import { shownAt } from './schedule.mjs';
 
 /** @param {string} path */
 async function readJSON(path) {
@@ -59,9 +60,10 @@ export function sharedLocaleOf(name) {
  * anyway with the site's facts left empty — the annotations do not depend on
  * them.
  * @param {string} root the site's root, holding `jtk/`
- * @param {{ dir?: string }} [options] `dir`: where `jtk/` is, relative to the root
+ * @param {{ dir?: string; now?: number }} [options] `dir`: where `jtk/` is, relative to the root; `now`: the clock a `show_at`/`hide_at` is read against
  */
 export async function collectContent(root, options = {}) {
+  const now = options.now ?? Date.now();
   const dir = join(root, options.dir ?? 'jtk');
   const site = (await readJSON(join(dir, 'site.json'))) ?? {};
   const pages = [];
@@ -72,7 +74,10 @@ export async function collectContent(root, options = {}) {
     const collected = { path: page.path, seo: page.seo ?? {}, blocks: page.blocks ?? [] };
     if (typeof page.collection === 'string' && page.collection !== '') {
       collected.collection = page.collection;
-      collected.visible = page.visible !== false;
+      // Hidden by `visible: false`, or by a schedule not come or gone
+      // (schedule.mjs) — read by the clock of this check, as the platform's
+      // build reads it by its own.
+      collected.visible = shownAt(page, now);
     }
     pages.push(collected);
   }

package/lib/kits.mjs

@@ -137,7 +137,11 @@ export function kitEntries(kit, locale) {
     const collection = kit.catalogue.collections.find((one) => one.name === entry.collection);
     const block = { _key: `kit${String(i + 1).padStart(5, '0')}`, type: collection.type, v: 1 };
     for (const [key, value] of Object.entries(entry.fields)) {
-      block[key] = value !== null && typeof value === 'object' ? (value[lang] ?? '') : value;
+      // An object is the words per language; a list — a master's `does`, a
+      // post's `tags: [{ tag }]` — is the value itself. It was read as a map
+      // of languages and laid out as '' (12 October 2026), which broke the
+      // listing that maps a resource's `does`.
+      block[key] = Array.isArray(value) ? value : value !== null && typeof value === 'object' ? (value[lang] ?? '') : value;
     }
     const path = `${collection.prefix}/${entry.slug}`;
     const doc = { path, collection: collection.name, visible: true, seo: { title: '', description: '' }, blocks: [block] };

package/lib/lint.mjs

@@ -301,6 +301,8 @@ export async function lint(options = {}) {
   // Entries of a collection without pages: on their listing, annotated there.
   const pageless = new Set((registry?.collections ?? []).filter((one) => one.pages === false).map((one) => one.name));
   const everywhere = [...htmlByPath.values()].join('\n');
+  // `visible` as collectContent read it: false for `visible: false` and for a
+  // schedule not come or gone (schedule.mjs) — a listing leaves both out.
   const listable = (page) => page.visible !== false;
   for (const one of registry?.collections ?? []) {
     if (one.pages !== false) continue;

package/lib/meta.mjs

@@ -34,6 +34,7 @@
  */
 import { readdir, readFile, writeFile } from 'node:fs/promises';
 import { join, relative, sep } from 'node:path';
+import { shownAt } from './schedule.mjs';
 
 /** The id of one specimen, which is also its address under the collection. */
 export function specimenId(type, view) {
@@ -76,12 +77,16 @@ export function specimenAddresses(collections, blocks, locales = []) {
  *
  * A document, not frontmatter: an entry is a page of blocks in a `.json`
  * file. Only an entry carries `visible` at all; a page has none and is not a
- * draft. `=== false` and not falsy: absent means listed.
+ * draft. `=== false` and not falsy: absent means listed — and so does a
+ * schedule that has come and not gone (`shownAt`, schedule.mjs): a `show_at`
+ * still ahead or a `hide_at` behind is a draft at the moment of the build,
+ * as it is on the platform, which writes it `visible: false` before building.
  *
  * @param {string} [root] where the content is, `jtk/content` under the working directory
+ * @param {number} [now] the clock a schedule is read against, the build's by default
  * @returns {Promise<string[]>}
  */
-export async function hiddenEntries(root = join(process.cwd(), 'jtk', 'content')) {
+export async function hiddenEntries(root = join(process.cwd(), 'jtk', 'content'), now = Date.now()) {
   const out = [];
   const walk = async (at) => {
     let entries;
@@ -104,7 +109,10 @@ export async function hiddenEntries(root = join(process.cwd(), 'jtk', 'content')
       } catch {
         continue; // unreadable JSON is the build's error to report, not this one
       }
-      if (document?.visible === false) {
+      // A schedule is an entry's (it names its collection); a page carries
+      // none, and `visible: false` is read wherever it is written, as before.
+      const isEntry = typeof document?.collection === 'string' && document.collection !== '';
+      if (document?.visible === false || (isEntry && !shownAt(document, now))) {
         const name = relative(root, full).split(sep).join('/').replace(/\.json$/, '');
         out.push(`/${name}/`);
       }

package/lib/schedule.mjs

@@ -0,0 +1,46 @@
+/**
+ * Whether an entry is out yet, and still out — the platform's scheduled
+ * publishing, read the way the platform reads it.
+ *
+ * An entry's file may carry `"show_at"` (hidden until then) and `"hide_at"`
+ * (hidden from then on), both RFC 3339 in UTC. A build the platform makes
+ * rewrites such an entry to `visible: false` in its checkout before the
+ * generator runs, so on the platform this changes nothing. On a laptop the
+ * files are read as they are, and every reader here that asks `visible` — the
+ * drafts in `_meta.json` (meta.mjs), the content the check reads (content.mjs,
+ * and so lint.mjs) — asks this instead, so a post scheduled for next week is a
+ * draft and not a listing's missing row.
+ *
+ * `visible: false` hides an entry whatever its dates say. A value that is not
+ * a time is no schedule: the platform refuses one where it is written, and a
+ * file edited by hand that says `"next week"` is shown rather than hidden for
+ * a reason nobody can see.
+ *
+ * The scaffold's entry loader asks the same question in
+ * `template/src/lib/schedule.ts` — a copy, not an import: a scaffold is built
+ * against the published kit, which may not have this file yet. The two are
+ * held to one answer by `test/schedule.test.mjs` at the repository's root.
+ */
+
+/**
+ * Whether the site lists the entry at `now` (milliseconds since the epoch).
+ * @param {{ visible?: boolean; show_at?: unknown; hide_at?: unknown } | null | undefined} document
+ * @param {number} [now]
+ * @returns {boolean}
+ */
+export function shownAt(document, now = Date.now()) {
+  if (document == null) return true;
+  if (document.visible === false) return false;
+  const show = instant(document.show_at);
+  if (show !== undefined && now < show) return false;
+  const hide = instant(document.hide_at);
+  if (hide !== undefined && now >= hide) return false;
+  return true;
+}
+
+/** A time written down, or `undefined` for none and for one that is not a time. */
+function instant(value) {
+  if (typeof value !== 'string' || value.trim() === '') return undefined;
+  const at = Date.parse(value);
+  return Number.isNaN(at) ? undefined : at;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jtakeit/kit",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "The framework-free half of a site on jtakeit: the booking form as an element and as markup, for Astro through @jtakeit/astro and for any other generator directly",
   "license": "MIT",
   "type": "module",

package/types/booking.d.ts

@@ -7,6 +7,7 @@ export interface Named {
   rates?: { day: string; from: number; until: number; costs: number }[];
   /** `'person'` for a price times the party — a class per place, shoes; the list says so and the running total multiplies. */
   per?: 'booking' | 'person';
+  /** The heading a service is listed under: the words — an option's label, a category's title — not the stored value. Services with none come after every heading. */
   group?: string;
   /** For a resource: the services they perform, by slug. The element greys the others out once they are chosen. */
   does?: string[];

package/types/content.d.ts

@@ -1,5 +1,5 @@
 /** The published content as one document, from the files in `jtk/` — what the build renders from. */
-export function collectContent(root: string, options?: { dir?: string }): Promise<{
+export function collectContent(root: string, options?: { dir?: string; now?: number }): Promise<{
   schema_version: number;
   content_rev: number;
   site: { slug: string; locale: string; media_base: string; business: Record<string, unknown> };

package/types/meta.d.ts

@@ -21,6 +21,6 @@ export function specimenAddresses(
   blocks: { type: string; views?: { key: string }[] }[],
   locales?: string[],
 ): string[];
-export function hiddenEntries(root?: string): Promise<string[]>;
+export function hiddenEntries(root?: string, now?: number): Promise<string[]>;
 export function buildMeta(what?: MetaInput): Promise<Meta>;
 export function writeMeta(dir: string, what?: MetaInput): Promise<Meta>;