@intentius/chant-lexicon-forgejo 0.124.13 → 0.124.15

package/dist/components/ci-jobs.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The Forgejo dialect of the three generated pipelines (#3765). Each forgejo
+ * generator builds github's document and hands it here: action refs and
+ * runner labels rewritten ({@link transformWorkflowObject}), `permissions:`
+ * dropped (the runner reads none), and a job's `environment:` dropped with a
+ * header note naming it, since Forgejo Actions has no environments.
+ */
+import type { GithubOpPipelineDoc } from "@intentius/chant-lexicon-github/components/generate-op-pipeline";
+import { type ForgejoDialectOptions } from "../dialect.js";
+/** Apply the Forgejo dialect to one section of a pipeline doc. */
+export declare function forgejoize(value: Record<string, unknown>, dialect: ForgejoDialectOptions): Record<string, unknown>;
+/**
+ * Strip each job's `environment:` (#2257). Forgejo Actions has no
+ * environments, so the key would read as a deployment gate and hold nothing
+ * back. Dropped here rather than in the dialect's own `DROPPED_KEYS`, so it
+ * touches the generated pipelines alone and leaves every other document the
+ * dialect transforms as it is.
+ */
+export declare function withoutEnvironment(jobsDoc: Record<string, unknown>): Record<string, unknown>;
+/** The header of an Op's workflow whose environment gate did not survive the crossing. */
+export declare function droppedEnvironmentHeader(environmentName: string): string[];
+/** The header of an Op waves workflow, naming each wave whose environment was dropped as `wave -> environment`. */
+export declare function droppedWaveEnvironmentsHeader(dropped: readonly string[]): string[];
+/**
+ * The token a Forgejo job uses for what the job token cannot do, such as
+ * dispatching a workflow: the `CHANT_FORGE_TOKEN` secret, a token with the
+ * `write:repository` scope.
+ */
+export declare const FORGE_TOKEN_ENV: {
+    CHANT_FORGE_TOKEN: string;
+};
+/**
+ * A github workflow document under the Forgejo dialect: every section
+ * transformed, each job's `environment:` dropped, `permissions:` emptied, and
+ * `header` above it when given.
+ */
+export declare function forgejoWorkflowDoc(doc: GithubOpPipelineDoc, dialect: ForgejoDialectOptions, header?: string[]): GithubOpPipelineDoc;
+//# sourceMappingURL=ci-jobs.d.ts.map

package/dist/components/ci-jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ci-jobs.d.ts","sourceRoot":"","sources":["../../src/components/ci-jobs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iEAAiE,CAAC;AAC3G,OAAO,EAA2B,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAEjF,kEAAkE;AAClE,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAElH;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQ5F;AAED,0FAA0F;AAC1F,wBAAgB,wBAAwB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ1E;AAED,mHAAmH;AACnH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAOlF;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe;IAAK,iBAAiB;CAAqC,CAAC;AAExF;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,mBAAmB,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,mBAAmB,CAYnI"}

package/dist/components/generate-op-pipeline.d.ts

@@ -86,7 +86,7 @@
  * sibling Op's job receives.
  */
 import type { ComponentPipelineOptions, OpPipelineResult, ScheduledOpSpec } from "@intentius/chant/lexicon";
-import { type ForgejoDialectOptions } from "../dialect.js";
+import type { ForgejoDialectOptions } from "../dialect.js";
 /**
  * Synthesize one `.forgejo/workflows/*.yml` per scheduled Op. Reuses github's
  * trigger/job structure ({@link buildGithubOpPipelineDocs}) — its `setup`-step

package/dist/components/generate-op-pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-op-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-op-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AAOH,OAAO,KAAK,EACV,wBAAwB,EACxB,gBAAgB,EAChB,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAA2B,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAmCjF;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,eAAe,EAAE,EACtB,OAAO,GAAE,wBAA6B,EACtC,cAAc,GAAE,qBAA0B,GACzC,gBAAgB,CA6BlB"}
+{"version":3,"file":"generate-op-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-op-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AAMH,OAAO,KAAK,EACV,wBAAwB,EACxB,gBAAgB,EAChB,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGxD;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,eAAe,EAAE,EACtB,OAAO,GAAE,wBAA6B,EACtC,cAAc,GAAE,qBAA0B,GACzC,gBAAgB,CAmBlB"}

package/dist/components/generate-op-waves-pipeline.d.ts

@@ -17,7 +17,7 @@
  */
 import type { OpWavesSpec } from "@intentius/chant/op/op-waves";
 import type { OpWavesPipelineOptions, OpWavesPipelineResult } from "@intentius/chant/lexicon";
-import { type ForgejoDialectOptions } from "../dialect.js";
+import type { ForgejoDialectOptions } from "../dialect.js";
 /** Render an Op waves spec as one Forgejo Actions workflow, `<name>.yml`. */
 export declare function generateForgejoOpWavesPipeline(spec: OpWavesSpec, options: OpWavesPipelineOptions, dialectOptions?: ForgejoDialectOptions): OpWavesPipelineResult;
 //# sourceMappingURL=generate-op-waves-pipeline.d.ts.map

package/dist/components/generate-op-waves-pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-op-waves-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-op-waves-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAC9F,OAAO,EAA2B,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAMjF,6EAA6E;AAC7E,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,sBAAsB,EAC/B,cAAc,GAAE,qBAA0B,GACzC,qBAAqB,CA0DvB"}
+{"version":3,"file":"generate-op-waves-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-op-waves-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAC9F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGxD,6EAA6E;AAC7E,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,sBAAsB,EAC/B,cAAc,GAAE,qBAA0B,GACzC,qBAAqB,CAgBvB"}

package/dist/components/generate-pipeline.d.ts

@@ -25,7 +25,7 @@
  */
 import type { DriverComponent } from "@intentius/chant/components/driver";
 import type { ComponentPipelineOptions, ComponentPipelineResult } from "@intentius/chant/lexicon";
-import { type ForgejoDialectOptions } from "../dialect.js";
+import type { ForgejoDialectOptions } from "../dialect.js";
 /**
  * Synthesize a `.forgejo/workflows/*.yml` pipeline from a set of components.
  * Reuses github's job/`needs:`/artifact structure ({@link buildGithubPipelineDoc}),

package/dist/components/generate-pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAOH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EACV,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAA2B,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAOjF;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,eAAe,EAAE,EAC7B,OAAO,GAAE,wBAA6B,EACtC,cAAc,GAAE,qBAA0B,GACzC,uBAAuB,CAsBzB"}
+{"version":3,"file":"generate-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAOH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EACV,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGxD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,eAAe,EAAE,EAC7B,OAAO,GAAE,wBAA6B,EACtC,cAAc,GAAE,qBAA0B,GACzC,uBAAuB,CAsBzB"}

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "d8319d0917ce1f80b9eb35bc5141f99b2ef6d6be4f473df11dae4f103c956b6f",
+    "manifest.json": "ee4a8346762f955023d0dec3fd0db793b88d4a9a47f8343fd70d671bc747261e",
     "meta.json": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a",
     "types/index.d.ts": "66204549b2a864ab5489e3f02c1878e73ab4b3c9d938cfb480b66f71543a43de",
     "rules/delegate-to-github.ts": "1060cda40f4b73d6cca3ba3fa13b80b4886147d4034c88584c2d80c5510dbe5e",
@@ -9,5 +9,5 @@
     "rules/wfj011.ts": "fcb8bf6685d744af20ad804ce929488257995c74b9a3353b2eacae3768d1c83e",
     "skills/chant-forgejo.md": "f28d7fb69fb1cfd992496ef41fda0ea5ccd54a29b84ea1c501a44f6a3992c4d5"
   },
-  "composite": "4488f3b6018bfd9aff8fa6a9d36832a5a9137f58413efac2ff2a026465f5fd48"
+  "composite": "571a078b5d84f95c5d8c19aabee54d82895f4e1fd01f9eec855a0b84b7971bb6"
 }

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "forgejo",
-  "version": "0.124.13",
+  "version": "0.124.15",
   "chantVersion": ">=0.1.0",
   "namespace": "Forgejo",
   "intrinsics": [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-forgejo",
-  "version": "0.124.13",
+  "version": "0.124.15",
   "description": "Forgejo / Codeberg / Gitea Actions lexicon for chant — a thin GitHub Actions dialect",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -54,8 +54,8 @@
   },
   "peerDependencies": {
     "zod": "^4.3.6",
-    "@intentius/chant": "^0.124.13",
-    "@intentius/chant-lexicon-github": "^0.124.13"
+    "@intentius/chant": "^0.124.15",
+    "@intentius/chant-lexicon-github": "^0.124.15"
   },
   "scripts": {
     "generate": "tsx src/codegen/generate-cli.ts",

package/src/components/ci-jobs.ts

@@ -0,0 +1,80 @@
+/**
+ * The Forgejo dialect of the three generated pipelines (#3765). Each forgejo
+ * generator builds github's document and hands it here: action refs and
+ * runner labels rewritten ({@link transformWorkflowObject}), `permissions:`
+ * dropped (the runner reads none), and a job's `environment:` dropped with a
+ * header note naming it, since Forgejo Actions has no environments.
+ */
+
+import { githubSecret } from "@intentius/chant/ci-jobs";
+import type { GithubOpPipelineDoc } from "@intentius/chant-lexicon-github/components/generate-op-pipeline";
+import { transformWorkflowObject, type ForgejoDialectOptions } from "../dialect";
+
+/** Apply the Forgejo dialect to one section of a pipeline doc. */
+export function forgejoize(value: Record<string, unknown>, dialect: ForgejoDialectOptions): Record<string, unknown> {
+  return transformWorkflowObject(value, dialect).value as Record<string, unknown>;
+}
+
+/**
+ * Strip each job's `environment:` (#2257). Forgejo Actions has no
+ * environments, so the key would read as a deployment gate and hold nothing
+ * back. Dropped here rather than in the dialect's own `DROPPED_KEYS`, so it
+ * touches the generated pipelines alone and leaves every other document the
+ * dialect transforms as it is.
+ */
+export function withoutEnvironment(jobsDoc: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(jobsDoc).map(([jobName, job]) => {
+      if (typeof job !== "object" || job === null || !("environment" in job)) return [jobName, job];
+      const { environment: _dropped, ...rest } = job as Record<string, unknown>;
+      return [jobName, rest];
+    }),
+  );
+}
+
+/** The header of an Op's workflow whose environment gate did not survive the crossing. */
+export function droppedEnvironmentHeader(environmentName: string): string[] {
+  return [
+    `# chant dropped \`environment: ${environmentName}\` from this workflow: Forgejo Actions has no`,
+    "# environments, so there is no protection rule, required reviewer or wait timer for the key to",
+    "# name. This job is not held back by anything on the forge. What still stops the apply is chant's",
+    "# own gate: the run records a pending fact on the chant/lifecycle branch and ends, and `chant",
+    "# approve <op> <gate>` is what lets the next run through.",
+  ];
+}
+
+/** The header of an Op waves workflow, naming each wave whose environment was dropped as `wave -> environment`. */
+export function droppedWaveEnvironmentsHeader(dropped: readonly string[]): string[] {
+  return [
+    `# chant dropped the environment of each of these waves: ${dropped.join(", ")}.`,
+    "# Forgejo Actions has no environments, so nothing on the forge holds these jobs.",
+    "# Each wave's own chant gate does: it records a pending fact on chant/lifecycle",
+    "# and the wave exits 3 until `chant approve` approves its set digest.",
+  ];
+}
+
+/**
+ * The token a Forgejo job uses for what the job token cannot do, such as
+ * dispatching a workflow: the `CHANT_FORGE_TOKEN` secret, a token with the
+ * `write:repository` scope.
+ */
+export const FORGE_TOKEN_ENV = { CHANT_FORGE_TOKEN: githubSecret("CHANT_FORGE_TOKEN") };
+
+/**
+ * A github workflow document under the Forgejo dialect: every section
+ * transformed, each job's `environment:` dropped, `permissions:` emptied, and
+ * `header` above it when given.
+ */
+export function forgejoWorkflowDoc(doc: GithubOpPipelineDoc, dialect: ForgejoDialectOptions, header?: string[]): GithubOpPipelineDoc {
+  return {
+    ...(header ? { header } : {}),
+    // Forgejo Actions reads `name:` as GitHub does (#2601).
+    ...(doc.name ? { name: doc.name } : {}),
+    on: forgejoize(doc.on, dialect),
+    ...(doc.env ? { env: forgejoize(doc.env, dialect) } : {}),
+    concurrency: forgejoize(doc.concurrency, dialect),
+    permissions: {},
+    jobsDoc: forgejoize(withoutEnvironment(doc.jobsDoc), dialect),
+    ...(doc.gatedNoticeDoc ? { gatedNoticeDoc: forgejoize(doc.gatedNoticeDoc, dialect) } : {}),
+  };
+}

