@octalmesh/seagull-core 0.0.2 → 0.1.1

package/dist/index.mjs

@@ -21,15 +21,14 @@ const varsTreeSchema = z.lazy(() => z.record(z.string(), z.union([
 	z.boolean(),
 	varsTreeSchema
 ])));
-const githubSchema = z.object({
-	owner: z.string().min(1),
-	repo: z.string().min(1)
-});
+const specFormatSchema = z.enum(["json", "yaml"]);
+const specFormatListSchema = z.union([specFormatSchema, z.array(specFormatSchema).min(1)]).default("json").transform((value) => Array.isArray(value) ? value : [value]).refine((formats) => new Set(formats).size === formats.length, { message: "paths.specFormat entries must be unique" });
 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()
+	sdk: z.string().min(1).optional(),
+	specFormat: specFormatListSchema
 });
 const docsSchema = z.object({
 	server: z.object({
@@ -66,8 +65,8 @@ const mavenCoordsSchema = z.object({
 /**
 * 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}`).
+* usual `{...}` placeholders (`{service}`, `{id}`, `{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
@@ -91,7 +90,7 @@ const publishingSchema = z.object({
 	/**
 	* 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}"`.
+	* `"https://github.com/{vars.repository.owner}/{vars.repository.repo}"`.
 	*/
 	repositoryUrl: z.string().min(1),
 	npm: z.object({
@@ -207,13 +206,15 @@ const contractSchema = z.object({
 });
 const rootConfigSchema = z.object({
 	/**
-	* The config schema version this file targets. Currently must be `1`
+	* 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" }),
+	paths: pathsSchema.default({
+		dist: "dist",
+		specFormat: ["json"]
+	}),
 	docs: docsSchema,
 	/**
 	* Publishing conventions (branch/tag naming, registry URLs), applied to
@@ -226,6 +227,131 @@ const rootConfigSchema = z.object({
 	contracts: z.array(contractSchema).min(1)
 });
 //#endregion
+//#region src/git/git.ts
+/**
+* A git ref name (branch or tag) that's safe to pass as a CLI argument to
+* `git`.
+*
+* @see {@link assertSafeRefName}
+*/
+const gitRefNameSchema = z.string().min(1).refine((value) => !value.startsWith("-"), { message: "must not start with \"-\" - git would parse it as a command-line option instead of a ref name" });
+/**
+* Throws if `name` isn't a safe git ref name - see {@link gitRefNameSchema}.
+*
+* @param name  - The candidate branch/tag name.
+* @param label - What to call it in the error message (e.g. `"branch"`).
+*/
+function assertSafeRefName(name, label) {
+	const result = gitRefNameSchema.safeParse(name);
+	if (!result.success) throw new Error(`Invalid git ${label} "${name}": ${result.error.issues[0]?.message}`);
+}
+/**
+* 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) {
+	assertSafeRefName(branch, "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) {
+	assertSafeRefName(tag, "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) {
+	assertSafeRefName(tag, "tag");
+	return git([
+		"fetch",
+		"origin",
+		"--force",
+		"--",
+		`refs/tags/${tag}:refs/tags/${tag}`
+	], 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) {
+	assertSafeRefName(tag, "tag");
+	if (filePath.length === 0) throw new Error("Invalid git file path: must not be empty");
+	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/config/template.ts
 const PLACEHOLDER = /\{([a-zA-Z0-9_.]+)}/g;
 /**
@@ -295,7 +421,7 @@ function flatten(value, prefix, out) {
 * @returns The validated (but not yet resolved) raw config.
 */
 function readRawConfig(configPath) {
-	const raw = parse(readFileSync(configPath, "utf8"));
+	const raw = parse(readFileSync(configPath, "utf8"), { merge: true });
 	const result = rootConfigSchema.safeParse(raw);
 	if (!result.success) {
 		const issues = z.prettifyError(result.error);
@@ -413,13 +539,19 @@ function resolveArtifactRef(ref, generators, contractName) {
 * @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.*`).
+*                              (`service`, `id`, `vars.*`).
+* @param artifactLabel       - `"<contract>/<artifact id>"`, used only to
+*                              identify the offending artifact in the error
+*                              thrown when `branch` resolves unsafely - see
+*                              {@link assertSafeRefName}.
 * @returns The fully resolved publishing conventions for this artifact.
 */
-function resolvePublishing(generatorPublishing, rootPublishing, context) {
+function resolvePublishing(generatorPublishing, rootPublishing, context, artifactLabel) {
 	const merged = applyPublishingOverride(rootPublishing, generatorPublishing);
+	const branch = interpolate(merged.branch, context);
+	assertSafeRefName(branch, `publishing.branch for artifact "${artifactLabel}"`);
 	return {
-		branch: interpolate(merged.branch, context),
+		branch,
 		tagTemplate: merged.tag,
 		repositoryUrl: interpolate(merged.repositoryUrl, context),
 		npmRegistry: interpolate(merged.npm.registry, context),
@@ -440,7 +572,7 @@ function resolvePublishing(generatorPublishing, rootPublishing, context) {
 * @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`).
+*                          (`service`, `vars.*` - not yet `id`).
 * @param rootPublishing  - The required root-level `publishing:` config from
 *                          the config file.
 * @returns The fully resolved artifact.
@@ -451,7 +583,7 @@ function resolveArtifact(id, def, rootDir, sdkDir, contractName, contractContext
 		id
 	};
 	const resolved = interpolateDeep(def, context);
-	const publishing = resolvePublishing(def.publishing, rootPublishing, context);
+	const publishing = resolvePublishing(def.publishing, rootPublishing, context, `${contractName}/${id}`);
 	return {
 		id,
 		tool: resolved.tool,
@@ -478,18 +610,15 @@ function resolveArtifact(id, def, rootDir, sdkDir, contractName, contractContext
 *                         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) {
+function resolveContract(input, rootDir, sdkDir, generators, vars, rootPublishing) {
 	const context = buildTemplateContext({
 		service: input.name,
-		github: githubCtx,
 		vars
 	});
 	const artifacts = input.artifacts.map((ref) => {
@@ -525,7 +654,7 @@ function loadConfig(configPath) {
 	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));
+	const contracts = raw.contracts.map((contract) => resolveContract(contract, rootDir, sdkDir, raw.generators, raw.vars, raw.publishing));
 	return {
 		configVersion: raw.configVersion,
 		rootDir,
@@ -533,9 +662,9 @@ function loadConfig(configPath) {
 			dist: distDir,
 			specs: specsDir,
 			docs: docsDir,
-			sdk: sdkDir
+			sdk: sdkDir,
+			specFormat: raw.paths.specFormat
 		},
-		github: raw.github,
 		vars: raw.vars,
 		docs: raw.docs,
 		contracts,
@@ -559,20 +688,19 @@ function loadConfig(configPath) {
 *                       `{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) {
+function renderArtifactTag(artifact, contractName, version, vars) {
 	const context = buildTemplateContext({
 		service: contractName,
 		id: artifact.id,
 		version,
-		github,
 		vars
 	});
-	return interpolate(artifact.publishing.tagTemplate, context);
+	const tag = interpolate(artifact.publishing.tagTemplate, context);
+	assertSafeRefName(tag, `publishing.tag for artifact "${contractName}/${artifact.id}"`);
+	return tag;
 }
 //#endregion
 //#region src/config/resolve-config-file.ts
@@ -604,6 +732,46 @@ function resolveConfigPath(cwd) {
 	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/config/spec-format.ts
+/**
+* The "primary" format among a `paths.specFormat` list - the one SDK generation,
+* version/hash resolution, and the docs site actually read from when more than
+* one format is configured. By convention, that's whichever format was listed
+* first.
+*
+* @param formats - `config.paths.specFormat` (always non-empty).
+* @returns The primary format.
+*/
+function primarySpecFormat(formats) {
+	return formats[0];
+}
+/**
+* The filename a contract's bundled spec is written to/read from, e.g.
+* `auth.json` or `auth.yaml` - one place computing this so `bundle`, `generate`,
+* and `docs generate` can't disagree about the extension.
+*
+* @param contractName - The contract's `name`.
+* @param format       - `config.paths.specFormat`.
+* @returns The filename (no directory), e.g. `"auth.yaml"`.
+*/
+function specFilename(contractName, format) {
+	return `${contractName}.${format}`;
+}
+/**
+* Parses a bundled spec's raw file contents according to its configured format.
+* JSON and YAML are both valid inputs to Redocly/openapi-generator/
+* openapi-typescript, so seagull's own parsing has to match: `JSON.parse`
+* rejects trailing commas and comments that valid YAML permits, and would
+* silently misparse a YAML document that happens to look JSON-ish.
+*
+* @param raw    - The raw bundled spec file contents.
+* @param format - `config.paths.specFormat`.
+* @returns The parsed document.
+*/
+function parseBundledSpec(raw, format) {
+	return format === "json" ? JSON.parse(raw) : parse(raw, { merge: true });
+}
+//#endregion
 //#region src/generator/generator.ts
 /**
 * The root primitive every concrete SDK generator implements.
@@ -677,8 +845,7 @@ function run(command, args, cwd) {
 	return new Promise((resolvePromise, reject) => {
 		spawn(command, args, {
 			cwd,
-			stdio: "inherit",
-			shell: true
+			stdio: "inherit"
 		}).on("close", (code) => {
 			if (code === 0) {
 				resolvePromise();
@@ -700,8 +867,7 @@ function run(command, args, cwd) {
 function runSync(command, args, cwd) {
 	return spawnSync(command, args, {
 		cwd,
-		stdio: "inherit",
-		shell: true
+		stdio: "inherit"
 	}).status ?? 1;
 }
 //#endregion
@@ -732,106 +898,6 @@ function resolveBinPath(pkgName, binName) {
 	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
@@ -861,12 +927,14 @@ function resolveVersion(spec, contractName) {
 	return specVersion.replace(/^v/, "");
 }
 /**
-* Computes a stable content hash of a bundled OpenAPI document's raw JSON text.
+* Computes a stable content hash of a bundled OpenAPI document's raw file
+* contents (JSON or YAML, whichever `paths.specFormat` produced).
+*
 * 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).
+* @param raw - The raw bundled spec file contents.
 * @returns A `sha256` hex digest of the raw contents.
 */
 function hashSpec(raw) {
@@ -883,19 +951,19 @@ function hashSpec(raw) {
 * 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.
+* @param args - The contract, artifact, version, and vars coordinates to render
+*               for.
 * @returns The rendered README content.
 */
-function renderDefaultReadme({ contract, artifact, version, github, vars }) {
+function renderDefaultReadme({ contract, artifact, version, vars }) {
 	return `${`# ${contract.title} - ${label(artifact)}
 
-> Generated from \`${contract.entrypointRelative}\` in [${github.owner}/${github.repo}](https://github.com/${github.owner}/${github.repo}).
+> Generated from \`${contract.entrypointRelative}\` in ${artifact.publishing.repositoryUrl}.
 > 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`;
+`}\n${body(contract, artifact, version, vars)}\n`;
 }
 function label(artifact) {
 	return `${{
@@ -904,11 +972,11 @@ function label(artifact) {
 		java: "Java"
 	}[artifact.lang]} ${artifact.kind === "client" ? "Client SDK" : artifact.lang === "typescript" ? "Server Types" : "Server Stubs"}`;
 }
-function body(contract, artifact, version, github, vars) {
+function body(contract, artifact, version, 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-client": return goClient(contract, artifact, vars);
 		case "go-server": return goServer(artifact);
 		case "java-client": return javaClient(artifact, version);
 		case "java-server": return javaServer(artifact, version);
@@ -966,8 +1034,8 @@ app.post("/login", (req, res) => {
 \`\`\`
 `;
 }
-function goClient(contract, artifact, github, vars) {
-	const exampleTag = renderArtifactTag(artifact, contract.name, "<version>", github, vars);
+function goClient(contract, artifact, vars) {
+	const exampleTag = renderArtifactTag(artifact, contract.name, "<version>", vars);
 	return `## Install
 
 Go has no package registry, so this module is pulled directly from its
@@ -1109,13 +1177,12 @@ public class SomeController implements SomeApi {
 * 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/
+* `{title}`, `{version}`, `{vars.*}`, 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.
+* @param args - The contract, artifact, version, and vars context to render for.
 * @returns The rendered README content.
 */
 async function renderReadme(args) {
@@ -1124,7 +1191,6 @@ async function renderReadme(args) {
 		service: args.contract.name,
 		title: args.contract.title,
 		version: args.version,
-		github: args.github,
 		vars: args.vars,
 		artifact: {
 			id: args.artifact.id,
@@ -1135,7 +1201,7 @@ async function renderReadme(args) {
 			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),
+			tag: renderArtifactTag(args.artifact, args.contract.name, args.version, args.vars),
 			npmRegistry: args.artifact.publishing.npmRegistry,
 			mavenRepositoryUrl: args.artifact.publishing.mavenRepositoryUrl
 		}
@@ -1160,7 +1226,7 @@ const GENERATED_HEADER = "# AUTO-GENERATED by Seagull from its config and 'redoc
 */
 async function syncRedoclyConfig(config) {
 	const basePath = path.join(config.rootDir, "redocly.base.yaml");
-	const base = parse(await readFile(basePath, "utf8"));
+	const base = parse(await readFile(basePath, "utf8"), { merge: true });
 	const apis = Object.fromEntries(config.contracts.map((contract) => {
 		const typesArtifact = contract.artifacts.find((artifact) => artifact.tool === "openapi-typescript");
 		return [`${contract.name}@v1`, {
@@ -1359,6 +1425,6 @@ var OpenApiTypescriptGenerator = class extends Generator {
 	}
 };
 //#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 };
+export { CONFIG_FILENAMES, CONFIG_SCHEMA_VERSION, Generator, GeneratorRegistry, OpenApiGeneratorCli, OpenApiTypescriptGenerator, assertSafeRefName, git, gitRefNameSchema, hashSpec, loadConfig, parseBundledSpec, primarySpecFormat, readFileAtTag, remoteBranchExists, renderArtifactTag, renderReadme, requireOk, resolveBinPath, resolveConfigPath, resolveVersion, run, runSync, specFilename, syncRedoclyConfig, tagExists };
 
 //# sourceMappingURL=index.mjs.map

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@octalmesh/seagull-core",
-  "version": "0.0.2",
-  "description": "The Seagull engine - config loading and SDK generators - as an internal library.",
+  "version": "0.1.1",
+  "description": "The Seagull engine.",
   "author": "OctalMesh <contact@octalmesh.com> (https://octalmesh.com)",
   "license": "MIT",
-  "homepage": "https://github.com/OctalMesh/Seagull/tree/main/packages/core",
+  "homepage": "https://developers.octalmesh.com/seagull",
   "type": "module",
   "repository": {
     "type": "git",
@@ -32,10 +32,10 @@
   },
   "dependencies": {
     "@openapitools/openapi-generator-cli": "^2.41.0",
-    "@redocly/cli": "^2.51.1",
+    "@redocly/cli": "^2.52.1",
     "openapi-typescript": "^7.13.0",
-    "yaml": "^2.9.0",
-    "zod": "^4.5.4"
+    "yaml": "^2.9.1",
+    "zod": "^4.6.4"
   },
   "scripts": {
     "build": "tsdown",