@junoflow/cli 0.1.0 → 0.1.1

package/README.md

@@ -5,7 +5,7 @@ project, generate types from your manifest, check it, and deploy it.
 
 ```bash
 npm install --save-dev @junoflow/cli
-npx juno init my-integration
+npx juno init my-integration --url http://juno.local:8080
 ```
 
 An integration is a git repository holding `manifest.json` and TypeScript. Juno
@@ -16,9 +16,10 @@ packaging format and nothing is published to npm.
 
 | Command                 | What it does                                                                   |
 | ----------------------- | ------------------------------------------------------------------------------ |
-| `juno init <name>`      | scaffold a project. **No server needed.**                                      |
+| `juno init <name>`      | fetch a starting project from a Juno and write it down                         |
 | `juno types`            | POST `manifest.json`, write `types/`                                           |
-| `juno check`            | local `tsc --noEmit` + `eslint`, then validate against a Juno (writes nothing) |
+| `juno verify-types`     | check `types/` still matches `manifest.json` — talks to nothing                |
+| `juno check`            | local `verify-types` + `tsc --noEmit` + `eslint`, then validate against a Juno |
 | `juno deploy [--watch]` | upload, verify, activate — and write back the returned types                   |
 | `juno pull`             | write back the manifest and sources the instance holds                         |
 
@@ -31,7 +32,7 @@ packaging format and nothing is published to npm.
 | `--watch`       | redeploy on every save (`deploy`)                                    |
 | `--force`       | overwrite a dirty working tree (`pull`)                              |
 | `--here`        | scaffold into the current directory (`init`)                         |
-| `--skip-local`  | skip the local tsc/eslint pass (`check`)                             |
+| `--skip-local`  | skip the local verify-types/tsc/eslint pass (`check`)                |
 
 ## Choosing an instance
 
@@ -61,14 +62,37 @@ interface. Most importantly, a drive-by contributor fixing a bug in someone
 else's integration never needs an instance — only the person changing the
 manifest does.
 
+The cost of that decision is drift: edit `manifest.json`, forget
+`npm run types`, and every other signal stays green while `types/` describes a
+contract you no longer declare. `tsc` compiles happily against stale types,
+`eslint` is happy, and the testkit's conformance check compares the manifest
+with your _module_, never with `types/` — so the mismatch surfaces at deploy, or
+later, as a flow author calling an action whose shape changed.
+
+`juno verify-types` closes it. `juno types` records a fingerprint of the
+`manifest.json` it generated from, as a comment in `types/integration-env.d.ts`:
+
+```ts
+// integration-env.d.ts for 'pushover'
+// DO NOT EDIT — generated by 'juno types' from 'manifest.json'.
+// juno:manifest-sha256 5c5ca8eabe12cf44
+```
+
+`verify-types` recomputes it and compares. It runs first in `npm test` and
+inside `juno check`, and it contacts nothing — which is the point: the mistake
+is caught in a contributor's CI, and that CI deliberately has no instance to
+ask. Reformatting `manifest.json` also invalidates the stamp; the fix is the
+same `npm run types` either way.
+
 ## What runs where
 
 |                                                                 | offline | needs an instance |
 | --------------------------------------------------------------- | ------- | ----------------- |
 | `tsc --noEmit`, `eslint`, `vitest`                              | ✅      |                   |
+| `juno verify-types` (is `types/` current?)                      | ✅      |                   |
 | structural manifest check via `"$schema"` in your editor        | ✅      |                   |
 | reserved names, cross-surface collisions, JSON Schema compiling |         | `juno check`      |
-| `juno types`, `juno deploy`                                     |         | ✅                |
+| `juno init`, `juno types`, `juno deploy`                        |         | ✅                |
 
 Everything semantic lives in the Go server. This package knows some HTTP
 endpoints and a config preset — that is deliberate, so there is one answer to
@@ -76,8 +100,9 @@ endpoints and a config preset — that is deliberate, so there is one answer to
 
 ## `init` vs. downloading a project
 