package/src/components/generate-op-pipeline.ts

@@ -89,47 +89,14 @@
 import {
   buildGithubOpPipelineDocs,
   emitOpPipelineYAML,
-  type GithubOpPipelineDoc,
 } from "@intentius/chant-lexicon-github/components/generate-op-pipeline";
 import type {
   ComponentPipelineOptions,
   OpPipelineResult,
   ScheduledOpSpec,
 } from "@intentius/chant/lexicon";
-import { transformWorkflowObject, type ForgejoDialectOptions } from "../dialect";
-
-/** Apply the Forgejo dialect to one section of a pipeline doc. */
-function forgejoize(value: Record<string, unknown>, dialect: ForgejoDialectOptions): Record<string, unknown> {
-  return transformWorkflowObject(value, dialect).value as Record<string, unknown>;
-}
-
-/**
- * Strip the job-level `environment:` github emitted (#2257). Forgejo Actions
- * has no environments, so the key would read as a deployment gate and hold
- * nothing back. Dropped from the rebuilt doc rather than from the dialect's
- * own `DROPPED_KEYS`, so this touches the Op generator alone and leaves every
- * other document the dialect transforms exactly as it emits today.
- */
-function withoutEnvironment(jobsDoc: Record<string, unknown>): Record<string, unknown> {
-  return Object.fromEntries(
-    Object.entries(jobsDoc).map(([jobName, job]) => {
-      if (typeof job !== "object" || job === null || !("environment" in job)) return [jobName, job];
-      const { environment: _dropped, ...rest } = job as Record<string, unknown>;
-      return [jobName, rest];
-    }),
-  );
-}
-
-/** Say in the generated file which environment gate did not survive the crossing. */
-function droppedEnvironmentHeader(environmentName: string): string[] {
-  return [
-    `# chant dropped \`environment: ${environmentName}\` from this workflow: Forgejo Actions has no`,
-    "# environments, so there is no protection rule, required reviewer or wait timer for the key to",
-    "# name. This job is not held back by anything on the forge. What still stops the apply is chant's",
-    "# own gate: the run records a pending fact on the chant/lifecycle branch and ends, and `chant",
-    "# approve <op> <gate>` is what lets the next run through.",
-  ];
-}
+import type { ForgejoDialectOptions } from "../dialect";
+import { droppedEnvironmentHeader, forgejoWorkflowDoc } from "./ci-jobs";
 
 /**
  * Synthesize one `.forgejo/workflows/*.yml` per scheduled Op. Reuses github's
@@ -156,20 +123,10 @@ export function generateForgejoOpPipeline(
     // read its Op's own `environment` off the input by position.
     files: files.map(({ name, doc }, index) => {
       const environment = ops[index].environment;
-      const forgejoDoc: GithubOpPipelineDoc = {
-        ...(environment ? { header: droppedEnvironmentHeader(environment.name) } : {}),
-        // Forgejo Actions reads `name:` as GitHub does (#2601), so the Op's
-        // name carries over and the Actions list shows it instead of the path.
-        ...(doc.name ? { name: doc.name } : {}),
-        on: forgejoize(doc.on, dialectOptions),
-        ...(doc.env ? { env: forgejoize(doc.env, dialectOptions) } : {}),
-        concurrency: forgejoize(doc.concurrency, dialectOptions),
-        permissions: {},
-        jobsDoc: forgejoize(withoutEnvironment(doc.jobsDoc), dialectOptions),
-        // The gate-notice job (#3773), dialect applied like the Op's own job.
-        ...(doc.gatedNoticeDoc ? { gatedNoticeDoc: forgejoize(doc.gatedNoticeDoc, dialectOptions) } : {}),
-      };
-      return { name, yaml: emitOpPipelineYAML(forgejoDoc) };
+      // The Op's name carries over, and the gate-notice job (#3773) takes the
+      // dialect like the Op's own job.
+      const header = environment ? droppedEnvironmentHeader(environment.name) : undefined;
+      return { name, yaml: emitOpPipelineYAML(forgejoWorkflowDoc(doc, dialectOptions, header)) };
     }),
     jobs,
   };

package/src/components/generate-op-waves-pipeline.ts

@@ -17,14 +17,11 @@
  */
 
 import { buildGithubOpWavesDoc } from "@intentius/chant-lexicon-github/components/generate-op-waves-pipeline";
