@starci/hfs 4.11.22 → 4.12.0

package/scaffold/edition-gate.d.mts

@@ -0,0 +1,49 @@
+/** The refusal of a verb a non-full edition does not carry: printed verbatim by the CLI, exit 2, nothing written. */
+export declare class EditionRefusal extends Error {
+    constructor(command: string, message?: string);
+}
+/**
+ * The refusal of a pattern noun in a lite app whose topic carries a `liteAdapter` (ruling:R212/case-1, amended by ruling:R212/case-4)
+ * and no lite template in this package: lite has the pattern, but generating its full-adapter templates would write adapter paths
+ * unavailable in lite. The pattern is written by hand using the topic's declared lite adapter until the package carries a lite template.
+ */
+export declare class LiteAdapterRefusal extends EditionRefusal {
+    constructor(command: string, topics: readonly string[]);
+}
+/**
+ * Refuses `command` in a lite app when one of `topics` (pattern topic ids with their parsed documents) carries a `liteAdapter` and
+ * has no complete edition-specific file tree: neither a `liteFiles` list nor a place among `liteTemplated`, the topics whose lite
+ * templates the package carries.
+ */
+/** A pattern topic with its parsed document. */
+export interface PatternTopic {
+    readonly id: string;
+    readonly doc?: {
+        readonly liteAdapter?: unknown;
+        readonly liteFiles?: unknown;
+    } | null | undefined;
+}
+export declare function refuseFullAdapterInLite({ edition, topics, command, liteTemplated }: {
+    edition: string;
+    topics: readonly PatternTopic[];
+    command: string;
+    liteTemplated?: readonly string[];
+}): void;
+/**
+ * Refuses `command` (`add <noun>`, `new <noun>`) when one of `slotIds` - the slots the verb writes into - does not
+ * exist for the edition of `resolver`'s repository or is forbidden under it. `resolver` is the
+ * createSlotResolver() view of the app; every scope answers a slot id. Under full every verb slot exists and none is
+ * forbidden, so the gate never fires. A slot id the view does not answer (an `editions` exclusion, or an unknown id) refuses
+ * in every edition alike: the view cannot tell them apart, and the callers name only slots of the manifest.
+ */
+/** The createSlotResolver() view of an app, as far as the gate reads it. */
+export interface SlotResolverLike {
+    slot(id: string): {
+        readonly presence?: string;
+    } | null;
+}
+export declare function refuseInEdition({ resolver, slotIds, command }: {
+    resolver: SlotResolverLike;
+    slotIds: readonly string[];
+    command: string;
+}): void;

package/scaffold/edition-gate.mjs

@@ -1,48 +1,38 @@
-// The edition gate of `starci app add` and `starci app new` (design 8.6 R8): a verb whose file tree lands in a slot the app's
+// The edition gate of `starci app add` (design 8.6 R8): a verb whose file tree lands in a slot the app's
 // edition does not have - the slot's `editions` exclude it, or its `litePresence` is forbidden - is a full-edition
 // capability and refuses before anything is planned or written. The slot resolver of the app answers, the same
 // view `starci app check` reads; the noun's name is never the test, so a slot the lite manifest forbids refuses every
 // verb that writes into it, with no noun list kept anywhere. The refusal carries no failure code by design: the
 // scaffolders of packages/hfs keep their codes out of the runtime catalog (like HFS_SCAFFOLD_LOCK_FAILED).
-
 /** The refusal of a verb a non-full edition does not carry: printed verbatim by the CLI, exit 2, nothing written. */
 export class EditionRefusal extends Error {
-  constructor(command, message = `${command}: full edition only; editions are fixed at scaffold, a lite app stays lite`) {
-    super(message);
-    this.name = 'EditionRefusal';
-  }
+    constructor(command, message = `${command}: full edition only; editions are fixed at scaffold, a lite app stays lite`) {
+        super(message);
+        this.name = 'EditionRefusal';
+    }
 }
-
 /**
  * The refusal of a pattern noun in a lite app whose topic carries a `liteAdapter` (ruling:R212/case-1, amended by ruling:R212/case-4)
  * and no lite template in this package: lite has the pattern, but generating its full-adapter templates would write adapter paths
  * unavailable in lite. The pattern is written by hand using the topic's declared lite adapter until the package carries a lite template.
  */
 export class LiteAdapterRefusal extends EditionRefusal {
-  constructor(command, topics) {
-    super(command, `${command}: the package carries only the full adapter of ${topics.join(', ')}; in a lite app write it on its lite adapter (knowledge/patterns/be/${topics[0]}.yaml liteAdapter)`);
-    this.name = 'LiteAdapterRefusal';
-  }
+    constructor(command, topics) {
+        super(command, `${command}: the package carries only the full adapter of ${topics.join(', ')}; in a lite app write it on its lite adapter (knowledge/patterns/be/${topics[0]}.yaml liteAdapter)`);
+        this.name = 'LiteAdapterRefusal';
+    }
 }