-`juno init` and the instance's **Develop locally → Download project** button
-produce the same layout. They differ in what they can know: `init` needs no
-server, while the download can pre-generate `types/` and carries the sources of
-an integration that already exists there. Use `juno pull` afterwards — a second
-download would clobber your working tree.
+Both produce the same project, from the same generator on the instance: `init`
+starts from a stub manifest, the **Develop locally → Download project** button
+starts from an integration that already exists there. Neither is a local
+template — the CLI writes the files it is handed, so a scaffold cannot drift
+from what the server ejects. To refresh an existing checkout use `juno pull`; a
+second download would clobber your working tree.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@junoflow/cli",
-  "version": "0.1.0",
-  "description": "Command line tools for developing Juno integrations: scaffold, generate types, check and deploy.",
+  "version": "0.1.1",
+  "description": "Command line tools for developing Juno integrations",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -25,12 +25,6 @@
     "eslint.config.js",
     "README.md"
   ],
-  "keywords": [
-    "juno",
-    "junoflow",
-    "cli",
-    "integration"
-  ],
   "scripts": {
     "test": "node --test \"test/**/*.test.js\""
   },

package/src/api.js

@@ -1,10 +1,11 @@
 import { DiagnosticsError, UserError } from './errors.js';
 
 /**
- * Client for the four endpoints this CLI knows about. It knows nothing
- * semantic: validation, reserved names, schema compilation and typegen all
- * live in the Go server, so there is one answer to "is this manifest valid"
- * rather than two that can disagree.
+ * Client for the handful of endpoints this CLI knows about. It knows nothing
+ * semantic: validation, reserved names, schema compilation, typegen and the
+ * shape of a project all live in the Go server, so there is one answer to "is
+ * this manifest valid" — and one project layout — rather than two that can
+ * disagree.
  */
 export class JunoClient {
   constructor(target, { fetch: fetchImpl = globalThis.fetch } = {}) {
@@ -12,6 +13,20 @@ export class JunoClient {
     this.fetch = fetchImpl;
   }
 
+  /**
+   * POST /api/integrations/scaffold — a whole starting project, path →
+   * content. `target` is what this client reached the instance at; the server
+   * prefers its own configured public URL and falls back to it.
+   */
+  async scaffold(name, { description, target } = {}) {
+    const body = await this.#json('POST', '/api/integrations/scaffold', {
+      name,
+      description: description ?? undefined,
+      target: target ?? undefined,
+    });
+    return body?.files ?? {};
+  }
+
   /** POST /api/typegen/integration — both .d.ts halves, one call. */
   async typegen(manifest) {
     return this.#json('POST', '/api/typegen/integration', { manifest });

package/src/commands/check.js

@@ -2,8 +2,10 @@ import { spawn } from 'node:child_process';
 import { join } from 'node:path';
 
 import { JunoClient } from '../api.js';
+import { UserError } from '../errors.js';
 import { readProject } from '../project.js';
 import { resolveTarget } from '../target.js';
+import { verifyTypes } from './verify-types.js';
 
 /**
  * `juno check` — the offline checks, then the ones only a Juno can answer.
@@ -17,6 +19,15 @@ export async function check(argv, io) {
   let failed = false;
 
   if (!argv['skip-local']) {
+    // Before tsc, deliberately: type-checking against types/ says nothing if
+    // types/ describes a manifest that is no longer on disk.
+    try {
+      await verifyTypes(argv, io);
+    } catch (err) {
+      if (!(err instanceof UserError)) throw err;
+      io.error(err.message);
+      failed = true;
+    }
     for (const [label, bin, args] of [
       ['typecheck', 'tsc', ['--noEmit']],
       ['lint', 'eslint', ['.']],

package/src/commands/deploy.js

@@ -3,8 +3,9 @@ import { join } from 'node:path';
 
 import { JunoClient } from '../api.js';
 import { DiagnosticsError } from '../errors.js';
-import { readProject, writeTypes } from '../project.js';
+import { readManifestRaw, readProject, writeTypes } from '../project.js';
 import { resolveTarget } from '../target.js';
+import { stampTypeFiles } from '../stamp.js';
 import { formatDiagnostics } from '../diagnostics.js';
 import { pickTypeFiles } from './types.js';
 
@@ -32,7 +33,12 @@ export async function deploy(argv, io) {
 async function deployOnce(client, argv, io, target) {
   const project = await readProject(io.cwd);
   const result = await client.ingest(project, { name: argv.name });
-  const written = await writeTypes(pickTypeFiles(result.types), io.cwd);
+  // Stamped against the manifest this deploy was built from, so the watch loop
+  // leaves a tree that `juno verify-types` accepts.
+  const written = await writeTypes(
+    stampTypeFiles(pickTypeFiles(result.types), await readManifestRaw(io.cwd)),
+    io.cwd
+  );
   for (const warning of result.warnings ?? []) io.warn(`warning: ${warning}`);
   io.log(
     `deployed ${result.name} v${result.version} to ${target} (${written.join(', ')})`

package/src/commands/init.js

@@ -1,39 +1,36 @@
-import { mkdir, readFile, writeFile, access } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { mkdir, writeFile, access } from 'node:fs/promises';
+import { dirname, join, resolve, sep } from 'node:path';
 
+import { JunoClient } from '../api.js';
 import { UserError } from '../errors.js';
+import { resolveTarget } from '../target.js';
 
 /**
- * `juno init [name]` — scaffold a project with no server involved.
+ * `juno init [name]` — ask a Juno for a starting project and write it down.
  *
- * This deliberately duplicates what `GET /api/integrations/{name}/package.zip`
- * generates server-side. It has to: init's whole point is that you can start
- * without a Juno, and the server's whole point is that it can eject an
- * integration that already exists there. The two agree on layout and scripts;
- * only the server's version can pre-generate types/, because only it knows the
- * manifest's compiled shape.
+ * Every file comes from `POST /api/integrations/scaffold`, which renders it
+ * with the same generator behind **Develop locally → Download project**. The
+ * CLI holds no copy of the layout: a scaffold and an ejected project cannot
+ * drift, and the starter arrives with `types/` already generated, which only
+ * the server can produce.
  */
 export async function init(argv, io) {
   const name = argv._[0] ?? argv.name;
   if (!name) throw new UserError('usage: juno init <name>');
-  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
-    throw new UserError(`"${name}" must be kebab-case: [a-z][a-z0-9-]*`);
-  }
 
   const dir = resolve(io.cwd, argv.here ? '.' : name);
   if (!argv.here && (await exists(dir))) {
     throw new UserError(`${dir} already exists`);
   }
 
-  const version = await toolingRange();
-  const files = scaffold(
-    name,
-    version,
-    argv.url ?? process.env.JUNO_URL ?? null
-  );
+  const target = await resolveTarget({ url: argv.url, cwd: io.cwd });
+  const client = argv.client ?? new JunoClient(target);
+  // The name is validated server-side, against the same rules an install is:
+  // one answer to "is this a valid integration name" rather than two.
+  const files = await client.scaffold(name, { target });
+
   for (const [rel, content] of Object.entries(files)) {
-    const path = join(dir, rel);
+    const path = join(dir, safeRelative(rel));
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, content, 'utf8');
   }