-import { emitOpPipelineYAML, type GithubOpPipelineDoc } from "@intentius/chant-lexicon-github/components/generate-op-pipeline";
+import { emitOpPipelineYAML } from "@intentius/chant-lexicon-github/components/generate-op-pipeline";
 import type { OpWavesSpec } from "@intentius/chant/op/op-waves";
 import type { OpWavesPipelineOptions, OpWavesPipelineResult } from "@intentius/chant/lexicon";
-import { transformWorkflowObject, type ForgejoDialectOptions } from "../dialect";
-
-function forgejoize(value: Record<string, unknown>, dialect: ForgejoDialectOptions): Record<string, unknown> {
-  return transformWorkflowObject(value, dialect).value as Record<string, unknown>;
-}
+import type { ForgejoDialectOptions } from "../dialect";
+import { droppedWaveEnvironmentsHeader, FORGE_TOKEN_ENV, forgejoWorkflowDoc } from "./ci-jobs";
 
 /** Render an Op waves spec as one Forgejo Actions workflow, `<name>.yml`. */
 export function generateForgejoOpWavesPipeline(
@@ -33,60 +30,18 @@ export function generateForgejoOpWavesPipeline(
   dialectOptions: ForgejoDialectOptions = {},
 ): OpWavesPipelineResult {
   const { doc, jobs, resumeDoc, plansDoc } = buildGithubOpWavesDoc(spec, options);
-  const jobsDoc = Object.fromEntries(
-    Object.entries(doc.jobsDoc).map(([name, job]) => {
-      const { environment: _dropped, ...rest } = job as Record<string, unknown>;
-      return [name, rest];
-    }),
-  );
   const dropped = spec.waves.filter((w) => w.environment).map((w) => `${w.name} -> ${w.environment!.name}`);
-  const forgejoDoc: GithubOpPipelineDoc = {
-    ...(dropped.length > 0
-      ? {
-          header: [
-            `# chant dropped the environment of each of these waves: ${dropped.join(", ")}.`,
-            "# Forgejo Actions has no environments, so nothing on the forge holds these jobs.",
-            "# Each wave's own chant gate does: it records a pending fact on chant/lifecycle",
-            "# and the wave exits 3 until `chant approve` approves its set digest.",
-          ],
-        }
-      : {}),
-    name: doc.name,
-    on: forgejoize(doc.on, dialectOptions),
-    ...(doc.env ? { env: forgejoize(doc.env, dialectOptions) } : {}),
-    concurrency: forgejoize(doc.concurrency, dialectOptions),
-    permissions: {},
-    jobsDoc: forgejoize(jobsDoc, dialectOptions),
-  };
-  const files = [{ name: `${spec.name}.yml`, yaml: emitOpPipelineYAML(forgejoDoc) }];
+  const header = dropped.length > 0 ? droppedWaveEnvironmentsHeader(dropped) : undefined;
+  const files = [{ name: `${spec.name}.yml`, yaml: emitOpPipelineYAML(forgejoWorkflowDoc(doc, dialectOptions, header)) }];
   if (resumeDoc) {
-    const resumeJobs = forgejoize(resumeDoc.jobsDoc, dialectOptions) as Record<string, { steps: Array<Record<string, unknown>> }>;
-    for (const job of Object.values(resumeJobs)) {
-      for (const step of job.steps) if (step.env) step.env = { CHANT_FORGE_TOKEN: "${{ secrets.CHANT_FORGE_TOKEN }}" };
+    // Forgejo has no API to re-run a run, so resume dispatches the workflow
+    // again, with a token that may.
+    const resume = forgejoWorkflowDoc(resumeDoc, dialectOptions);
+    for (const job of Object.values(resume.jobsDoc) as Array<{ steps: Array<Record<string, unknown>> }>) {
+      for (const step of job.steps) if (step.env) step.env = { ...FORGE_TOKEN_ENV };
     }
-    files.push({
-      name: `${spec.name}-resume.yml`,
-      yaml: emitOpPipelineYAML({
-        name: resumeDoc.name!,
-        on: forgejoize(resumeDoc.on, dialectOptions),
-        concurrency: forgejoize(resumeDoc.concurrency, dialectOptions),
-        permissions: {},
-        jobsDoc: resumeJobs,
-      }),
-    });
-  }
-  if (plansDoc) {
-    files.push({
-      name: `${spec.name}-plans.yml`,
-      yaml: emitOpPipelineYAML({
-        name: plansDoc.name!,
-        on: forgejoize(plansDoc.on, dialectOptions),
-        ...(plansDoc.env ? { env: forgejoize(plansDoc.env, dialectOptions) } : {}),
-        concurrency: forgejoize(plansDoc.concurrency, dialectOptions),
-        permissions: {},
-        jobsDoc: forgejoize(plansDoc.jobsDoc, dialectOptions),
-      }),
-    });
+    files.push({ name: `${spec.name}-resume.yml`, yaml: emitOpPipelineYAML(resume) });
   }
+  if (plansDoc) files.push({ name: `${spec.name}-plans.yml`, yaml: emitOpPipelineYAML(forgejoWorkflowDoc(plansDoc, dialectOptions)) });
   return { files, jobs };
 }

package/src/components/generate-pipeline.ts

@@ -34,12 +34,8 @@ import type {
   ComponentPipelineOptions,
   ComponentPipelineResult,
 } from "@intentius/chant/lexicon";
-import { transformWorkflowObject, type ForgejoDialectOptions } from "../dialect";
-
-/** Apply the Forgejo dialect to one section of the pipeline doc. */
-function forgejoize(value: Record<string, unknown>, dialect: ForgejoDialectOptions): Record<string, unknown> {
-  return transformWorkflowObject(value, dialect).value as Record<string, unknown>;
-}
+import type { ForgejoDialectOptions } from "../dialect";
+import { forgejoize } from "./ci-jobs";
 
 /**
  * Synthesize a `.forgejo/workflows/*.yml` pipeline from a set of components.