@octalmesh/seagull-core 0.0.2

package/dist/index.mjs

@@ -0,0 +1,1364 @@
+import { createRequire } from "node:module";
+import { z } from "zod";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { parse, stringify } from "yaml";
+import { spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+//#region src/config/schema.ts
+/**
+* The seagull config *schema* version - not the npm package's own version.
+* Bumped only when the shape of `seagull.yaml` changes in a breaking way, so
+* older configs fail with a clear "this config targets schema vN, seagull
+* expects vM" error instead of a confusing validation failure on some
+* unrelated field once the schema moves on.
+*/
+const CONFIG_SCHEMA_VERSION = 1;
+const varsTreeSchema = z.lazy(() => z.record(z.string(), z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	varsTreeSchema
+])));
+const githubSchema = z.object({
+	owner: z.string().min(1),
+	repo: z.string().min(1)
+});
+const pathsSchema = z.object({
+	dist: z.string().min(1).default("dist"),
+	specs: z.string().min(1).optional(),
+	docs: z.string().min(1).optional(),
+	sdk: z.string().min(1).optional()
+});
+const docsSchema = z.object({
+	server: z.object({
+		host: z.string().min(1),
+		port: z.number().int().positive()
+	}),
+	metadata: z.object({
+		title: z.string().min(1),
+		description: z.string().min(1),
+		favicon: z.string().min(1),
+		baseServerUrl: z.string().min(1)
+	})
+});
+const sdkToolSchema = z.enum(["openapi-generator", "openapi-typescript"]);
+const sdkLangSchema = z.enum([
+	"typescript",
+	"go",
+	"java"
+]);
+const sdkKindSchema = z.enum(["client", "server"]);
+/**
+* `-g`/`--additional-properties` values: openapi-generator accepts strings,
+* numbers and booleans, all rendered as `key=value` on the CLI.
+*/
+const additionalPropertiesSchema = z.record(z.string(), z.union([
+	z.string(),
+	z.number(),
+	z.boolean()
+])).default({});
+const mavenCoordsSchema = z.object({
+	groupId: z.string().min(1),
+	artifactId: z.string().min(1)
+});
+/**
+* Publishing conventions - git branch/tag naming, and where registry-backed
+* artifacts (npm, Maven) get pushed. Every field is a template supporting the
+* usual `{...}` placeholders (`{service}`, `{id}`, `{github.*}`, `{vars.*}`,
+* and for `tag` only, also `{version}`).
+*
+* Required at the root level - seagull has no built-in opinion on branch/tag
+* naming or which registry to use, so this has to come from the config, not
+* from a hardcoded convention baked into the tool. Per-generator
+* (`generators.<id>.publishing`) and per-contract-artifact
+* (`artifacts[].overrides.publishing`) blocks only need to override the
+* fields that differ for that generator/artifact - see
+* {@link publishingOverrideSchema}.
+*/
+const publishingSchema = z.object({
+	/**
+	* Git branch artifacts publish to. Resolved once, at config-load time -
+	* no `{version}` available here, e.g. `"sdk/svc-{service}/{id}"`.
+	*/
+	branch: z.string().min(1),
+	/**
+	* Git tag artifacts are tagged with on publish. Resolved at publish time,
+	* once the version is known, e.g. `"svc-{service}-{id}-v{version}"`.
+	*/
+	tag: z.string().min(1),
+	/**
+	* Template for the `repository.url` field written into generated
+	* `package.json` (and shown in default README templates), e.g.
+	* `"https://github.com/{github.owner}/{github.repo}"`.
+	*/
+	repositoryUrl: z.string().min(1),
+	npm: z.object({
+		registry: z.string().min(1),
+		access: z.enum(["public", "restricted"])
+	}),
+	maven: z.object({
+		repositoryId: z.string().min(1),
+		repositoryUrl: z.string().min(1)
+	})
+});
+/**
+* The generator-level / per-artifact-override form of {@link publishingSchema} -
+* every field optional, since it only needs to override whichever fields
+* differ from the root-level `publishing:` (which is guaranteed complete).
+*/
+const publishingOverrideSchema = z.object({
+	branch: z.string().min(1).optional(),
+	tag: z.string().min(1).optional(),
+	repositoryUrl: z.string().min(1).optional(),
+	npm: z.object({
+		registry: z.string().min(1).optional(),
+		access: z.enum(["public", "restricted"]).optional()
+	}).optional(),
+	maven: z.object({
+		repositoryId: z.string().min(1).optional(),
+		repositoryUrl: z.string().min(1).optional()
+	}).optional()
+});
+/**
+* The shape of a generator "recipe", without the cross-field checks below -
+* kept separate so {@link artifactRefSchema}'s `overrides:` can `.partial()`
+* it (zod rejects `.partial()` on a schema with `.check()` refinements
+* attached).
+*/
+const generatorDefBaseSchema = z.object({
+	tool: sdkToolSchema,
+	lang: sdkLangSchema,
+	kind: sdkKindSchema,
+	/**
+	* `openapi-generator -g <generator>` value. Required when `tool` is
+	* `openapi-generator`.
+	*/
+	generator: z.string().min(1).optional(),
+	/** npm package name template, e.g. `"@{vars.org}/{service}-client"`. */
+	package: z.string().min(1).optional(),
+	goModule: z.string().min(1).optional(),
+	goPackageName: z.string().min(1).optional(),
+	maven: mavenCoordsSchema.optional(),
+	additionalProperties: additionalPropertiesSchema,
+	/**
+	* Optional path (relative to the config file's directory) to a custom README
+	* template for this artifact - supports the same `{...}` placeholders as
+	* naming templates, plus `{version}`, `{title}`, and `{artifact.*}`. If
+	* omitted, a built-in default template for the artifact's language/kind is
+	* used instead.
+	*/
+	readme: z.string().min(1).optional(),
+	/**
+	* Publishing conventions (branch/tag naming, registry URLs) for this
+	* generator specifically - overrides whichever fields differ from the
+	* root-level `publishing:` (required, see {@link publishingSchema}).
+	*/
+	publishing: publishingOverrideSchema.optional()
+});
+/**
+* A single generator "recipe": which tool to invoke and how. Referenced by id
+* from one or more contracts' `artifacts:` list.
+*/
+const generatorDefSchema = generatorDefBaseSchema.check((ctx) => {
+	const value = ctx.value;
+	if (value.tool === "openapi-generator" && !value.generator) ctx.issues.push({
+		code: "custom",
+		message: "\"generator\" is required when tool is \"openapi-generator\"",
+		input: value
+	});
+	if (value.lang === "go" && !value.goModule) ctx.issues.push({
+		code: "custom",
+		message: "\"goModule\" is required for lang \"go\"",
+		input: value
+	});
+	if (value.lang === "java" && !value.maven) ctx.issues.push({
+		code: "custom",
+		message: "\"maven\" ({ groupId, artifactId }) is required for lang \"java\"",
+		input: value
+	});
+	if (value.lang === "typescript" && !value.package) ctx.issues.push({
+		code: "custom",
+		message: "\"package\" is required for lang \"typescript\"",
+		input: value
+	});
+});
+const generatorsSchema = z.record(z.string(), generatorDefSchema);
+/**
+* A contract's reference to a generator by id. The plain-string form just runs
+* that generator as-is; the object form lets one contract tweak a shared
+* generator (extra/overridden `additionalProperties`, a different
+* `maven`/`package`/`readme`/... value) without duplicating the whole recipe
+* under a new id, and `as` renames the artifact's own id (output
+* folder / branch / tag segment) if a contract needs two variants of the same
+* base generator.
+*/
+const artifactRefSchema = z.union([z.string().min(1), z.object({
+	generator: z.string().min(1),
+	as: z.string().min(1).optional(),
+	overrides: generatorDefBaseSchema.partial().optional()
+})]);
+const contractSchema = z.object({
+	name: z.string().min(1),
+	title: z.string().min(1),
+	entrypoint: z.string().min(1),
+	artifacts: z.array(artifactRefSchema).min(1)
+});
+const rootConfigSchema = z.object({
+	/**
+	* The config schema version this file targets. Currently must be `1`
+	* (the only version that exists) - see {@link CONFIG_SCHEMA_VERSION}.
+	*/
+	configVersion: z.literal(1),
+	github: githubSchema,
+	vars: varsTreeSchema.default({}),
+	paths: pathsSchema.default({ dist: "dist" }),
+	docs: docsSchema,
+	/**
+	* Publishing conventions (branch/tag naming, registry URLs), applied to
+	* every artifact unless overridden per-generator or
+	* per-contract-artifact. Required - seagull has no built-in default here,
+	* see {@link publishingSchema}.
+	*/
+	publishing: publishingSchema,
+	generators: generatorsSchema,
+	contracts: z.array(contractSchema).min(1)
+});
+//#endregion
+//#region src/config/template.ts
+const PLACEHOLDER = /\{([a-zA-Z0-9_.]+)}/g;
+/**
+* Replaces every `{dot.path}` placeholder in `template` with its value from
+* `context`, throwing a descriptive error if a placeholder has no match -
+* a typo'd `{vars.org}` should fail loudly at config-load time, not silently
+* produce a package named literally `@{vars.org}/...`.
+*
+* @param template - The template string, e.g. `"@{vars.org}/{service}-client"`.
+* @param context  - The flattened context to resolve placeholders against.
+* @returns The interpolated string.
+*/
+function interpolate(template, context) {
+	return template.replace(PLACEHOLDER, (_match, key) => {
+		const value = context[key];
+		if (value === void 0) {
+			const available = Object.keys(context).sort().join(", ");
+			throw new Error(`Unknown template placeholder "{${key}}" in "${template}" (available: ${available})`);
+		}
+		return value;
+	});
+}
+/**
+* Recursively interpolates every string value in `value` (walking through plain
+* objects), leaving non-string leaves untouched. Used to resolve
+* `additionalProperties` maps, which may mix templated strings with plain
+* booleans/numbers.
+*
+* @param value   - The value (string, object, or primitive) to interpolate.
+* @param context - The flattened context to resolve placeholders against.
+* @returns A deep copy of `value` with every string interpolated.
+*/
+function interpolateDeep(value, context) {
+	if (typeof value === "string") return interpolate(value, context);
+	if (Array.isArray(value)) return value.map((item) => interpolateDeep(item, context));
+	if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, interpolateDeep(child, context)]));
+	return value;
+}
+/**
+* Flattens a nested scope object (e.g. `{ service: "auth", vars: { org: "x" } }`)
+* into dot-path lookup keys (`{ service: "auth", "vars.org": "x" }`) for use
+* with {@link interpolate}.
+*
+* @param scope - The nested scope to flatten.
+* @returns A flat dot-path -> string map.
+*/
+function buildTemplateContext(scope) {
+	const out = {};
+	flatten(scope, "", out);
+	return out;
+}
+function flatten(value, prefix, out) {
+	if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+		for (const [key, child] of Object.entries(value)) flatten(child, prefix ? `${prefix}.${key}` : key, out);
+		return;
+	}
+	if (value === void 0) return;
+	out[prefix] = String(value);
+}
+//#endregion
+//#region src/config/loader.ts
+/**
+* Reads and validates a CLI config file, throwing a readable, multi-issue error
+* message if it doesn't match the schema.
+*
+* @param configPath - Absolute path to the YAML config file.
+* @returns The validated (but not yet resolved) raw config.
+*/
+function readRawConfig(configPath) {
+	const raw = parse(readFileSync(configPath, "utf8"));
+	const result = rootConfigSchema.safeParse(raw);
+	if (!result.success) {
+		const issues = z.prettifyError(result.error);
+		throw new Error(`Invalid ${path.basename(configPath)}:\n${issues}`);
+	}
+	return result.data;
+}
+/**
+* Deep-merges a generator override (from an artifact's `overrides:` block)
+* onto its base generator def. `additionalProperties`, `maven`, and
+* `publishing` are merged key-by-key; every other field is a plain override.
+*
+* @param base      - The base generator def, looked up by id from `generators:`.
+* @param overrides - The partial override from the artifact reference, if any.
+* @returns The merged generator def.
+*/
+function mergeGeneratorOverride(base, overrides) {
+	if (!overrides) return base;
+	return {
+		...base,
+		...overrides,
+		maven: overrides.maven ? {
+			...base.maven,
+			...overrides.maven
+		} : base.maven,
+		additionalProperties: {
+			...base.additionalProperties,
+			...overrides.additionalProperties
+		},
+		publishing: mergePublishingOverride(base.publishing, overrides.publishing)
+	};
+}
+/**
+* Deep-merges two partial `publishing:` overrides (from a generator def and
+* an artifact-ref's `overrides:` block) into one.
+*
+* @param base      - The base override (maybe undefined).
+* @param overrides - The overriding override (maybe undefined).
+* @returns The merged override, or undefined if both inputs were.
+*/
+function mergePublishingOverride(base, overrides) {
+	if (!overrides) return base;
+	return {
+		...base,
+		...overrides,
+		npm: overrides.npm ? {
+			...base?.npm,
+			...overrides.npm
+		} : base?.npm,
+		maven: overrides.maven ? {
+			...base?.maven,
+			...overrides.maven
+		} : base?.maven
+	};
+}
+/**
+* Applies a (possibly partial) `publishing:` override onto the required
+* root-level `publishing:` block, producing a fully complete result - the
+* root block is guaranteed complete by the schema, so there's no fallback
+* case to handle here (unlike {@link mergePublishingOverride}).
+*
+* @param root     - The root-level `publishing:` config (required, always
+*                   complete).
+* @param override - The generator/artifact-level override, if any.
+* @returns The fully complete, merged publishing config.
+*/
+function applyPublishingOverride(root, override) {
+	if (!override) return root;
+	return {
+		...root,
+		...override,
+		npm: override.npm ? {
+			...root.npm,
+			...override.npm
+		} : root.npm,
+		maven: override.maven ? {
+			...root.maven,
+			...override.maven
+		} : root.maven
+	};
+}
+/**
+* Resolves a single artifact reference (string id, or `{ generator, overrides,
+* as }`) into its `{ id, def }` pair, looking up the base generator by id and
+* applying any overrides.
+*
+* @param ref          - The artifact reference from a contract's `artifacts:`
+*                       list.
+* @param generators   - The full `generators:` map from the raw config.
+* @param contractName - The owning contract's name.
+* @returns The artifact's resolved id and generator def (templates not yet
+*          interpolated).
+*/
+function resolveArtifactRef(ref, generators, contractName) {
+	const generatorId = typeof ref === "string" ? ref : ref.generator;
+	const base = generators[generatorId];
+	if (!base) {
+		const available = Object.keys(generators).sort().join(", ");
+		throw new Error(`Contract "${contractName}" references unknown generator "${generatorId}" (available: ${available})`);
+	}
+	return {
+		id: typeof ref === "string" ? ref : ref.as ?? ref.generator,
+		def: mergeGeneratorOverride(base, typeof ref === "string" ? void 0 : ref.overrides)
+	};
+}
+/**
+* Resolves an artifact's publishing conventions: applies the (already
+* override-merged) generator-level `publishing:` override onto the required
+* root-level `publishing:` block, then interpolates every field except `tag`
+* (which keeps `{version}` unresolved, since it isn't known until publish time;
+* see `config/publishing.ts`).
+*
+* @param generatorPublishing - The (override-merged) generator's own
+*                              `publishing:` override, if any.
+* @param rootPublishing      - The required root-level `publishing:` config
+*                              from the config file.
+* @param context             - The flattened template context for this artifact
+*                              (`service`, `id`, `github.*`, `vars.*`).
+* @returns The fully resolved publishing conventions for this artifact.
+*/
+function resolvePublishing(generatorPublishing, rootPublishing, context) {
+	const merged = applyPublishingOverride(rootPublishing, generatorPublishing);
+	return {
+		branch: interpolate(merged.branch, context),
+		tagTemplate: merged.tag,
+		repositoryUrl: interpolate(merged.repositoryUrl, context),
+		npmRegistry: interpolate(merged.npm.registry, context),
+		npmAccess: merged.npm.access,
+		mavenRepositoryId: interpolate(merged.maven.repositoryId, context),
+		mavenRepositoryUrl: interpolate(merged.maven.repositoryUrl, context)
+	};
+}
+/**
+* Interpolates templates and resolves absolute paths for a single artifact.
+*
+* @param id              - The artifact's resolved id (output folder / branch /
+*                          tag segment).
+* @param def             - The (override-merged, not-yet-interpolated)
+*                          generator def.
+* @param rootDir         - Absolute repo root, `readme` template paths are
+*                          resolved relative to this.
+* @param sdkDir          - Absolute path to the SDK output root (`<dist>/sdk`).
+* @param contractName    - The owning contract's name.
+* @param contractContext - The flattened template context for this contract
+*                          (`service`, `github.*`, `vars.*` - not yet `id`).
+* @param rootPublishing  - The required root-level `publishing:` config from
+*                          the config file.
+* @returns The fully resolved artifact.
+*/
+function resolveArtifact(id, def, rootDir, sdkDir, contractName, contractContext, rootPublishing) {
+	const context = {
+		...contractContext,
+		id
+	};
+	const resolved = interpolateDeep(def, context);
+	const publishing = resolvePublishing(def.publishing, rootPublishing, context);
+	return {
+		id,
+		tool: resolved.tool,
+		lang: resolved.lang,
+		kind: resolved.kind,
+		generator: resolved.generator,
+		outputDir: path.join(sdkDir, contractName, id),
+		branch: publishing.branch,
+		publishing,
+		additionalProperties: resolved.additionalProperties,
+		package: resolved.package,
+		goModule: resolved.goModule,
+		goPackageName: resolved.goPackageName,
+		maven: resolved.maven,
+		readmeTemplate: resolved.readme ? path.resolve(rootDir, resolved.readme) : void 0
+	};
+}
+/**
+* Resolves a single contract: its entrypoint path and every artifact in its
+* `artifacts:` list.
+*
+* @param input          - The raw contract config.
+* @param rootDir        - Absolute repo root, entrypoints/`readme` paths are
+*                         resolved relative to this.
+* @param sdkDir         - Absolute path to the SDK output root (`<dist>/sdk`).
+* @param generators     - The full `generators:` map from the raw config.
+* @param githubCtx      - `{ owner, repo }`, exposed to templates as
+*                         `{github.owner}`/`{github.repo}`.
+* @param vars           - The `vars:` tree from the raw config, exposed as
+*                         `{vars.*}`.
+* @param rootPublishing - The required root-level `publishing:` config from the
+*                         config file.
+* @returns The fully resolved contract.
+*/
+function resolveContract(input, rootDir, sdkDir, generators, githubCtx, vars, rootPublishing) {
+	const context = buildTemplateContext({
+		service: input.name,
+		github: githubCtx,
+		vars
+	});
+	const artifacts = input.artifacts.map((ref) => {
+		const { id, def } = resolveArtifactRef(ref, generators, input.name);
+		return resolveArtifact(id, def, rootDir, sdkDir, input.name, context, rootPublishing);
+	});
+	const entrypoint = path.join(rootDir, input.entrypoint);
+	return {
+		name: input.name,
+		title: input.title,
+		entrypoint,
+		entrypointRelative: path.relative(rootDir, entrypoint),
+		artifacts
+	};
+}
+/**
+* Loads, validates, and fully resolves a CLI config file - the single entry
+* point every command uses to get its configuration.
+*
+* Unlike a build tool bundled into the consumer's own repo, seagull is
+* installed as a dependency, so it has no way to guess where the consumer's
+* config lives on its own - `configPath` must be supplied by the caller (the
+* CLI resolves it via `resolveConfigPath()` in `config/resolve-config-file.ts`,
+* or `--config`).
+*
+* @param configPath - Absolute path to the CLI config file.
+* @returns The fully resolved config.
+*/
+function loadConfig(configPath) {
+	const rootDir = path.dirname(configPath);
+	const raw = readRawConfig(configPath);
+	const distDir = path.resolve(rootDir, raw.paths.dist);
+	const specsDir = raw.paths.specs ? path.resolve(rootDir, raw.paths.specs) : path.join(distDir, "specs");
+	const docsDir = raw.paths.docs ? path.resolve(rootDir, raw.paths.docs) : path.join(distDir, "docs");
+	const sdkDir = raw.paths.sdk ? path.resolve(rootDir, raw.paths.sdk) : path.join(distDir, "sdk");
+	const contracts = raw.contracts.map((contract) => resolveContract(contract, rootDir, sdkDir, raw.generators, raw.github, raw.vars, raw.publishing));
+	return {
+		configVersion: raw.configVersion,
+		rootDir,
+		paths: {
+			dist: distDir,
+			specs: specsDir,
+			docs: docsDir,
+			sdk: sdkDir
+		},
+		github: raw.github,
+		vars: raw.vars,
+		docs: raw.docs,
+		contracts,
+		allArtifacts: contracts.flatMap((contract) => contract.artifacts.map((artifact) => ({
+			contract,
+			artifact
+		})))
+	};
+}
+//#endregion
+//#region src/config/publishing.ts
+/**
+* Renders an artifact's final git tag from its `publishing.tagTemplate` -
+* the one piece of `publishing:` config that can't be resolved at config-load
+* time, since it needs the artifact's version, which is only known once the
+* contract's spec has been bundled.
+*
+* @param artifact     - The resolved artifact (for `id` and
+*                       `publishing.tagTemplate`).
+* @param contractName - The owning contract's name, exposed to the template as
+*                       `{service}`.
+* @param version      - The resolved SDK version, exposed to the template as
+*                       `{version}`.
+* @param github       - `{ owner, repo }`, exposed as `{github.owner}`/
+*                       `{github.repo}`.
+* @param vars         - The config's `vars:` tree, exposed as `{vars.*}`.
+* @returns The rendered tag name.
+*/
+function renderArtifactTag(artifact, contractName, version, github, vars) {
+	const context = buildTemplateContext({
+		service: contractName,
+		id: artifact.id,
+		version,
+		github,
+		vars
+	});
+	return interpolate(artifact.publishing.tagTemplate, context);
+}
+//#endregion
+//#region src/config/resolve-config-file.ts
+/**
+* Config filenames CLI recognizes, checked in this order.
+*/
+const CONFIG_FILENAMES = [
+	".seagull",
+	".seagull.yaml",
+	".seagull.yml",
+	"seagull.yaml",
+	"seagull.yml"
+];
+/**
+* Finds the CLI config file in a directory, trying each of
+* {@link CONFIG_FILENAMES} in order.
+*
+* @param cwd - The directory to look in (typically `process.cwd()`).
+* @returns The absolute path to the first matching config file.
+* @throws Error if none of the candidate filenames exist in `cwd`.
+*
+* @see {@link CONFIG_FILENAMES} - the list of filenames checked, in order.
+*/
+function resolveConfigPath(cwd) {
+	for (const filename of CONFIG_FILENAMES) {
+		const candidate = path.join(cwd, filename);
+		if (existsSync(candidate)) return candidate;
+	}
+	throw new Error(`No CLI config found in ${cwd} - looked for: ${CONFIG_FILENAMES.join(", ")}. Create one of these, or pass --config <path>.`);
+}
+//#endregion
+//#region src/generator/generator.ts
+/**
+* The root primitive every concrete SDK generator implements.
+*
+* One instance per underlying tool (`openapi-generator-cli`,
+* `openapi-typescript`, ...) - not one per language, since a single tool
+* invocation (e.g. `openapi-generator-cli -g java`/`-g go`) already covers
+* every language it supports. Language-specific behaviour (patching `go.mod`,
+* `package.json`, `pom.xml`, ...) is composed in via patchers rather than
+* living in per-language subclasses.
+*/
+var Generator = class {};
+//#endregion
+//#region src/generator/registry.ts
+/**
+* Looks up the concrete {@link Generator} implementation for a given tool name.
+*/
+var GeneratorRegistry = class {
+	generators = /* @__PURE__ */ new Map();
+	/**
+	* Registers a generator implementation under its own {@link Generator.tool}.
+	*
+	* @param generator - The generator instance to register.
+	* @returns `this`, for chaining.
+	*/
+	register(generator) {
+		this.generators.set(generator.tool, generator);
+		return this;
+	}
+	/**
+	* Resolves the generator implementation for a given tool name.
+	*
+	* @param tool - The tool name, e.g. `"openapi-generator"`.
+	* @returns The registered generator.
+	* @throws Error if no generator is registered for that tool.
+	*/
+	resolve(tool) {
+		const generator = this.generators.get(tool);
+		if (!generator) {
+			const available = [...this.generators.keys()].join(", ");
+			throw new Error(`No generator implementation registered for tool "${tool}" (available: ${available})`);
+		}
+		return generator;
+	}
+	/**
+	* All distinct tools currently registered.
+	*
+	* @returns The registered tool names.
+	*/
+	tools() {
+		return [...this.generators.keys()];
+	}
+};
+//#endregion
+//#region src/process/exec.ts
+/**
+* Runs a command to completion, streaming its stdio straight through
+* (`inherit`), and rejects if it exits non-zero.
+*
+* This is the async counterpart used for the "one long-running tool" commands
+* (`redocly`, `openapi-generator-cli`, `openapi-typescript`); for short
+* synchronous calls (git plumbing, `npm publish`/`mvn deploy`), see
+* {@link runSync}.
+*
+* @param command - The executable to run.
+* @param args    - Arguments to pass to it.
+* @param cwd     - The working directory to run it in.
+* @returns A promise that resolves on exit code 0, and rejects otherwise.
+*/
+function run(command, args, cwd) {
+	return new Promise((resolvePromise, reject) => {
+		spawn(command, args, {
+			cwd,
+			stdio: "inherit",
+			shell: true
+		}).on("close", (code) => {
+			if (code === 0) {
+				resolvePromise();
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(`${command} ${args.join(" ")} exited with ${code}`));
+		});
+	});
+}
+/**
+* Runs a command to completion synchronously, streaming its stdio straight
+* through (`inherit`).
+*
+* @param command - The executable to run.
+* @param args    - Arguments to pass to it.
+* @param cwd     - The working directory to run it in.
+* @returns The exit status (0 on success).
+*/
+function runSync(command, args, cwd) {
+	return spawnSync(command, args, {
+		cwd,
+		stdio: "inherit",
+		shell: true
+	}).status ?? 1;
+}
+//#endregion
+//#region src/process/resolve-bin.ts
+const require = createRequire(import.meta.url);
+/**
+* Resolves the absolute path to an installed npm package's own CLI entrypoint
+* script, using Node's standard module resolution algorithm - so it works the
+* same way regardless of which package manager (npm/pnpm/yarn) installed CLI
+* and its dependencies, or how deeply they get hoisted. Shelling out to
+* `pnpm exec`/`npx` instead would assume a specific package manager and a
+* particular install layout, which doesn't hold once CLI is just another
+* dependency in someone else's project.
+*
+* @param pkgName - The npm package name, e.g. `"@org/cli"`.
+* @param binName - Which entry to resolve from that package's `bin` field.
+*                  Defaults to the package's own unscoped name.
+* @returns The absolute path to the resolved bin script.
+* @throws Error if the package or the requested bin entry can't be found.
+*/
+function resolveBinPath(pkgName, binName) {
+	const pkgJsonPath = require.resolve(`${pkgName}/package.json`);
+	const pkgDir = path.dirname(pkgJsonPath);
+	const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+	const key = binName ?? pkg.name.split("/").pop();
+	const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.[key];
+	if (!bin) throw new Error(`Could not resolve a "${key}" bin entry for package "${pkgName}" - is it installed, and does it expose that bin?`);
+	return path.join(pkgDir, bin);
+}
+//#endregion
+//#region src/git/git.ts
+/**
+* Execute a git command in a given working directory and return the result.
+*
+* @param args - The command-line arguments to pass to the git command.
+* @param cwd  - The working directory in which to execute the git command.
+* @returns The result of the git command.
+*
+* @see {@link GitResult} - The result of executing the git command.
+*/
+function git(args, cwd) {
+	const result = spawnSync("git", args, {
+		cwd,
+		encoding: "utf8"
+	});
+	return {
+		status: result.status ?? 1,
+		stdout: (result.stdout ?? "").trim(),
+		stderr: (result.stderr ?? "").trim()
+	};
+}
+/**
+* Check if a remote branch exists in the given repository.
+*
+* @param repoRoot - The root directory of the repository.
+* @param branch   - The name of the branch to check.
+* @returns Whether the remote branch exists (true) or not (false).
+*/
+function remoteBranchExists(repoRoot, branch) {
+	return git([
+		"ls-remote",
+		"--exit-code",
+		"--heads",
+		"origin",
+		branch
+	], repoRoot).status === 0;
+}
+/**
+* Check if a remote tag exists in the given repository.
+*
+* @param repoRoot - The root directory of the repository.
+* @param tag      - The name of the tag to check.
+* @returns Whether the remote tag exists (true) or not (false).
+*/
+function tagExists(repoRoot, tag) {
+	return git([
+		"ls-remote",
+		"--exit-code",
+		"--tags",
+		"origin",
+		tag
+	], repoRoot).status === 0;
+}
+/**
+* Fetch a single tag's object from origin into the local repo, without
+* fetching the rest of history/tags.
+*
+* @param repoRoot - The root directory of the repository.
+* @param tag      - The name of the tag to fetch.
+* @returns The result of the underlying `git fetch` command.
+*/
+function fetchTag(repoRoot, tag) {
+	return git([
+		"fetch",
+		"origin",
+		`refs/tags/${tag}:refs/tags/${tag}`,
+		"--force"
+	], repoRoot);
+}
+/**
+* Read a single file's content as it existed at a given git tag, without
+* checking out a worktree.
+*
+* Returns `null` (rather than throwing) both when the tag can't be fetched and
+* when the tag exists but doesn't contain the requested file - the latter is
+* expected for tags published before that file was introduced, and callers
+* should treat "unknown" the same as "no mismatch to report".
+*
+* @param repoRoot - The root directory of the repository.
+* @param tag      - The tag to read the file from.
+* @param filePath - The path of the file within that tag's tree.
+* @returns The file's content, or `null` if it couldn't be read.
+*/
+function readFileAtTag(repoRoot, tag, filePath) {
+	if (fetchTag(repoRoot, tag).status !== 0) return null;
+	const show = git(["show", `${tag}:${filePath}`], repoRoot);
+	return show.status === 0 ? show.stdout.trim() : null;
+}
+/**
+* Require that a git command succeeded, throwing an error with the given
+* message if it did not.
+*
+* @param result  - The result of the git command to check.
+* @param message - The error message to throw if the command failed.
+* @throws Error if the git command failed (non-zero exit code).
+*/
+function requireOk(result, message) {
+	if (result.status !== 0) throw new Error(`${message}: ${result.stderr || result.stdout}`);
+}
+//#endregion
+//#region src/version/version.ts
+/**
+* Resolves the version to stamp onto a single contract's generated SDK
+* artifacts (npm/Maven packages, Go module tags, git branches, etc.).
+*
+* The single source of truth is that contract's own `info.version` field in its
+* `openapi.yaml` - bump it there and every artifact, package, and git tag for
+* that contract picks up the new version on the next release. Versions are
+* resolved independently per contract: two services can be at different
+* versions at the same time.
+*
+* `SDK_VERSION_OVERRIDE` (wired up from the release workflow's manual `version`
+* input) bypasses the spec entirely and stamps every contract with the same
+* given value. It exists for one-off emergency republishes, not routine
+* releases. Routine releases should always go through `info.version`.
+*
+* @param spec         - The parsed, bundled OpenAPI document for the contract.
+* @param contractName - The contract name, used only for the error message.
+* @returns The resolved version string (no leading `v`).
+* @throws Error if no override is set and the spec has no `info.version`.
+*/
+function resolveVersion(spec, contractName) {
+	const override = process.env.SDK_VERSION_OVERRIDE?.trim();
+	if (override) return override.replace(/^v/, "");
+	const specVersion = spec.info?.version?.trim();
+	if (!specVersion) throw new Error(`specs/${contractName}/openapi.yaml is missing "info.version" - set it to a semver value. This field is the single source of truth for the ${contractName} contract's SDK version.`);
+	return specVersion.replace(/^v/, "");
+}
+/**
+* Computes a stable content hash of a bundled OpenAPI document's raw JSON text.
+* Stamped alongside `VERSION` into every generated SDK package so
+* `publish-sdk.ts` can tell a genuine no-op republish (same spec, same version)
+* apart from a spec that changed without its `info.version` being bumped.
+*
+* @param raw - The raw bundled spec file contents (JSON text).
+* @returns A `sha256` hex digest of the raw contents.
+*/
+function hashSpec(raw) {
+	return createHash("sha256").update(raw).digest("hex");
+}
+//#endregion
+//#region src/readme/default-templates.ts
+/**
+* Renders a sensible default `README.md` for a generated SDK package, used
+* whenever the artifact has no custom `readme:` template configured. Covers
+* every built-in `lang`/`kind` combination; anything more specific (house
+* install instructions, extra usage notes) belongs in a custom template
+* instead - see `readme-renderer.ts`. Registry URLs and branch/tag names
+* come from the artifact's resolved `publishing:` config, so a repo that
+* overrides its registry sees that reflected here automatically.
+*
+* @param args - The contract, artifact, version, and github/vars coordinates
+*               to render for.
+* @returns The rendered README content.
+*/
+function renderDefaultReadme({ contract, artifact, version, github, vars }) {
+	return `${`# ${contract.title} - ${label(artifact)}
+
+> Generated from \`${contract.entrypointRelative}\` in [${github.owner}/${github.repo}](https://github.com/${github.owner}/${github.repo}).
+> Do not edit by hand - this package is regenerated and republished on every release.
+
+Version: \`${version}\`
+Source branch: \`${artifact.branch}\`
+`}\n${body(contract, artifact, version, github, vars)}\n`;
+}
+function label(artifact) {
+	return `${{
+		typescript: "TypeScript",
+		go: "Go",
+		java: "Java"
+	}[artifact.lang]} ${artifact.kind === "client" ? "Client SDK" : artifact.lang === "typescript" ? "Server Types" : "Server Stubs"}`;
+}
+function body(contract, artifact, version, github, vars) {
+	switch (`${artifact.lang}-${artifact.kind}`) {
+		case "typescript-client": return tsClient(artifact, version);
+		case "typescript-server": return tsServer(artifact, version);
+		case "go-client": return goClient(contract, artifact, github, vars);
+		case "go-server": return goServer(artifact);
+		case "java-client": return javaClient(artifact, version);
+		case "java-server": return javaServer(artifact, version);
+		default: return "";
+	}
+}
+function tsClient(artifact, version) {
+	return `## Install
+
+\`\`\`bash
+npm config set <scope>:registry ${artifact.publishing.npmRegistry}
+npm install ${artifact.package}@${version}
+\`\`\`
+
+(Requires an authenticated \`.npmrc\` with a token for that registry.)
+
+## Usage
+
+\`\`\`ts
+import { Configuration, DefaultApi } from "${artifact.package}";
+
+const api = new DefaultApi(
+  new Configuration({ basePath: "https://api.your-domain.com" }),
+);
+
+const result = await api.someOperation();
+\`\`\`
+`;
+}
+function tsServer(artifact, version) {
+	return `## Install
+
+\`\`\`bash
+npm config set <scope>:registry ${artifact.publishing.npmRegistry}
+npm install --save-dev ${artifact.package}@${version}
+\`\`\`
+
+(Requires an authenticated \`.npmrc\` with a token for that registry.)
+
+## Usage
+
+\`\`\`ts
+import type { components, operations } from "${artifact.package}";
+
+type LoginResponses = operations["login"]["responses"];
+
+// Example: an Express handler typed against the contract
+app.post("/login", (req, res) => {
+  const body = req.body as components["schemas"]["LoginRequest"];
+  const response: LoginResponses[200]["content"]["application/json"] = {
+    // ...
+  };
+  res.json(response);
+});
+\`\`\`
+`;
+}
+function goClient(contract, artifact, github, vars) {
+	const exampleTag = renderArtifactTag(artifact, contract.name, "<version>", github, vars);
+	return `## Install
+
+Go has no package registry, so this module is pulled directly from its
+publishing branch:
+
+\`\`\`bash
+go get ${artifact.goModule}@${artifact.branch}
+\`\`\`
+
+To pin an exact release instead of the branch head, use the matching tag:
+
+\`\`\`bash
+go get ${artifact.goModule}@${exampleTag}
+\`\`\`
+
+## Usage
+
+\`\`\`go
+import (
+    "context"
+
+    ${artifact.goPackageName} "${artifact.goModule}"
+)
+
+func main() {
+    cfg := ${artifact.goPackageName}.NewConfiguration()
+    client := ${artifact.goPackageName}.NewAPIClient(cfg)
+
+    resp, _, err := client.DefaultAPI.SomeOperation(context.Background()).Execute()
+    _ = resp
+    _ = err
+}
+\`\`\`
+`;
+}
+function goServer(artifact) {
+	return `## Install
+
+\`\`\`bash
+go get ${artifact.goModule}@${artifact.branch}
+\`\`\`
+
+## Usage
+
+Implement the generated \`${artifact.goPackageName}.*ApiServicer\` interfaces and
+wire them into the generated router:
+
+\`\`\`go
+router := ${artifact.goPackageName}.NewRouter(
+    ${artifact.goPackageName}.NewSomeApiController(yourServiceImpl),
+)
+\`\`\`
+`;
+}
+function javaClient(artifact, version) {
+	return `## Install (Maven)
+
+\`\`\`xml
+<dependency>
+  <groupId>${artifact.maven?.groupId}</groupId>
+  <artifactId>${artifact.maven?.artifactId}</artifactId>
+  <version>${version}</version>
+</dependency>
+\`\`\`
+
+Add the repository to your \`settings.xml\` (or \`pom.xml\`) with credentials
+for that repository:
+
+\`\`\`xml
+<repository>
+  <id>${artifact.publishing.mavenRepositoryId}</id>
+  <url>${artifact.publishing.mavenRepositoryUrl}</url>
+</repository>
+\`\`\`
+
+## Usage
+
+Generated with \`library=restclient\` - Spring's \`RestClient\`, the current
+recommended synchronous HTTP client for Spring apps:
+
+\`\`\`java
+@Configuration
+public class SomeServiceClientConfig {
+
+    @Bean
+    public ApiClient someServiceApiClient(RestClient.Builder builder) {
+        ApiClient client = new ApiClient(builder.build());
+        client.setBasePath("https://api.your-domain.com");
+        return client;
+    }
+
+    @Bean
+    public DefaultApi someServiceApi(ApiClient someServiceApiClient) {
+        return new DefaultApi(someServiceApiClient);
+    }
+}
+\`\`\`
+`;
+}
+function javaServer(artifact, version) {
+	return `## Install (Maven)
+
+\`\`\`xml
+<dependency>
+  <groupId>${artifact.maven?.groupId}</groupId>
+  <artifactId>${artifact.maven?.artifactId}</artifactId>
+  <version>${version}</version>
+</dependency>
+\`\`\`
+
+Add the repository to your \`settings.xml\` (or \`pom.xml\`) with credentials
+for that repository:
+
+\`\`\`xml
+<repository>
+  <id>${artifact.publishing.mavenRepositoryId}</id>
+  <url>${artifact.publishing.mavenRepositoryUrl}</url>
+</repository>
+\`\`\`
+
+## Usage
+
+This artifact only contains the generated Spring \`@RestController\` interfaces
+(\`interfaceOnly=true\`) - implement them in your service:
+
+\`\`\`java
+@RestController
+public class SomeController implements SomeApi {
+    // interface methods generated from the OpenAPI contract
+}
+\`\`\`
+`;
+}
+//#endregion
+//#region src/readme/readme-renderer.ts
+/**
+* Renders the root-level `README.md` for a generated SDK package.
+*
+* If the artifact has a `readme:` path configured (resolved at config-load time
+* to `artifact.readmeTemplate`), that file is read and interpolated with the
+* same `{...}` placeholder engine naming templates use - `{service}`,
+* `{title}`, `{version}`, `{vars.*}`, `{github.owner}`, `{github.repo}`, plus
+* `{artifact.*}` (id/lang/kind/package/goModule/goPackageName/maven.groupId/
+* maven.artifactId/branch/tag/npmRegistry/mavenRepositoryUrl). Otherwise,
+* falls back to a built-in default template for the artifact's language/kind.
+*
+* @param args - The contract, artifact, version, and github/vars context to
+*               render for.
+* @returns The rendered README content.
+*/
+async function renderReadme(args) {
+	if (!args.artifact.readmeTemplate) return renderDefaultReadme(args);
+	return interpolate(await readFile(args.artifact.readmeTemplate, "utf8"), buildTemplateContext({
+		service: args.contract.name,
+		title: args.contract.title,
+		version: args.version,
+		github: args.github,
+		vars: args.vars,
+		artifact: {
+			id: args.artifact.id,
+			lang: args.artifact.lang,
+			kind: args.artifact.kind,
+			package: args.artifact.package,
+			goModule: args.artifact.goModule,
+			goPackageName: args.artifact.goPackageName,
+			maven: args.artifact.maven,
+			branch: args.artifact.branch,
+			tag: renderArtifactTag(args.artifact, args.contract.name, args.version, args.github, args.vars),
+			npmRegistry: args.artifact.publishing.npmRegistry,
+			mavenRepositoryUrl: args.artifact.publishing.mavenRepositoryUrl
+		}
+	}));
+}
+//#endregion
+//#region src/redocly/redocly-sync.ts
+const GENERATED_HEADER = "# AUTO-GENERATED by Seagull from its config and 'redocly.base.yaml'.\n# Do not edit directly, edit those two files instead (this file is\n# regenerated on every lint/bundle/generate run).\n\n";
+/**
+* Regenerates `redocly.yaml`'s `apis:` section from the resolved CLI config,
+* merging it with the hand-authored `extends`/`rules` in `redocly.base.yaml`.
+*
+* The CLI config stays the single source of truth for which APIs exist and
+* where their TypeScript server types land, instead of that being duplicated
+* by hand into `redocly.yaml`.
+*
+* Called at the start of every command that shells out to `redocly` or
+* `openapi-typescript` (both read `redocly.yaml` directly), so it's always
+* up to date before those tools run.
+*
+* @param config - The resolved CLI config.
+*/
+async function syncRedoclyConfig(config) {
+	const basePath = path.join(config.rootDir, "redocly.base.yaml");
+	const base = parse(await readFile(basePath, "utf8"));
+	const apis = Object.fromEntries(config.contracts.map((contract) => {
+		const typesArtifact = contract.artifacts.find((artifact) => artifact.tool === "openapi-typescript");
+		return [`${contract.name}@v1`, {
+			root: contract.entrypointRelative,
+			...typesArtifact ? { "x-openapi-ts": { output: path.join(path.relative(config.rootDir, typesArtifact.outputDir), "index.d.ts") } } : {}
+		}];
+	}));
+	const final = {
+		extends: base.extends,
+		apis,
+		rules: base.rules
+	};
+	await writeFile(path.join(config.rootDir, "redocly.yaml"), GENERATED_HEADER + stringify(final));
+}
+//#endregion
+//#region src/generators/openapi-generator-cli/patchers/go-module.patcher.ts
+/**
+* Patches the `go.mod` file in a generated Go SDK package to set the correct
+* module path (`openapi-generator-cli` has no way to be told this up front for
+* every template).
+*/
+var GoModulePatcher = class {
+	async patch({ artifact }) {
+		if (!artifact.goModule) return;
+		const moduleFile = path.join(artifact.outputDir, "go.mod");
+		try {
+			const contents = await readFile(moduleFile, "utf8");
+			await writeFile(moduleFile, contents.replace(/^module .*$/m, `module ${artifact.goModule}`));
+		} catch {}
+	}
+};
+//#endregion
+//#region src/generators/openapi-generator-cli/patchers/maven.patcher.ts
+/**
+* Patches the `pom.xml` file in a generated Java SDK package to set the correct
+* version and distribution management information for publishing, using the
+* artifact's resolved `publishing:` config rather than a hardcoded registry.
+*/
+var MavenPomPatcher = class {
+	async patch({ artifact, version }) {
+		const pomFile = path.join(artifact.outputDir, "pom.xml");
+		try {
+			let pom = await readFile(pomFile, "utf8");
+			pom = pom.replace(/<version>[^<]*<\/version>/, `<version>${version}</version>`);
+			if (!pom.includes("<distributionManagement>")) pom = pom.replace("</project>", [
+				"  <distributionManagement>",
+				"    <repository>",
+				`      <id>${artifact.publishing.mavenRepositoryId}</id>`,
+				`      <url>${artifact.publishing.mavenRepositoryUrl}</url>`,
+				"    </repository>",
+				"  </distributionManagement>",
+				"</project>"
+			].join("\n"));
+			await writeFile(pomFile, pom);
+		} catch {}
+	}
+};
+//#endregion
+//#region src/generators/openapi-generator-cli/patchers/npm.patcher.ts
+/**
+* Patches the `package.json` file in a generated TypeScript SDK package (the
+* client target - `openapi-generator-cli` produces its own `package.json`, this
+* just fills in the version and publishing metadata) to set the correct version
+* and repository information, using the artifact's resolved `publishing:`
+* config rather than a hardcoded registry.
+*/
+var NpmPackagePatcher = class {
+	async patch({ artifact, version }) {
+		const pkgFile = path.join(artifact.outputDir, "package.json");
+		const pkgData = await readFile(pkgFile, "utf8");
+		const pkg = JSON.parse(pkgData);
+		pkg.version = version;
+		pkg.repository = {
+			type: "git",
+			url: `git+${artifact.publishing.repositoryUrl}.git`
+		};
+		pkg.publishConfig = {
+			registry: artifact.publishing.npmRegistry,
+			access: artifact.publishing.npmAccess
+		};
+		await writeFile(pkgFile, JSON.stringify(pkg, null, 2));
+	}
+};
+//#endregion
+//#region src/generators/openapi-generator-cli/openapi-generator-cli.generator.ts
+/**
+* Additional-properties that are fully derivable from an artifact's own
+* `package`/`goPackageName`/`maven` fields - conventional openapi-generator
+* knobs (`npmName`, `groupId`, ...) that would otherwise have to be duplicated
+* by hand in every generator's `additionalProperties:` block, in lockstep with
+* those same fields. Tool-specific tuning that isn't derivable this way
+* (`library=restclient`, `withGoMod`, ...) still lives in
+* `additionalProperties:` and is layered on top of these.
+*
+* @param artifact - The resolved artifact to derive properties for.
+* @returns The derived additional-properties, before the artifact's own
+*          `additionalProperties` are layered on top.
+*/
+function deriveAdditionalProperties(artifact) {
+	if (artifact.lang === "typescript" && artifact.package) return { npmName: artifact.package };
+	if (artifact.lang === "go" && artifact.goPackageName) return { packageName: artifact.goPackageName };
+	if (artifact.lang === "java" && artifact.maven) {
+		const invokerPackage = `${artifact.maven.groupId}.${artifact.kind}`;
+		return {
+			groupId: artifact.maven.groupId,
+			artifactId: artifact.maven.artifactId,
+			invokerPackage,
+			apiPackage: `${invokerPackage}.api`,
+			modelPackage: `${invokerPackage}.model`
+		};
+	}
+	return {};
+}
+/**
+* Renders an artifact's additional-properties (derived + explicit, explicit
+* wins on conflicts) as the `key=value,key=value` string
+* `openapi-generator-cli --additional-properties` expects.
+*
+* @param artifact - The resolved artifact.
+* @returns The rendered `--additional-properties` value.
+*/
+function buildAdditionalPropertiesArg(artifact) {
+	const merged = {
+		...deriveAdditionalProperties(artifact),
+		...artifact.additionalProperties
+	};
+	return Object.entries(merged).map(([key, value]) => `${key}=${String(value)}`).join(",");
+}
+/**
+* Wraps `openapi-generator-cli` - the single tool implementation behind every
+* `-g` template (`typescript-fetch`, `go`, `go-server`, `java`, `spring`, ...),
+* regardless of language. Language-specific output patching is delegated to a
+* {@link Patcher}, selected by `artifact.lang`.
+*/
+var OpenApiGeneratorCli = class extends Generator {
+	tool = "openapi-generator";
+	patchers = {
+		go: new GoModulePatcher(),
+		typescript: new NpmPackagePatcher(),
+		java: new MavenPomPatcher()
+	};
+	async generate(ctx) {
+		const { artifact, rootDir, specInputPath } = ctx;
+		if (!artifact.generator) throw new Error(`Artifact "${artifact.id}" uses tool "openapi-generator" but has no "generator" value`);
+		await mkdir(artifact.outputDir, { recursive: true });
+		await run("node", [
+			resolveBinPath("@openapitools/openapi-generator-cli", "openapi-generator-cli"),
+			"generate",
+			"-i",
+			specInputPath,
+			"-g",
+			artifact.generator,
+			"-o",
+			artifact.outputDir,
+			`--additional-properties=${buildAdditionalPropertiesArg(artifact)}`
+		], rootDir);
+		await this.patchers[artifact.lang]?.patch(ctx);
+	}
+};
+//#endregion
+//#region src/generators/openapi-typescript/openapi-typescript.generator.ts
+/**
+* Wraps `openapi-typescript`. Unlike `openapi-generator-cli`, it isn't invoked
+* once per artifact - it reads `redocly.yaml`'s `apis:` map (kept in sync with
+* the CLI config by `core/redocly/redocly-sync.ts`) and writes every contract's
+* `index.d.ts` to its configured `x-openapi-ts.output` path in a single run,
+* so that single global invocation happens once in {@link prepare}.
+* {@link generate} then only has to write each artifact's package.json` -
+* `openapi-typescript` emits `index.d.ts` alone, with no package manifest of
+* its own to patch.
+*/
+var OpenApiTypescriptGenerator = class extends Generator {
+	tool = "openapi-typescript";
+	async prepare({ rootDir, entries }) {
+		await Promise.all(entries.map((entry) => mkdir(entry.artifact.outputDir, { recursive: true })));
+		await run("node", [resolveBinPath("openapi-typescript", "openapi-typescript")], rootDir);
+	}
+	async generate({ contract, artifact, version }) {
+		const pkg = {
+			name: artifact.package,
+			version,
+			description: `Types-only OpenAPI contract for the ${contract.name} service.`,
+			types: "./index.d.ts",
+			files: ["index.d.ts"],
+			license: "MIT",
+			repository: {
+				type: "git",
+				url: `git+${artifact.publishing.repositoryUrl}.git`
+			},
+			publishConfig: {
+				registry: artifact.publishing.npmRegistry,
+				access: artifact.publishing.npmAccess
+			}
+		};
+		await writeFile(path.join(artifact.outputDir, "package.json"), JSON.stringify(pkg, null, 2));
+	}
+};
+//#endregion
+export { CONFIG_FILENAMES, CONFIG_SCHEMA_VERSION, Generator, GeneratorRegistry, OpenApiGeneratorCli, OpenApiTypescriptGenerator, git, hashSpec, loadConfig, readFileAtTag, remoteBranchExists, renderArtifactTag, renderReadme, requireOk, resolveBinPath, resolveConfigPath, resolveVersion, run, runSync, syncRedoclyConfig, tagExists };
+
+//# sourceMappingURL=index.mjs.map