@@ -41,178 +38,25 @@ export async function init(argv, io) {
   io.log(`created ${dir}`);
   io.log('');
   io.log(argv.here ? 'npm install' : `cd ${name} && npm install`);
-  io.log('npm run types      # generate types/ from manifest.json');
   io.log('npm test');
   io.log('npm run deploy');
   return 0;
 }
 
-/** @junoflow/* are version-locked, so the CLI's own version is the range. */
-async function toolingRange() {
-  const here = dirname(fileURLToPath(import.meta.url));
-  const raw = await readFile(join(here, '..', '..', 'package.json'), 'utf8');
-  return `^${JSON.parse(raw).version}`;
-}
-
-function scaffold(name, toolingRange, target) {
-  const pkg = {
-    name,
-    version: '0.1.0',
-    description: '',
-    private: true,
-    type: 'module',
-    scripts: {
-      typecheck: 'tsc --noEmit',
-      lint: 'eslint .',
-      test: 'npm run typecheck && npm run lint && vitest run',
-      types: 'juno types',
-      check: 'juno check',
-      deploy: 'juno deploy',
-      watch: 'juno deploy --watch',
-      pull: 'juno pull',
-    },
-    devDependencies: {
-      '@junoflow/cli': toolingRange,
-      '@junoflow/testkit': toolingRange,
-      eslint: '^9.34.0',
-      typescript: '^5.9.0',
-      vitest: '^3.2.0',
-    },
-    ...(target ? { juno: { target } } : {}),
-  };
-
-  const manifest = {
-    ...(target
-      ? {
-          $schema: `${target.replace(/\/+$/, '')}/api/schemas/integration-manifest.json`,
-        }
-      : {}),
-    name,
-    description: `The ${name} integration.`,
-    config: {
-      apiToken: {
-        type: 'string',
-        credential: true,
-        required: true,
-        title: 'API token',
-        description: 'Filled in by whoever installs this.',
-      },
-    },
-    actions: {
-      ping: {
-        description: 'Replace me with something the service actually does.',
-        params: {
-          type: 'object',
-          properties: { message: { type: 'string' } },
-          required: ['message'],
-          additionalProperties: false,
-        },
-        response: {
-          type: 'object',
-          properties: { ok: { type: 'boolean' } },
-        },
-      },
-    },
-  };
-
-  return {
-    'manifest.json': `${JSON.stringify(manifest, null, 2)}\n`,
-    'package.json': `${JSON.stringify(pkg, null, 2)}\n`,
-    'src/integration.ts': SRC,
-    'test/integration.test.ts': TEST(name),
-    'tsconfig.json': TSCONFIG,
-    'eslint.config.js': ESLINT,
-    '.gitignore': GITIGNORE,
-    '.github/workflows/ci.yml': CI,
-    'README.md': README(name),
-  };
-}
-
-// No imports: every type is an ambient global from types/, and verify rejects
-// an import of juno:sdk.
-const SRC = `export default {
-  actions: {
-    ping: async (params, ctx) => {
-      ctx.log(\`ping: \${params.message}\`);
-      // ctx.config and ctx.credentials are typed from manifest.json's config.
-      return { ok: true };
-    },
-  },
-} satisfies Integration;
-`;
-
-const TEST = (name) => `import { describe, expect, it } from 'vitest';
-import { harness } from '@junoflow/testkit';
-
-import manifest from '../manifest.json';
-import integration from '../src/integration';
-
-const h = harness({ manifest, integration });
-
-describe('${name}', () => {
-  it('conforms to its manifest', () => {
-    expect(h.conformance()).toEqual([]);
-  });
-
-  it('ping returns ok', async () => {
-    h.credentials({ apiToken: 'test-token' });
-    expect(await h.action('ping', { message: 'hello' })).toEqual({ ok: true });
-  });
-});
-`;
-
-const TSCONFIG = `{
-  "extends": "@junoflow/cli/tsconfig.base.json",
-  "include": ["src/**/*.ts", "types/**/*.d.ts", "test/**/*.ts"]
+/**
+ * The server hands back repo-relative POSIX paths. It is a trusted instance,
+ * but "write these paths" is the one place a bad answer escapes the project
+ * directory, and checking costs a line.
+ */
+function safeRelative(rel) {
+  const parts = rel.split('/');
+  if (rel.startsWith('/') || parts.includes('..') || parts.includes('')) {
+    throw new UserError(
+      `refusing to write ${rel}: not a project-relative path`
+    );
+  }
+  return parts.join(sep);
 }
-`;
-
-const ESLINT = `import juno from '@junoflow/cli/eslint.config.js';
-
-export default juno;
-`;
-
-const GITIGNORE = `node_modules/
-dist/
-*.log
-.DS_Store
-`;
-
-const CI = `name: CI
-
-on:
-  push:
-  pull_request:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-      - run: npm install
-      - run: npm test
-`;
-
-const README = (name) => `# ${name}
-
-A [Juno](https://github.com/boivie/juno) integration.
-
-\`\`\`bash
-npm install
-npm run types     # generate types/ from manifest.json
-npm test
-npm run deploy
-\`\`\`
-
-\`types/\` is generated and **committed**, so a fresh clone compiles offline and a
-contributor fixing a bug needs no Juno instance. Regenerate it after every
-\`manifest.json\` edit.
-
-Publish by tagging: Juno installs this repository at \`refs/tags/<tag>\`.
-`;
 
 async function exists(path) {
   try {

package/src/commands/types.js

@@ -1,5 +1,6 @@
 import { JunoClient } from '../api.js';
-import { readManifest, writeTypes } from '../project.js';
+import { readManifest, readManifestRaw, writeTypes } from '../project.js';
+import { stampTypeFiles } from '../stamp.js';
 import { resolveTarget } from '../target.js';
 
 /**
@@ -12,11 +13,15 @@ import { resolveTarget } from '../target.js';
  */
 export async function types(argv, io) {
   const target = await resolveTarget({ url: argv.url, cwd: io.cwd });
+  const raw = await readManifestRaw(io.cwd);
   const manifest = await readManifest(io.cwd);
   const client = argv.client ?? new JunoClient(target);
 
   const generated = await client.typegen(manifest);
-  const written = await writeTypes(pickTypeFiles(generated), io.cwd);
+  const written = await writeTypes(
+    stampTypeFiles(pickTypeFiles(generated), raw),
+    io.cwd
+  );
   io.log(`wrote ${written.join(', ')}`);
   return 0;
 }

package/src/commands/verify-types.js

@@ -0,0 +1,57 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { UserError } from '../errors.js';
+import { readManifestRaw } from '../project.js';
+import { ENV_DTS, manifestStamp, readStamp } from '../stamp.js';
+
+/**
+ * `juno verify-types` — does types/ still describe manifest.json?
+ *
+ * The one check in this CLI that talks to nothing. It is the counterweight to
+ * committing types/: that decision is what lets a drive-by contributor work
+ * without an instance, and its cost is that the committed types can silently
+ * fall behind the manifest they were generated from. Everything else in the
+ * gate stays green when they do — tsc type-checks against the stale types
+ * rather than noticing they are stale, and h.conformance() compares the
+ * manifest with the module, never with types/.
+ *
+ * So this runs first in `npm test` and inside `juno check`. A failure here is
+ * always the same one sentence of advice, which is why the message says it
+ * rather than describing the mismatch.
+ */
+export async function verifyTypes(argv, io) {
+  const raw = await readManifestRaw(io.cwd);
+  const path = join(io.cwd, ...ENV_DTS.split('/'));
+
+  let generated;
+  try {
+    generated = await readFile(path, 'utf8');
+  } catch {
+    throw new UserError(
+      `${ENV_DTS} is missing — run 'npm run types' (needs a Juno instance) to generate it.`
+    );
+  }
+
+  const found = readStamp(generated);
+  if (found === null) {
+    // Every generator writes one. A file without it predates the stamp or was
+    // hand-edited, and either way nothing here can vouch for it.
+    throw new UserError(
+      `${ENV_DTS} carries no manifest stamp, so it cannot be checked against manifest.json.\n` +
+        `Regenerate it with 'npm run types'.`
+    );
+  }
+
+  const want = manifestStamp(raw);
+  if (found !== want) {
+    throw new UserError(
+      `${ENV_DTS} was generated from a different manifest.json (stamped ${found}, on disk ${want}).\n` +
+        `Run 'npm run types' and commit the result — until then every other check ` +
+        `passes against a contract that is no longer the one you declared.`
+    );
+  }
+
+  io.log(`${ENV_DTS} matches manifest.json`);
+  return 0;
+}

package/src/index.js

@@ -5,18 +5,27 @@ import { deploy } from './commands/deploy.js';
 import { init } from './commands/init.js';
 import { pull } from './commands/pull.js';
 import { types } from './commands/types.js';
+import { verifyTypes } from './commands/verify-types.js';
 import { DiagnosticsError, UserError } from './errors.js';
 import { formatDiagnostics } from './diagnostics.js';
 
-const COMMANDS = { init, types, check, deploy, pull };
+const COMMANDS = {
+  init,
+  types,
+  'verify-types': verifyTypes,
+  check,
+  deploy,
+  pull,
+};
 
 const USAGE = `juno — develop Juno integrations
 
 Usage: juno <command> [options]
 
 Commands:
-  init <name>      scaffold a new integration project (no server needed)
+  init <name>      scaffold a new integration project from a Juno
   types            generate types/ from manifest.json
+  verify-types     check types/ still matches manifest.json (offline)
   check            typecheck and lint locally, then validate against a Juno
   deploy [--watch] upload, verify, and activate a new version
   pull             write back the manifest and sources Juno holds

package/src/project.js

@@ -26,16 +26,23 @@ export async function readProject(cwd = process.cwd()) {
   };
 }
 
-export async function readManifest(cwd = process.cwd()) {
-  const path = join(cwd, 'manifest.json');
-  let raw;
+/**
+ * The manifest as it sits on disk. The stamp in types/integration-env.d.ts
+ * fingerprints these exact bytes, so both writing and verifying it go through
+ * here rather than through a re-encoding of the parsed object.
+ */
+export async function readManifestRaw(cwd = process.cwd()) {
   try {
-    raw = await readFile(path, 'utf8');
+    return await readFile(join(cwd, 'manifest.json'), 'utf8');
   } catch {
     throw new UserError(
       `no manifest.json in ${cwd} — run this from an integration project root`
     );
   }
+}
+
+export async function readManifest(cwd = process.cwd()) {
+  const raw = await readManifestRaw(cwd);
   try {
     return JSON.parse(raw);
   } catch (err) {

package/src/stamp.js

@@ -0,0 +1,84 @@
+import { createHash } from 'node:crypto';
+
+/**
+ * The manifest fingerprint carried in types/integration-env.d.ts, and the
+ * mirror of internal/typegen/stamp.go. Both halves must produce the same 16
+ * hex characters for the same manifest.json — stampParity in test/stamp.test.js
+ * and TestManifestStampParity pin the same input to the same output from each
+ * side, which is the only thing that keeps them together.
+ *
+ * Why it exists: "edit manifest.json, forget `juno types`" is the one mistake
+ * this workflow reliably produces, and nothing else catches it. tsc compiles
+ * happily against stale types, eslint is happy, and h.conformance() checks the
+ * manifest against the *module*, never against types/. The drift surfaces at
+ * deploy, or later still, as a flow author calling an action with a shape that
+ * no longer exists.
+ *
+ * Why a hash rather than asking a Juno: the check has to run where the mistake
+ * is caught — a contributor's CI, which deliberately has no instance to ask.
+ * `juno types` needs a server; verifying what it wrote must not.
+ */
+const STAMP_PREFIX = '// juno:manifest-sha256 ';
+const STAMP_LENGTH = 16;
+
+/** The generated file that carries the stamp. */
+export const ENV_DTS = 'types/integration-env.d.ts';
+
+/**
+ * Fingerprints the exact bytes of a manifest.json.
+ *
+ * Raw bytes, not a canonical re-encoding: the other half of this is Go, and any
+ * normalisation beyond line endings would need encoding/json and JSON.stringify
+ * to agree on key order, number formatting and string escaping — which they do
+ * not promise. Hashing what is on disk needs no such treaty. The cost is that
+ * reformatting manifest.json invalidates the stamp, and the fix is the same
+ * `npm run types` the author owed anyway.
+ *
+ * CRLF folds to LF because that is the one rewrite git performs by itself, and
+ * a Windows checkout of a Linux-authored repository must still verify.
+ */
+export function manifestStamp(manifestJSON) {
+  return createHash('sha256')
+    .update(manifestJSON.replace(/\r\n/g, '\n'))
+    .digest('hex')
+    .slice(0, STAMP_LENGTH);
+}
+
+/** Writes the fingerprint into a generated env .d.ts, replacing any prior one. */
+export function stampEnvDTS(envDTS, manifestJSON) {
+  const stamp = STAMP_PREFIX + manifestStamp(manifestJSON);
+  const lines = envDTS.split('\n');
+  const existing = lines.findIndex((l) => l.startsWith(STAMP_PREFIX));
+  if (existing >= 0) {
+    lines[existing] = stamp;
+    return lines.join('\n');
+  }
+  // Directly under the "DO NOT EDIT" header, where a reader looking for the
+  // file's provenance already is.
+  let at = 0;
+  while (at < lines.length && lines[at].startsWith('//')) at++;
+  lines.splice(at, 0, stamp);
+  return lines.join('\n');
+}
+
+/**
+ * Stamps the env half of a `{ 'integration-env.d.ts': …, … }` map, as the
+ * typegen and ingest endpoints answer with.
+ *
+ * Applied client-side rather than server-side because it fingerprints the bytes
+ * on *this* disk: both endpoints are handed a parsed manifest and never see the
+ * file, and the same typegen endpoint also answers the authoring agent, which
+ * has no file at all. The project generator behind `juno init` does see one, so
+ * it stamps there — internal/typegen/stamp.go.
+ */
+export function stampTypeFiles(types, rawManifest) {
+  const name = ENV_DTS.replace('types/', '');
+  if (typeof types?.[name] !== 'string') return types;
+  return { ...types, [name]: stampEnvDTS(types[name], rawManifest) };
+}
+
+/** The stamp an env .d.ts carries, or null when it has none. */
+export function readStamp(envDTS) {
+  const line = envDTS.split('\n').find((l) => l.startsWith(STAMP_PREFIX));
+  return line ? line.slice(STAMP_PREFIX.length).trim() : null;
+}

package/tsconfig.base.json

@@ -1,13 +1,13 @@
 {
   "//": "The compiler options Juno type-checks with server-side. internal/verify's tsconfig_preset_test.go asserts this file and verify.CompilerOptions() are identical, so `tsc --noEmit` passing here means the deploy will not 422 on a type error. Extend it; do not fork it.",
   "compilerOptions": {
-    "esModuleInterop": true,
+    "target": "ES2022",
     "module": "CommonJS",
     "moduleResolution": "node",
+    "strict": true,
     "noEmit": true,
+    "esModuleInterop": true,
     "resolveJsonModule": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "target": "ES2022"
+    "skipLibCheck": true
   }
 }