-
-/**
- * Refuses `command` in a lite app when one of `topics` (pattern topic ids with their parsed documents) carries a `liteAdapter` and
- * has no complete edition-specific file tree: neither a `liteFiles` list nor a place among `liteTemplated`, the topics whose lite
- * templates the package carries.
- */
 export function refuseFullAdapterInLite({ edition, topics, command, liteTemplated = [] }) {
-  if (edition !== 'lite') return;
-  const adapted = topics.filter(({ id, doc }) => doc?.liteAdapter !== undefined && !liteTemplated.includes(id) && (!Array.isArray(doc.liteFiles) || doc.liteFiles.length === 0)).map(({ id }) => id).sort();
-  if (adapted.length) throw new LiteAdapterRefusal(command, adapted);
+    if (edition !== 'lite')
+        return;
+    const adapted = topics.filter(({ id, doc }) => doc?.liteAdapter !== undefined && !liteTemplated.includes(id) && (!Array.isArray(doc.liteFiles) || doc.liteFiles.length === 0)).map(({ id }) => id).sort();
+    if (adapted.length)
+        throw new LiteAdapterRefusal(command, adapted);
 }
-
-/**
- * Refuses `command` (`add <noun>`, `new <noun>`) when one of `slotIds` - the slots the verb writes into - does not
- * exist for the edition of `resolver`'s repository or is forbidden under it. `resolver` is the
- * createSlotResolver() view of the app; every scope answers a slot id. Under full every verb slot exists and none is
- * forbidden, so the gate never fires. A slot id the view does not answer (an `editions` exclusion, or an unknown id) refuses
- * in every edition alike: the view cannot tell them apart, and the callers name only slots of the manifest.
- */
 export function refuseInEdition({ resolver, slotIds, command }) {
-  if (slotIds.some((id) => resolver.slot(id) === null || resolver.slot(id).presence === 'forbidden')) throw new EditionRefusal(command);
+    if (slotIds.some((id) => {
+        const slot = resolver.slot(id);
+        return slot === null || slot.presence === 'forbidden';
+    }))
+        throw new EditionRefusal(command);
 }

package/scaffold/image.d.mts

@@ -0,0 +1,4 @@
+/** Writes the missing Dockerfiles of the app at `repoRoot` (the folder of hfs.json); the app-relative paths written. */
+export declare function newImages({ repoRoot }: {
+    repoRoot: string;
+}): string[];

package/scaffold/image.mjs

@@ -1,19 +1,19 @@
-// starci app new image - the Dockerfile of every declared app that has none, written from the image canon
+// starci app add image - the Dockerfile of every declared app that has none, written from the image canon
 // (templates/<side>/image/<kind>, the same render starci app scaffold uses). It never overwrites a file.
 import fs from 'node:fs';
 import path from 'node:path';
 import { appSource, imageFiles, loadHfs, validateHfs } from '../sync/index.mjs';
-
 /** Writes the missing Dockerfiles of the app at `repoRoot` (the folder of hfs.json); the app-relative paths written. */
 export function newImages({ repoRoot }) {
-  const files = imageFiles(validateHfs(loadHfs(repoRoot)), appSource(repoRoot));
-  const written = [];
-  for (const file of files) {
-    const target = path.join(repoRoot, ...file.path.split('/'));
-    if (fs.existsSync(target)) continue;
-    fs.mkdirSync(path.dirname(target), { recursive: true });
-    fs.writeFileSync(target, file.content);
-    written.push(file.path);
-  }
-  return written;
+    const files = imageFiles(validateHfs(loadHfs(repoRoot)), appSource(repoRoot));
+    const written = [];
+    for (const file of files) {
+        const target = path.join(repoRoot, ...file.path.split('/'));
+        if (fs.existsSync(target))
+            continue;
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, file.content);
+        written.push(file.path);
+    }
+    return written;
 }

package/scaffold/lite-exports.d.mts

@@ -0,0 +1,15 @@
+/** Every file below a folder (absolute paths); none when the folder is absent. */
+export declare const filesBelow: (folder: string) => string[];
+/** The app-relative barrels one generator's registrations edit (a caller snapshots them before registerLiteExports). */
+export declare const registrationFiles: (generator: string) => string[];
+/** Adds only the barrel exports first consumed by one generator; full webhooks share the same optional platform API. */
+export declare function registerLiteExports({ root, generator }: {
+    root: string;
+    generator: string;
+}): string[];
+/** Makes a domain service public only when a generated transport first imports its module barrel. */
+export declare function registerLiteDomainService({ root, moduleSpecifier, service }: {
+    root: string;
+    moduleSpecifier: string;
+    service: string;
+}): string | null;