@postman/sdk-config 0.0.4 → 0.1.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import semver from 'semver';
 
-// src/sdk-config-ir/v1/api.ts
+// src/sdk-config-domain/v1/api.ts
 var nonEmptyStringSchema = z.string().min(1);
 var exactSemverSchema = z.string().refine(
   (value) => {
@@ -25,7 +25,7 @@ var jsonValueSchema = z.lazy(
 );
 var jsonObjectSchema = z.record(z.string(), jsonValueSchema);
 
-// src/sdk-config-ir/v1/api.ts
+// src/sdk-config-domain/v1/api.ts
 var authVariableSchema = z.strictObject({
   name: nonEmptyStringSchema.optional(),
   environmentVariable: nonEmptyStringSchema.optional(),
@@ -175,8 +175,20 @@ var apiConfigSchema = z.strictObject({
   environmentVariables: z.array(environmentVariableSchema).default([]),
   defaultEnvironment: nonEmptyStringSchema.optional(),
   auth: authConfigSchema.optional(),
-  headers: z.array(headerSchema).optional()
+  headers: z.array(headerSchema).optional(),
+  /**
+   * Selects the named `x-fern-audiences`.
+   *
+   * Absent means all audiences. A present empty array selects no tagged audience: untagged nodes
+   * remain included, while every audience-tagged node is excluded.
+   */
+  audiences: z.array(nonEmptyStringSchema).optional()
 });
+
+// src/sdk-config/v1/api.ts
+var sdkConfigV1AuthSchemeSchema = authSchemeSchema;
+var sdkConfigV1AuthConfigSchema = authConfigSchema;
+var sdkConfigV1ApiConfigSchema = apiConfigSchema;
 var retryConfigSchema = z.strictObject({
   enabled: z.boolean().default(true),
   maxAttempts: z.number().int().min(1).default(3),
@@ -229,34 +241,89 @@ var clientConfigSchema = z.strictObject({
   pathParameterStyle: parameterStyleSchema.optional(),
   filePropertyStyle: parameterStyleSchema.optional(),
   useDefaultRequestParameterValues: z.boolean().optional(),
+  respectOptionalRequestBody: z.boolean().optional(),
   tokenRefresh: tokenRefreshConfigSchema.optional()
 });
-var unsupportedFieldSchema = z.strictObject({
-  source: z.enum(["fern", "postman", "sdk-config-ir"]),
-  path: z.array(z.union([nonEmptyStringSchema, z.number().int().nonnegative()])).min(1),
-  code: nonEmptyStringSchema.optional(),
-  reason: nonEmptyStringSchema,
-  severity: z.enum(["error", "warning", "info"]),
-  risk: z.enum(["high", "medium", "low"]),
-  owner: nonEmptyStringSchema,
-  suggestedAction: nonEmptyStringSchema
+
+// src/sdk-config/v1/client.ts
+var sdkConfigV1ClientConfigSchema = clientConfigSchema;
+var goModulePathSchema = nonEmptyStringSchema.regex(
+  /^(?!.*(?:^|\/)\.{1,2}(?:\/|$))[A-Za-z0-9._~-]+(?:\/[A-Za-z0-9._~-]+)+$/,
+  "Go module path must be a slash-delimited path using letters, numbers, dots, dashes, underscores, or tildes"
+);
+var composerPackageNameSchema = nonEmptyStringSchema.regex(
+  /^[a-z0-9]([_.-]?[a-z0-9]+)*\/[a-z0-9](([_.]?|-{0,2})[a-z0-9]+)*$/,
+  'Composer package name must be a lowercase "vendor/package" name'
+);
+var authorSchema = z.strictObject({
+  name: nonEmptyStringSchema,
+  email: z.email().optional()
 });
-var postmanLegacyInputSchema = z.strictObject({
-  kind: z.literal("postman-build-parameters"),
-  value: jsonObjectSchema
+var developerSchema = z.strictObject({
+  name: nonEmptyStringSchema,
+  email: z.email().optional(),
+  organization: nonEmptyStringSchema.optional(),
+  organizationUrl: nonEmptyStringSchema.optional()
 });
-var fernLegacyInputSchema = z.strictObject({
-  kind: z.literal("fern-generator-invocation"),
-  value: jsonObjectSchema
+var licenseSchema = z.strictObject({
+  type: nonEmptyStringSchema,
+  name: nonEmptyStringSchema.optional(),
+  url: nonEmptyStringSchema.optional(),
+  path: nonEmptyStringSchema.optional()
 });
-var legacyInputSchema = z.discriminatedUnion("kind", [
-  postmanLegacyInputSchema,
-  fernLegacyInputSchema
+var dependencySourceSchema = z.discriminatedUnion("type", [
+  z.strictObject({
+    type: z.literal("registry"),
+    registry: nonEmptyStringSchema.optional()
+  }),
+  z.strictObject({
+    type: z.literal("git"),
+    url: nonEmptyStringSchema,
+    ref: nonEmptyStringSchema.optional(),
+    subdirectory: nonEmptyStringSchema.optional()
+  }),
+  z.strictObject({
+    type: z.literal("path"),
+    path: nonEmptyStringSchema
+  })
 ]);
-var compatibilityConfigSchema = z.strictObject({
-  outputProfile: z.enum(["converged", "postman-legacy", "fern-legacy"]),
-  legacyInput: legacyInputSchema.optional(),
-  unsupportedFields: z.array(unsupportedFieldSchema).optional()
+var dependencySchema = z.strictObject({
+  name: nonEmptyStringSchema,
+  version: nonEmptyStringSchema.optional(),
+  source: dependencySourceSchema.optional(),
+  packageName: nonEmptyStringSchema.optional(),
+  features: z.array(nonEmptyStringSchema).optional(),
+  extras: z.array(nonEmptyStringSchema).optional(),
+  optional: z.boolean().optional(),
+  defaultFeatures: z.boolean().optional(),
+  environmentMarker: nonEmptyStringSchema.optional()
+}).refine(({ source, version }) => source !== void 0 || version !== void 0, {
+  message: "dependency must define a version or a source"
+});
+var projectUrlSchema = z.strictObject({
+  label: nonEmptyStringSchema,
+  url: nonEmptyStringSchema
+});
+var packageConfigSchema = z.strictObject({
+  packageName: nonEmptyStringSchema.optional(),
+  moduleName: nonEmptyStringSchema.optional(),
+  modulePath: goModulePathSchema.optional(),
+  namespace: nonEmptyStringSchema.optional(),
+  groupId: nonEmptyStringSchema.optional(),
+  artifactId: nonEmptyStringSchema.optional(),
+  description: z.string().optional(),
+  repository: nonEmptyStringSchema.optional(),
+  homepage: nonEmptyStringSchema.optional(),
+  documentationUrl: nonEmptyStringSchema.optional(),
+  authors: z.array(authorSchema).optional(),
+  developers: z.array(developerSchema).optional(),
+  license: licenseSchema.optional(),
+  keywords: z.array(nonEmptyStringSchema).optional(),
+  classifiers: z.array(nonEmptyStringSchema).optional(),
+  projectUrls: z.array(projectUrlSchema).optional(),
+  extraDependencies: z.array(dependencySchema).optional(),
+  extraDevDependencies: z.array(dependencySchema).optional(),
+  extraPeerDependencies: z.array(dependencySchema).optional()
 });
 var httpMethodSchema = z.enum([
   "GET",
@@ -274,12 +341,17 @@ var readmeEndpointSchema = z.strictObject({
   path: nonEmptyStringSchema,
   stream: z.boolean().optional()
 });
+var readmeCustomSectionSchema = z.strictObject({
+  title: nonEmptyStringSchema,
+  content: z.string()
+});
 var readmeConfigSchema = z.strictObject({
   apiName: nonEmptyStringSchema.optional(),
   introduction: z.string().optional(),
   apiReferenceLink: nonEmptyStringSchema.optional(),
   bannerLink: nonEmptyStringSchema.optional(),
   disabledSections: z.array(nonEmptyStringSchema).optional(),
+  customSections: z.array(readmeCustomSectionSchema).optional(),
   defaultEndpoint: readmeEndpointSchema.optional(),
   features: z.record(z.string(), z.array(readmeEndpointSchema)).optional()
 });
@@ -294,6 +366,737 @@ var docsConfigSchema = z.strictObject({
   referenceBaseUrl: nonEmptyStringSchema.optional(),
   includeApiReference: z.boolean().optional()
 });
+
+// src/sdk-config/v1/docs.ts
+var sdkConfigV1ReadmeEndpointSchema = readmeEndpointSchema;
+var sdkConfigV1ReadmeCustomSectionSchema = readmeCustomSectionSchema;
+var sdkConfigV1DocsConfigSchema = docsConfigSchema;
+
+// src/sdk-config/v1/fern-config-mapper-types.ts
+var FernConfigMappingError = class extends Error {
+  constructor(issues) {
+    super(issues.map(({ path, reason }) => `${path.join(".")}: ${reason}`).join("\n"));
+    this.issues = issues;
+    this.name = "FernConfigMappingError";
+  }
+  issues;
+};
+
+// src/sdk-config/v1/fern-config-mapper-helpers.ts
+function fail(code, path, reason, suggestedAction, sdkConfigPath) {
+  throw new FernConfigMappingError([
+    {
+      code,
+      severity: "error",
+      path,
+      reason,
+      suggestedAction,
+      ...optional("sdkConfigPath", sdkConfigPath)
+    }
+  ]);
+}
+function takeTimeoutMs(value, state, basePath) {
+  const milliseconds = locate(value, ["defaultTimeout", "defaultTimeoutInMilliseconds"], basePath);
+  if (milliseconds && (milliseconds.value === "infinity" || isNonNegativeNumber(milliseconds.value))) {
+    consume(state, milliseconds.path);
+    return milliseconds.value;
+  }
+  const seconds = locate(
+    value,
+    ["defaultTimeoutInSeconds", "timeoutInSeconds", "timeout"],
+    basePath
+  );
+  if (seconds && (seconds.value === "infinity" || isNonNegativeNumber(seconds.value))) {
+    consume(state, seconds.path);
+    return seconds.value === "infinity" ? "infinity" : seconds.value * 1e3;
+  }
+  return void 0;
+}
+function locate(value, aliases, basePath) {
+  for (const [key, child] of Object.entries(value)) {
+    if (aliases.some((alias) => normalizeKey(alias) === normalizeKey(key))) {
+      return { value: child, path: [...basePath, key] };
+    }
+  }
+  return void 0;
+}
+function takeObject(value, aliases, _state, basePath) {
+  const located = locate(value, aliases, basePath);
+  return located && isObject(located.value) ? { value: located.value, path: located.path } : void 0;
+}
+function takeString(value, aliases, state, basePath) {
+  const located = locate(value, aliases, basePath);
+  if (!located || typeof located.value !== "string" || located.value.length === 0) return void 0;
+  consume(state, located.path);
+  return located.value;
+}
+function takeGoModulePath(value, aliases, state, basePath) {
+  const located = locate(value, aliases, basePath);
+  if (!located || !goModulePathSchema.safeParse(located.value).success) return void 0;
+  consume(state, located.path);
+  return located.value;
+}
+function takeBoolean(value, aliases, state, basePath) {
+  const located = locate(value, aliases, basePath);
+  if (!located || typeof located.value !== "boolean") return void 0;
+  consume(state, located.path);
+  return located.value;
+}
+function takeNumber(value, aliases, state, basePath) {
+  const located = locate(value, aliases, basePath);
+  if (!located || !isNonNegativeNumber(located.value) || !Number.isInteger(located.value))
+    return void 0;
+  consume(state, located.path);
+  return located.value;
+}
+function takeEnum(value, aliases, values, state, basePath) {
+  const located = locate(value, aliases, basePath);
+  if (!located || typeof located.value !== "string" || !values.includes(located.value))
+    return void 0;
+  consume(state, located.path);
+  return located.value;
+}
+function takeEnumArray(value, aliases, values, state, basePath) {
+  const located = locate(value, aliases, basePath);
+  if (!located || !Array.isArray(located.value) || located.value.some((item) => typeof item !== "string" || !values.includes(item)))
+    return void 0;
+  consume(state, located.path);
+  return located.value;
+}
+function takeStringArray(value, aliases, state, basePath) {
+  const located = locate(value, aliases, basePath);
+  const strings = located ? stringArrayValue(located.value) : void 0;
+  if (!located || !strings) return void 0;
+  consume(state, located.path);
+  return strings;
+}
+function takeStringArrayRecord(value, aliases, state, basePath) {
+  const located = locate(value, aliases, basePath);
+  if (!located || !isObject(located.value)) return void 0;
+  const entries = Object.entries(located.value);
+  if (entries.some(([, item]) => !stringArrayValue(item))) return void 0;
+  consume(state, located.path);
+  return Object.fromEntries(entries);
+}
+function collectUnsupported(value, basePath, state) {
+  return collectLeafPaths(value, basePath).filter((path) => {
+    const key = pathKey(path);
+    return ![...state.consumedPaths].some(
+      (consumed) => key === consumed || key.startsWith(`${consumed}.`)
+    );
+  }).map((path) => ({
+    code: "FERN_CONFIG_FIELD_UNSUPPORTED",
+    severity: "warning",
+    path,
+    reason: "Fern configuration field is not represented by SDK Config v1",
+    suggestedAction: "Review this value and set the closest SDK Config field manually, or preserve the setting outside SDK Config if no equivalent exists."
+  }));
+}
+function collectLeafPaths(value, path) {
+  if (Array.isArray(value))
+    return value.flatMap((item, index) => collectLeafPaths(item, [...path, index]));
+  if (isObject(value))
+    return Object.entries(value).flatMap(([key, child]) => collectLeafPaths(child, [...path, key]));
+  return value === void 0 ? [] : [path];
+}
+function consume(state, path) {
+  state.consumedPaths.add(pathKey(path));
+}
+function pathKey(path) {
+  return path.join(".");
+}
+function normalizeKey(value) {
+  return value.replace(/[-_]/g, "").toLowerCase();
+}
+function compact(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, child]) => child !== void 0));
+}
+function optional(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function stringArrayValue(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string" && item.length > 0) ? value : void 0;
+}
+function stableJson(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (!isObject(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortKeys(child)])
+  );
+}
+
+// src/sdk-config/v1/fern-config-mapper-output.ts
+function mapOutput(generator, language, index) {
+  const raw = isObject(generator.raw) ? generator.raw : void 0;
+  const rawOutput = raw && isObject(raw.output) ? raw.output : void 0;
+  const outputPath = ["group", "generators", index, "outputMode"];
+  const state = { consumedPaths: /* @__PURE__ */ new Set() };
+  if (rawOutput?.location === "local-file-system") {
+    if (isObject(generator.outputMode)) consume(state, [...outputPath, "type"]);
+    return finishOutputMapping(
+      {
+        output: {
+          delivery: "files",
+          ...typeof rawOutput.path === "string" && rawOutput.path ? { path: rawOutput.path } : {}
+        }
+      },
+      generator.outputMode,
+      outputPath,
+      state,
+      index
+    );
+  }
+  if (!isObject(generator.outputMode) || typeof generator.outputMode.type !== "string") {
+    fail(
+      "FERN_OUTPUT_REQUIRED",
+      ["group", "generators", index, "outputMode"],
+      `Cannot map output for Fern generator ${generator.name}`,
+      "Set generator.output to a public SDK Config output, or provide the resolved Fern outputMode.",
+      ["targets", index, "output"]
+    );
+  }
+  const output = generator.outputMode;
+  consume(state, [...outputPath, "type"]);
+  switch (output.type) {
+    case "downloadFiles":
+      return finishOutputMapping({ output: { delivery: "zip" } }, output, outputPath, state, index);
+    case "github":
+      return finishOutputMapping(
+        githubOutput(output, output.publishInfo, language, outputPath, state, index),
+        output,
+        outputPath,
+        state,
+        index
+      );
+    case "githubV2": {
+      if (!isObject(output.githubV2))
+        fail(
+          "FERN_GITHUB_OUTPUT_INVALID",
+          ["group", "generators", index, "outputMode", "githubV2"],
+          "Fern githubV2 output is missing its configuration",
+          'Set target.output manually with delivery "github" and the intended repository.',
+          ["targets", index, "output"]
+        );
+      const githubPath = [...outputPath, "githubV2"];
+      return finishOutputMapping(
+        githubOutput(
+          output.githubV2,
+          output.githubV2.publishInfo,
+          language,
+          githubPath,
+          state,
+          index
+        ),
+        output,
+        outputPath,
+        state,
+        index
+      );
+    }
+    case "publishV2": {
+      const publication = mapPublication(
+        output.publishV2,
+        language,
+        [...outputPath, "publishV2"],
+        state,
+        index
+      );
+      return finishOutputMapping(
+        {
+          output: { delivery: "zip", publish: publication.publish },
+          ...optional("package", publication.package)
+        },
+        output,
+        outputPath,
+        state,
+        index
+      );
+    }
+    case "publish": {
+      const publication = mapLegacyPublication(
+        output.registryOverrides,
+        language,
+        [...outputPath, "registryOverrides"],
+        state,
+        index
+      );
+      return finishOutputMapping(
+        {
+          output: { delivery: "zip", publish: publication.publish },
+          ...optional("package", publication.package)
+        },
+        output,
+        outputPath,
+        state,
+        index
+      );
+    }
+    default:
+      fail(
+        "FERN_OUTPUT_UNSUPPORTED",
+        ["group", "generators", index, "outputMode", "type"],
+        `Unsupported Fern output mode "${output.type}"`,
+        "Choose the equivalent files, zip, or github SDK Config output manually.",
+        ["targets", index, "output"]
+      );
+  }
+}
+function githubOutput(value, publishInfo, language, sourcePath, state, index) {
+  const owner = stringValue(value.owner);
+  const repo = stringValue(value.repo);
+  if (!owner || !repo)
+    fail(
+      "FERN_GITHUB_REPOSITORY_REQUIRED",
+      sourcePath,
+      "Fern GitHub output requires owner and repo",
+      'Set target.output.github.repository manually as "owner/repository".',
+      ["targets", index, "output", "github", "repository"]
+    );
+  consume(state, [...sourcePath, "owner"]);
+  consume(state, [...sourcePath, "repo"]);
+  const publication = publishInfo ? mapPublication(publishInfo, language, [...sourcePath, "publishInfo"], state, index) : void 0;
+  const type = stringValue(value.type);
+  const reviewers = mapReviewers(value.reviewers, [...sourcePath, "reviewers"], state);
+  if (type) consume(state, [...sourcePath, "type"]);
+  if (typeof value.makePr === "boolean") consume(state, [...sourcePath, "makePr"]);
+  if (stringValue(value.host)) consume(state, [...sourcePath, "host"]);
+  if (stringValue(value.branch)) consume(state, [...sourcePath, "branch"]);
+  return {
+    output: {
+      delivery: "github",
+      github: {
+        repository: `${owner}/${repo}`,
+        ...optional("host", stringValue(value.host)),
+        ...optional("branch", stringValue(value.branch)),
+        mode: value.makePr === true || type === "pullRequest" ? "pull-request" : type === "push" ? "push" : "release",
+        ...optional("reviewers", reviewers)
+      },
+      ...publication ? { publish: publication.publish } : {}
+    },
+    ...optional("package", publication?.package)
+  };
+}
+function mapReviewers(value, sourcePath, state) {
+  if (Array.isArray(value)) {
+    const teams2 = reviewerNames(value, "team", sourcePath, state);
+    const users2 = reviewerNames(value, "user", sourcePath, state);
+    return teams2 || users2 ? { ...optional("teams", teams2), ...optional("users", users2) } : void 0;
+  }
+  if (!isObject(value)) return void 0;
+  const teams = reviewerNames(value.teams, "team", [...sourcePath, "teams"], state);
+  const users = reviewerNames(value.users, "user", [...sourcePath, "users"], state);
+  return teams || users ? { ...optional("teams", teams), ...optional("users", users) } : void 0;
+}
+function reviewerNames(value, expectedType, sourcePath, state) {
+  if (!Array.isArray(value)) return void 0;
+  const names = value.flatMap((reviewer, index) => {
+    if (typeof reviewer === "string") {
+      consume(state, [...sourcePath, index]);
+      return [reviewer];
+    }
+    if (!isObject(reviewer) || reviewer.type !== expectedType || typeof reviewer.name !== "string") {
+      return [];
+    }
+    consume(state, [...sourcePath, index, "type"]);
+    consume(state, [...sourcePath, index, "name"]);
+    return [reviewer.name];
+  });
+  return names.length ? names : void 0;
+}
+function mapPublication(value, language, sourcePath, state, index) {
+  if (!isObject(value))
+    fail(
+      "FERN_PUBLICATION_INVALID",
+      sourcePath,
+      "Fern publication output is invalid",
+      "Set target.output.publish and target.package manually.",
+      ["targets", index, "output", "publish"]
+    );
+  const type = stringValue(value.type);
+  if (type) consume(state, [...sourcePath, "type"]);
+  const nested = type && isObject(value[type]) ? value[type] : value;
+  const nestedPath = nested === value ? sourcePath : [...sourcePath, type];
+  const registry = publicationRegistry(type, language, [...sourcePath, "type"], index);
+  const registryUrl = stringValue(nested.registryUrl);
+  if (registryUrl) consume(state, [...nestedPath, "registryUrl"]);
+  if (registry === "maven") {
+    const coordinate = stringValue(nested.coordinate);
+    if (coordinate) consume(state, [...nestedPath, "coordinate"]);
+    return {
+      publish: compact({ registry, url: registryUrl }),
+      ...coordinate ? { package: mavenPackage(coordinate, [...nestedPath, "coordinate"], index) } : {}
+    };
+  }
+  const packageNameField = stringValue(nested.packageName) ? "packageName" : "coordinate";
+  const packageName = stringValue(nested[packageNameField]);
+  if (packageName) consume(state, [...nestedPath, packageNameField]);
+  const metadata = registry === "pypi" ? mapPypiMetadata(nested.pypiMetadata, nestedPath, state) : {};
+  return {
+    publish: compact({ registry, url: registryUrl }),
+    ...packageName || Object.keys(metadata).length ? { package: { ...optional("packageName", packageName), ...metadata } } : {}
+  };
+}
+function mapLegacyPublication(value, language, sourcePath, state, index) {
+  const registry = defaultRegistry(language, sourcePath, index);
+  const overrides = isObject(value) ? value : {};
+  const override = isObject(overrides[registry]) ? overrides[registry] : {};
+  return mapPublication(override, language, [...sourcePath, registry], state, index);
+}
+function publicationRegistry(type, language, sourcePath, index) {
+  if (type === "postman") {
+    fail(
+      "FERN_POSTMAN_PUBLICATION_UNSUPPORTED",
+      sourcePath,
+      "Postman collection publication is not an SDK output",
+      "Remove this non-SDK target or convert it separately from the SDK Config document."
+    );
+  }
+  const normalized = type?.replace(/Override$/, "").toLowerCase();
+  if (normalized === "rubygems") return "rubygems";
+  if (normalized && ["npm", "pypi", "maven", "nuget", "crates"].includes(normalized)) {
+    return normalized;
+  }
+  if (normalized !== void 0) {
+    fail(
+      "FERN_PUBLICATION_UNSUPPORTED",
+      sourcePath,
+      `Unsupported Fern publication type "${type}"`,
+      "Set target.output.publish and target.package manually if SDK Config supports the registry.",
+      ["targets", index, "output", "publish"]
+    );
+  }
+  return defaultRegistry(language, sourcePath, index);
+}
+function defaultRegistry(language, sourcePath, index) {
+  const registries = {
+    typescript: "npm",
+    mcp: "npm",
+    python: "pypi",
+    java: "maven",
+    kotlin: "maven",
+    csharp: "nuget",
+    ruby: "rubygems",
+    rust: "crates",
+    go: "go",
+    php: "composer"
+  };
+  const registry = registries[language];
+  if (!registry)
+    fail(
+      "FERN_PUBLICATION_REGISTRY_REQUIRED",
+      sourcePath,
+      `No publication registry can be inferred for ${language}`,
+      "Set target.output.publish.registry manually.",
+      ["targets", index, "output", "publish", "registry"]
+    );
+  return registry;
+}
+function mavenPackage(coordinate, sourcePath, index) {
+  const parts = coordinate.split(":");
+  const [groupId, artifactId] = parts;
+  if (parts.length !== 2 || !groupId || !artifactId)
+    fail(
+      "FERN_MAVEN_COORDINATE_INVALID",
+      sourcePath,
+      `Invalid Maven coordinate ${coordinate}`,
+      "Set target.package.groupId and target.package.artifactId manually.",
+      ["targets", index, "package"]
+    );
+  return { groupId, artifactId };
+}
+function mapPypiMetadata(value, sourcePath, state) {
+  if (!isObject(value)) return {};
+  const metadataPath = [...sourcePath, "pypiMetadata"];
+  const description = stringValue(value.description);
+  const keywords = stringArrayValue(value.keywords);
+  const documentationUrl = stringValue(value.documentationLink);
+  const homepage = stringValue(value.homepageLink);
+  const authors = mapAuthors(value.authors, [...metadataPath, "authors"], state);
+  if (description) consume(state, [...metadataPath, "description"]);
+  if (keywords) consume(state, [...metadataPath, "keywords"]);
+  if (documentationUrl) consume(state, [...metadataPath, "documentationLink"]);
+  if (homepage) consume(state, [...metadataPath, "homepageLink"]);
+  return compact({ description, authors, keywords, documentationUrl, homepage });
+}
+function mapAuthors(value, sourcePath, state) {
+  if (!Array.isArray(value)) return void 0;
+  const authors = value.flatMap((author) => {
+    if (!isObject(author)) return [];
+    const name = stringValue(author.name);
+    const email = stringValue(author.email);
+    return name ? [{ name, ...optional("email", email) }] : [];
+  });
+  if (authors.length !== value.length) return void 0;
+  value.forEach((author, index) => {
+    consume(state, [...sourcePath, index, "name"]);
+    if (isObject(author) && stringValue(author.email)) {
+      consume(state, [...sourcePath, index, "email"]);
+    }
+  });
+  return authors;
+}
+function finishOutputMapping(mapping, outputMode, sourcePath, state, index) {
+  for (const path of collectLeafPaths(outputMode, sourcePath)) {
+    if (path[path.length - 1] === "_visit") consume(state, path);
+  }
+  return {
+    ...mapping,
+    unsupportedFields: collectUnsupported(outputMode, sourcePath, state).map(
+      (diagnostic) => outputDiagnostic(diagnostic.path, index)
+    )
+  };
+}
+function outputDiagnostic(path, index) {
+  const fields = path.filter((part) => typeof part === "string");
+  const field = fields[fields.length - 1];
+  const credential = fields.some((part) => part === "credentials" || part === "signature") || ["apiKey", "keyId", "password", "secretKey", "token", "username"].includes(field ?? "");
+  if (credential) {
+    return {
+      code: "FERN_OUTPUT_CREDENTIAL_UNSUPPORTED",
+      severity: "warning",
+      path,
+      reason: "Fern output credentials and signatures are not represented by SDK Config v1",
+      suggestedAction: "Configure publication credentials and signing secrets outside SDK Config."
+    };
+  }
+  const guidance = {
+    directory: {
+      suggestedAction: "Preserve the GitHub output subdirectory outside SDK Config; public v1 has no repository subdirectory field."
+    },
+    license: {
+      sdkConfigPath: ["targets", index, "package", "license"],
+      suggestedAction: "Set target.package.license manually using portable license metadata."
+    },
+    id: {
+      sdkConfigPath: ["targets", index, "package", "license"],
+      suggestedAction: "Set target.package.license manually using portable license metadata."
+    },
+    contents: {
+      sdkConfigPath: ["targets", index, "package", "license"],
+      suggestedAction: "Set target.package.license manually without embedding license contents."
+    },
+    downloadSnippets: {
+      sdkConfigPath: ["docs", "snippets", "enabled"],
+      suggestedAction: "Set docs.snippets.enabled manually and choose a portable output path if needed."
+    },
+    version: {
+      sdkConfigPath: ["targets", index, "sdkVersion"],
+      suggestedAction: "Set target.sdkVersion manually if this output version identifies the SDK artifact."
+    },
+    description: {
+      sdkConfigPath: ["targets", index, "package", "description"],
+      suggestedAction: "Set target.package.description manually to a valid value."
+    },
+    authors: {
+      sdkConfigPath: ["targets", index, "package", "authors"],
+      suggestedAction: "Set target.package.authors manually using valid author metadata."
+    },
+    keywords: {
+      sdkConfigPath: ["targets", index, "package", "keywords"],
+      suggestedAction: "Set target.package.keywords manually using non-empty strings."
+    },
+    documentationLink: {
+      sdkConfigPath: ["targets", index, "package", "documentationUrl"],
+      suggestedAction: "Set target.package.documentationUrl manually to a valid URL."
+    },
+    homepageLink: {
+      sdkConfigPath: ["targets", index, "package", "homepage"],
+      suggestedAction: "Set target.package.homepage manually to a valid URL."
+    }
+  };
+  const fieldGuidance = field ? guidance[field] : void 0;
+  const resolvedGuidance = fields.includes("license") ? guidance.license : fieldGuidance;
+  return {
+    code: "FERN_OUTPUT_FIELD_UNSUPPORTED",
+    severity: "warning",
+    path,
+    reason: "Fern output field is not represented by SDK Config v1",
+    ...optional("sdkConfigPath", resolvedGuidance?.sdkConfigPath),
+    suggestedAction: resolvedGuidance?.suggestedAction ?? "Review this output setting and preserve it outside SDK Config when no equivalent exists."
+  };
+}
+var customerGenerationAssetSchema = z.discriminatedUnion("type", [
+  z.strictObject({ type: z.literal("path"), location: nonEmptyStringSchema }),
+  z.strictObject({ type: z.literal("url"), location: nonEmptyStringSchema })
+]);
+var hookDependencySchema = z.strictObject({
+  name: nonEmptyStringSchema,
+  version: nonEmptyStringSchema,
+  groupId: nonEmptyStringSchema.optional()
+});
+var hooksConfigSchema = z.strictObject({
+  enabled: z.boolean(),
+  source: customerGenerationAssetSchema.optional(),
+  dependencies: z.array(hookDependencySchema).optional()
+});
+var customCodeConfigSchema = z.strictObject({
+  enabled: z.boolean(),
+  source: customerGenerationAssetSchema.optional(),
+  conflictStrategy: z.enum(["mark", "ours", "theirs"]).optional(),
+  trackChanges: z.boolean().optional(),
+  protectedFiles: z.array(nonEmptyStringSchema).optional()
+});
+var workflowConfigSchema = z.strictObject({
+  path: nonEmptyStringSchema,
+  outputName: nonEmptyStringSchema.optional()
+});
+var analyticsHeaderSchema = z.union([
+  z.strictObject({ name: nonEmptyStringSchema, value: z.string() }),
+  z.strictObject({
+    name: nonEmptyStringSchema,
+    valueRef: nonEmptyStringSchema
+  })
+]);
+var analyticsConfigSchema = z.strictObject({
+  enabled: z.boolean(),
+  endpoint: nonEmptyStringSchema.optional(),
+  exporter: z.enum(["otlp-http", "console"]).optional(),
+  headers: z.array(analyticsHeaderSchema).optional(),
+  batchSize: z.number().int().positive().optional(),
+  scheduledDelayMs: z.number().nonnegative().optional(),
+  exportTimeoutMs: z.number().nonnegative().optional()
+}).superRefine(({ enabled, endpoint }, context) => {
+  if (enabled && endpoint === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "endpoint is required when analytics is enabled",
+      path: ["endpoint"]
+    });
+  }
+});
+var wireTestsSchema = z.strictObject({
+  enabled: z.boolean(),
+  exclusions: z.array(nonEmptyStringSchema).optional(),
+  fallbackToGeneratedErrorExamples: z.boolean().optional(),
+  fixtureSource: z.enum(["synthetic", "recorded", "auto"]).optional()
+});
+var unitTestsSchema = z.strictObject({
+  enabled: z.boolean(),
+  mode: z.enum(["core-runtime", "schema-driven", "both"]).optional(),
+  exclusions: z.array(nonEmptyStringSchema).optional()
+});
+var streamsSchema = z.strictObject({
+  enabled: z.boolean(),
+  responseType: z.enum(["wrapper", "native", "web"]).optional(),
+  fileResponseType: z.enum(["stream", "binary-response"]).optional(),
+  defaultChunkSizeBytes: z.number().int().positive().optional()
+});
+var namingConfigSchema = z.strictObject({
+  clientName: nonEmptyStringSchema.optional(),
+  exportedClientName: nonEmptyStringSchema.optional(),
+  environmentTypeName: nonEmptyStringSchema.optional(),
+  apiErrorName: nonEmptyStringSchema.optional(),
+  baseErrorName: nonEmptyStringSchema.optional(),
+  pagerName: nonEmptyStringSchema.optional()
+});
+var layoutConfigSchema = z.strictObject({
+  outputDirectory: z.enum(["project-root", "source-root"]).optional(),
+  packagePath: nonEmptyStringSchema.optional()
+});
+var serializationConfigSchema = z.strictObject({
+  enumRepresentation: z.enum(["enum", "union", "literal", "forward-compatible-enum", "language-default"]).optional(),
+  additionalProperties: z.enum(["allow", "forbid", "ignore", "language-default"]).optional(),
+  inlineTypes: z.boolean().optional(),
+  omitUndefined: z.boolean().optional()
+});
+var sdkConfigV1GenerationConfigSchema = z.strictObject({
+  includeWatermark: z.boolean().default(false),
+  ai: z.boolean().default(false),
+  includeOptionalSnippetParameters: z.boolean().optional(),
+  buildAllModels: z.boolean().default(false),
+  inferServiceNames: z.boolean().default(false),
+  includeDeprecatedOperations: z.boolean().default(true),
+  multipleResponses: z.boolean().default(false),
+  devContainer: z.boolean().default(false),
+  allowMockClient: z.boolean().default(false),
+  ignoreFiles: z.array(nonEmptyStringSchema).optional(),
+  reservedKeywords: z.array(nonEmptyStringSchema).optional(),
+  hooks: hooksConfigSchema.optional(),
+  customCode: customCodeConfigSchema.optional(),
+  workflows: z.array(workflowConfigSchema).optional(),
+  customQueryPaths: z.array(nonEmptyStringSchema).optional(),
+  analytics: analyticsConfigSchema.optional(),
+  wireTests: wireTestsSchema.optional(),
+  unitTests: unitTestsSchema.optional(),
+  webSockets: z.boolean().optional(),
+  streams: streamsSchema.optional(),
+  naming: namingConfigSchema.optional(),
+  layout: layoutConfigSchema.optional(),
+  serialization: serializationConfigSchema.optional()
+});
+var sdkConfigV1PublishRegistrySchema = z.enum([
+  "npm",
+  "pypi",
+  "maven",
+  "nuget",
+  "rubygems",
+  "crates",
+  "go",
+  "composer"
+]);
+var commonPublishShape = {
+  url: nonEmptyStringSchema.optional(),
+  releaseBranch: nonEmptyStringSchema.optional(),
+  tolerateRepublish: z.boolean().optional()
+};
+var sdkConfigV1PublishConfigSchema = z.discriminatedUnion("registry", [
+  z.strictObject({ registry: z.literal("npm"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("pypi"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("maven"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("nuget"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("rubygems"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("crates"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("go"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("composer"), ...commonPublishShape })
+]);
+var reviewersSchema = z.strictObject({
+  teams: z.array(nonEmptyStringSchema).optional(),
+  users: z.array(nonEmptyStringSchema).optional()
+});
+var githubOutputSchema = z.strictObject({
+  repository: nonEmptyStringSchema,
+  host: nonEmptyStringSchema.optional(),
+  branch: nonEmptyStringSchema.optional(),
+  mode: z.enum(["release", "pull-request", "push"]).optional(),
+  reviewers: reviewersSchema.optional(),
+  privateRepository: z.boolean().optional()
+});
+var filesOutputSchema = z.strictObject({
+  delivery: z.literal("files"),
+  path: nonEmptyStringSchema.optional(),
+  publish: sdkConfigV1PublishConfigSchema.optional()
+});
+var zipOutputSchema = z.strictObject({
+  delivery: z.literal("zip"),
+  fileName: nonEmptyStringSchema.optional(),
+  publish: sdkConfigV1PublishConfigSchema.optional()
+});
+var githubDeliverySchema = z.strictObject({
+  delivery: z.literal("github"),
+  github: githubOutputSchema,
+  publish: sdkConfigV1PublishConfigSchema.optional()
+});
+var sdkConfigV1OutputConfigSchema = z.discriminatedUnion(
+  "delivery",
+  [filesOutputSchema, zipOutputSchema, githubDeliverySchema],
+  { error: 'output.delivery must be one of "files", "zip", or "github"' }
+);
+
+// src/sdk-config/v1/package.ts
+var sdkConfigV1DependencySchema = dependencySchema;
+var sdkConfigV1PackageConfigSchema = packageConfigSchema;
 var cliGenerationConfigSchema = z.strictObject({
   paginationParameters: z.array(nonEmptyStringSchema).optional(),
   skills: z.boolean().optional()
@@ -303,10 +1106,15 @@ var csharpGenerationConfigSchema = z.strictObject({
   simplifyObjectDictionaries: z.boolean().optional(),
   explicitNamespaces: z.boolean().optional(),
   rootNamespaceForCoreClasses: z.boolean().optional(),
-  includeExceptionHandler: z.boolean().optional()
+  includeExceptionHandler: z.boolean().optional(),
+  experimentalExplicitNullableOptional: z.boolean().optional()
 });
 var goGenerationConfigSchema = z.strictObject({
   legacyComplexModels: z.boolean().optional(),
+  /** Uppercase common initialisms in generated names (`UserID` rather than `UserId`). */
+  smartCasing: z.boolean().optional(),
+  /** Overrides the fern root-client constructor independently from the client type name. */
+  clientConstructorName: nonEmptyStringSchema.optional(),
   unionVersion: z.enum(["v0", "v1"]).optional(),
   includeLegacyClientOptions: z.boolean().optional()
 });
@@ -316,15 +1124,17 @@ var jvmGenerationConfigSchema = z.strictObject({
   collapseOptionalNullable: z.boolean().optional(),
   gradleDistributionUrl: z.string().min(1).optional(),
   gradlePluginManagement: z.string().optional(),
-  gradleCentralDependencyManagement: z.boolean().optional()
+  gradleCentralDependencyManagement: z.boolean().optional(),
+  /** Selects co-located async methods or a separate async client surface. */
+  asyncStyle: z.enum(["dedicated-client", "twin-methods"]).optional()
 });
 
-// src/sdk-config-ir/v1/language/java.ts
+// src/sdk-config-domain/v1/language/java.ts
 var javaGenerationConfigSchema = jvmGenerationConfigSchema.extend({
   includeKotlinSnippets: z.boolean().optional()
 });
 
-// src/sdk-config-ir/v1/language/kotlin.ts
+// src/sdk-config-domain/v1/language/kotlin.ts
 var kotlinGenerationConfigSchema = jvmGenerationConfigSchema;
 var compilerOptionsSchema = z.strictObject({
   target: nonEmptyStringSchema.optional(),
@@ -356,8 +1166,32 @@ var typescriptGenerationConfigSchema = z.strictObject({
   scripts: z.array(packageScriptSchema).optional()
 });
 
-// src/sdk-config-ir/v1/language/mcp.ts
-var mcpGenerationConfigSchema = typescriptGenerationConfigSchema;
+// src/sdk-config-domain/v1/language/mcp.ts
+var mcpAvailabilityStatuses = [
+  "IN_DEVELOPMENT",
+  "PRE_RELEASE",
+  "GENERAL_AVAILABILITY",
+  "DEPRECATED",
+  "ALPHA",
+  "BETA",
+  "PREVIEW",
+  "LEGACY"
+];
+var mcpToolFilterSchema = z.strictObject({
+  include: z.array(nonEmptyStringSchema).optional(),
+  exclude: z.array(nonEmptyStringSchema).optional()
+});
+var mcpToolsetNameSchema = nonEmptyStringSchema.refine(
+  (name) => name !== "default" && /^[a-z0-9-]+$/.test(name),
+  'toolset names must match [a-z0-9-]+ and cannot be "default"'
+);
+var mcpGenerationConfigSchema = typescriptGenerationConfigSchema.extend({
+  serverName: nonEmptyStringSchema.optional(),
+  serverDescription: nonEmptyStringSchema.optional(),
+  excludeAvailability: z.array(z.enum(mcpAvailabilityStatuses)).optional(),
+  tools: mcpToolFilterSchema.optional(),
+  toolsets: z.record(mcpToolsetNameSchema, mcpToolFilterSchema).optional()
+});
 var phpGenerationConfigSchema = z.strictObject({
   propertyAccess: z.enum(["public", "private"]).optional(),
   generateClientInterfaces: z.boolean().optional()
@@ -398,126 +1232,1002 @@ var rustGenerationConfigSchema = z.strictObject({
   defaultFeatures: z.array(nonEmptyStringSchema).optional()
 });
 var swiftGenerationConfigSchema = z.strictObject({
-  moduleName: nonEmptyStringSchema.optional()
+  moduleName: nonEmptyStringSchema.optional(),
+  nullableAsOptional: z.boolean().optional()
 });
-var goModulePathSchema = nonEmptyStringSchema.regex(
-  /^(?!.*(?:^|\/)\.{1,2}(?:\/|$))[A-Za-z0-9._~-]+(?:\/[A-Za-z0-9._~-]+)+$/,
-  "Go module path must be a slash-delimited path using letters, numbers, dots, dashes, underscores, or tildes"
-);
-var composerPackageNameSchema = nonEmptyStringSchema.regex(
-  /^[a-z0-9]([_.-]?[a-z0-9]+)*\/[a-z0-9](([_.]?|-{0,2})[a-z0-9]+)*$/,
-  'Composer package name must be a lowercase "vendor/package" name'
-);
-var authorSchema = z.strictObject({
-  name: nonEmptyStringSchema,
-  email: z.email().optional()
+var planModifierSourceSchema = z.discriminatedUnion("enabled", [
+  z.strictObject({ enabled: z.literal(true), sourceDir: nonEmptyStringSchema }),
+  z.strictObject({ enabled: z.literal(false) })
+]);
+var planModifiersSchema = z.strictObject({
+  resources: planModifierSourceSchema,
+  attributes: planModifierSourceSchema
 });
-var developerSchema = z.strictObject({
-  name: nonEmptyStringSchema,
-  email: z.email().optional(),
-  organization: nonEmptyStringSchema.optional(),
-  organizationUrl: nonEmptyStringSchema.optional()
+var providerSchemaSchema = z.strictObject({
+  addressKey: nonEmptyStringSchema,
+  authTokenKey: nonEmptyStringSchema
 });
-var licenseSchema = z.strictObject({
-  type: nonEmptyStringSchema,
-  name: nonEmptyStringSchema.optional(),
-  url: nonEmptyStringSchema.optional(),
-  path: nonEmptyStringSchema.optional()
+var terraformGenerationConfigSchema = z.strictObject({
+  providerName: nonEmptyStringSchema.optional(),
+  providerVersion: nonEmptyStringSchema.optional(),
+  providerModulePath: goModulePathSchema.optional(),
+  mockAcceptance: z.boolean().optional(),
+  hideComputedDiff: z.boolean().optional(),
+  providerSchema: providerSchemaSchema.optional(),
+  planModifiers: planModifiersSchema.optional()
+});
+
+// src/sdk-config/v1/target.ts
+var targetOverrideShape = {
+  generatorVersion: exactSemverSchema.optional(),
+  sdkName: nonEmptyStringSchema.optional(),
+  sdkVersion: nonEmptyStringSchema.optional(),
+  package: sdkConfigV1PackageConfigSchema.optional(),
+  output: sdkConfigV1OutputConfigSchema.optional()
+};
+var sdkConfigV1TargetSchema = z.discriminatedUnion("language", [
+  z.strictObject({
+    language: z.literal("typescript"),
+    generation: typescriptGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  z.strictObject({
+    language: z.literal("python"),
+    generation: pythonGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  z.strictObject({
+    language: z.literal("java"),
+    generation: javaGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  z.strictObject({
+    language: z.literal("kotlin"),
+    generation: kotlinGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  z.strictObject({
+    language: z.literal("go"),
+    generation: goGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  z.strictObject({
+    language: z.literal("csharp"),
+    generation: csharpGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  z.strictObject({
+    language: z.literal("php"),
+    generation: phpGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  z.strictObject({
+    language: z.literal("ruby"),
+    generation: rubyGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  z.strictObject({
+    language: z.literal("rust"),
+    generation: rustGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  z.strictObject({
+    language: z.literal("swift"),
+    generation: swiftGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  z.strictObject({
+    language: z.literal("cli"),
+    generation: cliGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  z.strictObject({
+    language: z.literal("mcp"),
+    generation: mcpGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  z.strictObject({
+    language: z.literal("terraform"),
+    generation: terraformGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  })
+]);
+
+// src/sdk-config/v1/sdk-config-v1.ts
+var SDK_CONFIG_V1_SCHEMA_VERSION = "sdk-config/v1";
+var publishRegistryLanguages = {
+  npm: ["typescript", "mcp"],
+  pypi: ["python"],
+  maven: ["java", "kotlin"],
+  nuget: ["csharp"],
+  rubygems: ["ruby"],
+  crates: ["rust"],
+  go: ["go"],
+  composer: ["php"]
+};
+var packageNameRegistries = /* @__PURE__ */ new Set([
+  "npm",
+  "pypi",
+  "nuget",
+  "rubygems",
+  "crates",
+  "composer"
+]);
+function validatePublishingIdentity(packageConfig, registry, targetIndex, context) {
+  const pathPrefix = ["targets", targetIndex, "package"];
+  if (packageNameRegistries.has(registry) && !packageConfig.packageName) {
+    context.addIssue({
+      code: "custom",
+      message: `packageName is required when publishing to "${registry}"`,
+      path: [...pathPrefix, "packageName"]
+    });
+  }
+  if (registry === "composer" && packageConfig.packageName) {
+    const result = composerPackageNameSchema.safeParse(packageConfig.packageName);
+    if (!result.success) {
+      context.addIssue({
+        code: "custom",
+        message: result.error.issues[0]?.message ?? "Invalid Composer package name",
+        path: [...pathPrefix, "packageName"]
+      });
+    }
+  }
+  if (registry === "go" && !packageConfig.modulePath) {
+    context.addIssue({
+      code: "custom",
+      message: "modulePath is required when publishing a Go module",
+      path: [...pathPrefix, "modulePath"]
+    });
+  }
+  if (registry === "maven") {
+    ["groupId", "artifactId"].forEach((field) => {
+      if (!packageConfig[field]) {
+        context.addIssue({
+          code: "custom",
+          message: `${field} is required when publishing to Maven`,
+          path: [...pathPrefix, field]
+        });
+      }
+    });
+  }
+}
+function validateTargetPublishing(target, targetIndex, globalPackage, globalOutput, context) {
+  const output = target.output ?? globalOutput;
+  if (!output.publish) {
+    return;
+  }
+  const registry = output.publish.registry;
+  if (!publishRegistryLanguages[registry].some((language) => language === target.language)) {
+    context.addIssue({
+      code: "custom",
+      message: `registry "${registry}" is not supported for target language "${target.language}"`,
+      path: ["targets", targetIndex, target.output ? "output" : "language"]
+    });
+    return;
+  }
+  validatePublishingIdentity(
+    { ...globalPackage, ...target.package },
+    registry,
+    targetIndex,
+    context
+  );
+}
+var sdkConfigV1Schema = z.strictObject({
+  schemaVersion: z.literal(SDK_CONFIG_V1_SCHEMA_VERSION),
+  sdkName: nonEmptyStringSchema,
+  sdkVersion: nonEmptyStringSchema.default("1.0.0"),
+  apiVersion: nonEmptyStringSchema.optional(),
+  api: sdkConfigV1ApiConfigSchema,
+  client: sdkConfigV1ClientConfigSchema,
+  package: sdkConfigV1PackageConfigSchema,
+  output: sdkConfigV1OutputConfigSchema,
+  docs: sdkConfigV1DocsConfigSchema,
+  generation: sdkConfigV1GenerationConfigSchema,
+  targets: z.array(sdkConfigV1TargetSchema).min(1)
+}).superRefine(({ output, package: globalPackage, targets }, context) => {
+  const configuredLanguages = /* @__PURE__ */ new Set();
+  targets.forEach((target, targetIndex) => {
+    if (configuredLanguages.has(target.language)) {
+      context.addIssue({
+        code: "custom",
+        message: `target language "${target.language}" must be unique`,
+        path: ["targets", targetIndex, "language"]
+      });
+    }
+    configuredLanguages.add(target.language);
+    validateTargetPublishing(target, targetIndex, globalPackage, output, context);
+  });
 });
-var dependencySourceSchema = z.discriminatedUnion("type", [
-  z.strictObject({
-    type: z.literal("registry"),
-    registry: nonEmptyStringSchema.optional()
-  }),
-  z.strictObject({
-    type: z.literal("git"),
-    url: nonEmptyStringSchema,
-    ref: nonEmptyStringSchema.optional(),
-    subdirectory: nonEmptyStringSchema.optional()
-  }),
-  z.strictObject({
-    type: z.literal("path"),
-    path: nonEmptyStringSchema
-  })
-]);
-var dependencySchema = z.strictObject({
-  name: nonEmptyStringSchema,
-  version: nonEmptyStringSchema.optional(),
-  source: dependencySourceSchema.optional(),
-  packageName: nonEmptyStringSchema.optional(),
-  features: z.array(nonEmptyStringSchema).optional(),
-  extras: z.array(nonEmptyStringSchema).optional(),
-  optional: z.boolean().optional(),
-  defaultFeatures: z.boolean().optional(),
-  environmentMarker: nonEmptyStringSchema.optional()
-}).refine(({ source, version }) => source !== void 0 || version !== void 0, {
-  message: "dependency must define a version or a source"
+function parseSdkConfigV1(value) {
+  return sdkConfigV1Schema.parse(value);
+}
+
+// src/sdk-config/v1/fern-config-mapper.ts
+var generatorLanguages = {
+  "fernapi/fern-typescript": "typescript",
+  "fernapi/fern-typescript-sdk": "typescript",
+  "fernapi/fern-typescript-node-sdk": "typescript",
+  "fernapi/fern-typescript-browser-sdk": "typescript",
+  "fernapi/fern-python-sdk": "python",
+  "fernapi/fern-java-sdk": "java",
+  "fernapi/fern-kotlin-sdk": "kotlin",
+  "fernapi/fern-go-sdk": "go",
+  "fernapi/fern-csharp-sdk": "csharp",
+  "fernapi/fern-php-sdk": "php",
+  "fernapi/fern-ruby-sdk": "ruby",
+  "fernapi/fern-ruby-sdk-v2": "ruby",
+  "fernapi/fern-rust-sdk": "rust",
+  "fernapi/fern-swift-sdk": "swift",
+  "fernapi/fern-cli": "cli",
+  "fernapi/fern-cli-generator": "cli",
+  "fernapi/fern-mcp-server": "mcp"
+};
+function mapFernConfigToSdkConfigV1(input) {
+  if (input.group.generators.length === 0) {
+    fail(
+      "FERN_GENERATORS_REQUIRED",
+      ["group", "generators"],
+      "Fern generator group must contain at least one generator",
+      "Select a Fern generator group containing at least one SDK generator."
+    );
+  }
+  const mapped = input.group.generators.map((generator, index) => {
+    const language = resolveLanguage(generator, index);
+    const invocation = mapInvocation(generator, language, index);
+    const outputMapping = generator.output ? { output: generator.output, unsupportedFields: [] } : mapOutput(generator, language, index);
+    return {
+      generator,
+      language,
+      invocation,
+      ...outputMapping
+    };
+  });
+  requireUniqueLanguages(mapped.map(({ language }) => language));
+  const client = requireSharedBlock(
+    mapped.map(({ invocation }) => invocation.client),
+    "client",
+    (value) => sdkConfigV1ClientConfigSchema.parse(value)
+  );
+  const docs = requireSharedBlock(
+    mapped.map(({ invocation }) => invocation.docs),
+    "docs",
+    (value) => sdkConfigV1DocsConfigSchema.parse(value)
+  );
+  const generation = requireSharedBlock(
+    mapped.map(({ invocation }) => invocation.generation),
+    "generation",
+    (value) => sdkConfigV1GenerationConfigSchema.parse(value)
+  );
+  const api = { ...input.api ?? {} };
+  delete api.audiences;
+  if (input.group.audiences.type === "select") {
+    api.audiences = [...input.group.audiences.audiences];
+  }
+  const targets = mapped.map(
+    ({ generator, invocation, language, output, package: outputPackage }, index) => {
+      const target = {
+        language,
+        output,
+        ...optional("sdkName", generator.sdkName),
+        ...optional("sdkVersion", generator.sdkVersion)
+      };
+      if (Object.keys(invocation.package).length > 0 || outputPackage || generator.package) {
+        target.package = { ...invocation.package, ...outputPackage, ...generator.package };
+      }
+      if (Object.keys(invocation.targetGeneration).length > 0) {
+        target.generation = invocation.targetGeneration;
+      }
+      if (generator.version) {
+        if (exactSemverSchema.safeParse(generator.version).success) {
+          target.generatorVersion = generator.version;
+        } else {
+          invocation.unsupportedFields.push({
+            code: "FERN_GENERATOR_VERSION_NOT_EXACT",
+            severity: "warning",
+            path: ["group", "generators", index, "version"],
+            reason: "SDK Config requires an exact generator semantic version",
+            sdkConfigPath: ["targets", index, "generatorVersion"],
+            suggestedAction: "Resolve the Fern generator tag to an exact semantic version and set target.generatorVersion manually, or leave it omitted."
+          });
+        }
+      }
+      return target;
+    }
+  );
+  const parsed = sdkConfigV1Schema.safeParse({
+    schemaVersion: "sdk-config/v1",
+    sdkName: input.apiName,
+    ...optional("sdkVersion", input.sdkVersion),
+    ...optional("apiVersion", input.apiVersion),
+    api,
+    client,
+    package: {},
+    output: mapped[0].output,
+    docs,
+    generation,
+    targets
+  });
+  if (!parsed.success) {
+    throw new FernConfigMappingError(
+      parsed.error.issues.map((issue) => {
+        const path = issue.path.map(
+          (part) => typeof part === "symbol" ? part.description ?? part.toString() : part
+        );
+        return {
+          code: "SDK_CONFIG_VALIDATION_FAILED",
+          severity: "error",
+          path: ["mappedSdkConfig", ...path],
+          reason: issue.message,
+          sdkConfigPath: path,
+          suggestedAction: `Set ${path.join(".")} manually to a valid SDK Config v1 value.`
+        };
+      })
+    );
+  }
+  return {
+    sdkConfig: parsed.data,
+    unsupportedFields: mapped.flatMap(({ invocation, unsupportedFields }) => [
+      ...invocation.unsupportedFields,
+      ...unsupportedFields
+    ])
+  };
+}
+function resolveLanguage(generator, index) {
+  const language = generator.sdkLanguage ?? generatorLanguages[generator.name];
+  if (!language || !isFernLanguage(language)) {
+    fail(
+      "FERN_SDK_LANGUAGE_REQUIRED",
+      ["group", "generators", index, "name"],
+      `Cannot determine an SDK language for Fern generator ${generator.name}`,
+      "Set sdkLanguage explicitly if this custom generator produces one of the SDK Config v1 target languages.",
+      ["targets", index, "language"]
+    );
+  }
+  return language;
+}
+function isFernLanguage(value) {
+  return [
+    "typescript",
+    "python",
+    "java",
+    "kotlin",
+    "go",
+    "csharp",
+    "php",
+    "ruby",
+    "rust",
+    "swift",
+    "cli",
+    "mcp",
+    "terraform"
+  ].includes(value);
+}
+function requireUniqueLanguages(languages) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const language of languages) {
+    if (seen.has(language)) {
+      fail(
+        "FERN_DUPLICATE_TARGET_LANGUAGE",
+        ["group", "generators"],
+        `SDK Config v1 cannot represent multiple Fern generators for language "${language}"`,
+        "Create a separate SDK Config document for each generator that targets the same language.",
+        ["targets"]
+      );
+    }
+    seen.add(language);
+  }
+}
+function requireSharedBlock(values, name, normalize) {
+  const first = normalize(values[0]);
+  const serialized = stableJson(first);
+  if (values.some((value) => stableJson(normalize(value)) !== serialized)) {
+    fail(
+      "FERN_TARGET_SPECIFIC_SHARED_CONFIG",
+      ["group", "generators"],
+      `SDK Config v1 cannot represent target-specific Fern ${name} configuration`,
+      `Choose one shared ${name} configuration manually or create separate SDK Config documents for the differing targets.`,
+      [name]
+    );
+  }
+  return first;
+}
+function mapInvocation(generator, language, index) {
+  const prefix = ["group", "generators", index];
+  const state = { consumedPaths: /* @__PURE__ */ new Set() };
+  const config = isObject(generator.config) ? generator.config : {};
+  const client = {};
+  const generation = {};
+  const packageConfig = {};
+  mapCommonConfig(config, state, client, generation, packageConfig, [...prefix, "config"]);
+  const targetGeneration = mapLanguageConfig(language, config, state, packageConfig, [
+    ...prefix,
+    "config"
+  ]);
+  mapPublishMetadata(generator.publishMetadata, packageConfig);
+  if (language === "go" && generator.smartCasing !== void 0) {
+    targetGeneration.smartCasing = generator.smartCasing;
+  }
+  if (generator.keywords?.length) {
+    generation.reservedKeywords = [...generator.keywords];
+  }
+  const settings = isObject(generator.settings) ? generator.settings : void 0;
+  if (settings) {
+    const inlinePathParameters = takeBoolean(settings, ["inlinePathParameters"], state, [
+      ...prefix,
+      "settings"
+    ]);
+    if (inlinePathParameters !== void 0 && client.pathParameterStyle === void 0) {
+      client.pathParameterStyle = inlinePathParameters ? "inline" : "wrapped";
+    }
+  }
+  const docs = mapReadme(generator.readme, state, [...prefix, "readme"]);
+  const unsupportedFields = [
+    ...collectUnsupported(config, [...prefix, "config"], state),
+    ...settings ? collectUnsupported(settings, [...prefix, "settings"], state) : [],
+    ...isObject(generator.readme) ? collectUnsupported(generator.readme, [...prefix, "readme"], state) : [],
+    ...unsupportedResolvedFields(generator, index, language)
+  ];
+  return { client, docs, generation, package: packageConfig, targetGeneration, unsupportedFields };
+}
+function unsupportedResolvedFields(generator, index, language) {
+  const values = [
+    ["automation", isDefaultAutomation(generator.automation) ? void 0 : generator.automation],
+    ["containerImage", generator.containerImage],
+    ["irVersionOverride", generator.irVersionOverride],
+    ["idempotencyKeyGenerationConfig", generator.idempotencyKeyGenerationConfig],
+    ["absolutePathToLocalSnippets", generator.absolutePathToLocalSnippets],
+    [
+      "smartCasingDigitWordBoundary",
+      generator.smartCasingDigitWordBoundary === false ? void 0 : generator.smartCasingDigitWordBoundary
+    ],
+    [
+      "disableExamples",
+      generator.disableExamples === false ? void 0 : generator.disableExamples
+    ],
+    ["apiOverride", generator.apiOverride],
+    ...language === "go" || generator.smartCasing === true ? [] : [["smartCasing", generator.smartCasing]]
+  ];
+  return values.flatMap(([field, value]) => {
+    if (value === void 0) return [];
+    const guidance = resolvedFieldGuidance(field);
+    return [
+      {
+        code: "FERN_RESOLVED_FIELD_UNSUPPORTED",
+        severity: "warning",
+        path: ["group", "generators", index, field],
+        reason: "Resolved Fern field is not represented by SDK Config v1",
+        ...optional("sdkConfigPath", guidance.sdkConfigPath),
+        suggestedAction: guidance.suggestedAction
+      }
+    ];
+  });
+}
+function resolvedFieldGuidance(field) {
+  if (field === "absolutePathToLocalSnippets") {
+    return {
+      sdkConfigPath: ["docs", "snippets", "outputPath"],
+      suggestedAction: "Choose a portable relative snippet path and set docs.snippets.outputPath manually."
+    };
+  }
+  if (field === "idempotencyKeyGenerationConfig") {
+    return {
+      suggestedAction: "Preserve this orchestration setting outside SDK Config; public v1 has no idempotency-generation field."
+    };
+  }
+  return {
+    suggestedAction: "Review this Fern setting and preserve it outside SDK Config, or set an equivalent SDK Config field manually if one is introduced."
+  };
+}
+function isDefaultAutomation(value) {
+  return isObject(value) && value.generate === true && value.upgrade === true && value.preview === true && value.verify === true;
+}
+function mapCommonConfig(config, state, client, generation, packageConfig, basePath) {
+  const inlinePath = takeBoolean(config, ["inlinePathParameters"], state, basePath);
+  const inlineFile = takeBoolean(config, ["inlineFileProperties"], state, basePath);
+  const inlineRequest = takeBoolean(config, ["inlineRequestParams"], state, basePath);
+  if (inlinePath !== void 0) client.pathParameterStyle = inlinePath ? "inline" : "wrapped";
+  if (inlineFile !== void 0) client.filePropertyStyle = inlineFile ? "inline" : "wrapped";
+  if (inlineRequest !== void 0)
+    client.requestParameterStyle = inlineRequest ? "inline" : "wrapped";
+  const timeoutMs = takeTimeoutMs(config, state, basePath);
+  if (timeoutMs !== void 0) client.timeoutMs = timeoutMs;
+  const skipValidation = takeBoolean(
+    config,
+    ["skipResponseValidation", "skipValidation"],
+    state,
+    basePath
+  );
+  if (skipValidation !== void 0) client.responseValidation = !skipValidation;
+  const useDefaults = takeBoolean(config, ["useDefaultRequestParameterValues"], state, basePath);
+  if (useDefaults !== void 0) client.useDefaultRequestParameterValues = useDefaults;
+  const respectOptionalBody = takeBoolean(config, ["respectOptionalRequestBody"], state, basePath);
+  if (respectOptionalBody !== void 0) client.respectOptionalRequestBody = respectOptionalBody;
+  const maxRetries = takeNumber(config, ["maxRetries"], state, basePath);
+  const statusCodeProfile = takeEnum(
+    config,
+    ["retryStatusCodes"],
+    ["legacy", "recommended"],
+    state,
+    basePath
+  );
+  if (maxRetries !== void 0 || statusCodeProfile !== void 0) {
+    client.retry = {
+      ...maxRetries === void 0 ? {} : { maxAttempts: maxRetries + 1 },
+      ...optional("statusCodeProfile", statusCodeProfile)
+    };
+  }
+  const naming = compact({
+    pagerName: takeString(
+      config,
+      ["customPagerName", "customPagerClassname", "customPagerClassName"],
+      state,
+      basePath
+    ),
+    clientName: takeString(config, ["clientName", "clientClassName"], state, basePath),
+    exportedClientName: takeString(
+      config,
+      ["exportedClientName", "exportedClientClassName"],
+      state,
+      basePath
+    ),
+    environmentTypeName: takeString(
+      config,
+      ["environmentClassName", "environmentEnumName"],
+      state,
+      basePath
+    ),
+    apiErrorName: takeString(config, ["baseApiExceptionClassName"], state, basePath),
+    baseErrorName: takeString(config, ["baseExceptionClassName"], state, basePath)
+  });
+  if (Object.keys(naming).length) generation.naming = naming;
+  const wireTests = takeBoolean(config, ["enableWireTests", "generateWireTests"], state, basePath);
+  if (wireTests !== void 0) generation.wireTests = { enabled: wireTests };
+  const webSockets = takeBoolean(
+    config,
+    ["generateWebSocketClients", "shouldGenerateWebsocketClients", "enableWebsockets"],
+    state,
+    basePath
+  );
+  if (webSockets !== void 0) generation.webSockets = webSockets;
+  const inlineTypes = takeBoolean(config, ["enableInlineTypes"], state, basePath);
+  const omitUndefined = takeBoolean(config, ["omitUndefined"], state, basePath);
+  const forwardEnums = takeBoolean(config, ["enableForwardCompatibleEnums"], state, basePath);
+  const serialization = compact({
+    inlineTypes,
+    omitUndefined,
+    enumRepresentation: forwardEnums === void 0 ? void 0 : forwardEnums ? "forward-compatible-enum" : "language-default"
+  });
+  if (Object.keys(serialization).length) generation.serialization = serialization;
+  const namespace = takeString(config, ["namespace", "packagePrefix"], state, basePath);
+  if (namespace !== void 0) packageConfig.namespace = namespace;
+  const packagePath = takeString(config, ["packagePath"], state, basePath);
+  if (packagePath !== void 0) generation.layout = { packagePath };
+  mapDependencies(config, state, packageConfig, basePath);
+}
+function mapLanguageConfig(language, config, state, packageConfig, basePath) {
+  switch (language) {
+    case "typescript":
+      return mapTypescript(config, state, packageConfig, basePath);
+    case "mcp":
+      return {
+        ...mapTypescript(config, state, packageConfig, basePath),
+        ...mapMcp(config, state, basePath)
+      };
+    case "python":
+      return mapPython(config, state, packageConfig, basePath);
+    case "java":
+    case "kotlin":
+      return mapJvm(language, config, state, packageConfig, basePath);
+    case "go":
+      return mapGo(config, state, packageConfig, basePath);
+    case "csharp":
+      return mapCsharp(config, state, packageConfig, basePath);
+    case "php":
+      return mapPhp(config, state, packageConfig, basePath);
+    case "ruby":
+      return mapRuby(config, state, packageConfig, basePath);
+    case "rust":
+      return mapRust(config, state, packageConfig, basePath);
+    case "swift":
+      return compact({ moduleName: takeString(config, ["moduleName"], state, basePath) });
+    case "cli":
+      return mapCli(config, state, packageConfig, basePath);
+    case "terraform":
+      return mapTerraform(config, state, packageConfig, basePath);
+  }
+}
+function mapTypescript(config, state, packageConfig, basePath) {
+  const packageJson = takeObject(config, ["packageJson"], state, basePath);
+  const packageName = packageJson ? takeString(packageJson.value, ["name"], state, packageJson.path) : void 0;
+  if (packageName !== void 0) packageConfig.packageName = packageName;
+  const serdeLayer = takeBoolean(config, ["serdeLayer"], state, basePath);
+  const noSerdeLayer = takeBoolean(config, ["noSerdeLayer"], state, basePath);
+  return compact({
+    typescriptVersion: takeString(config, ["typescriptVersion"], state, basePath),
+    zodVersion: takeString(config, ["zodVersion"], state, basePath),
+    packageManager: takeEnum(config, ["packageManager"], ["pnpm", "yarn"], state, basePath),
+    testFramework: takeEnum(config, ["testFramework"], ["jest", "vitest"], state, basePath),
+    bundle: takeBoolean(config, ["bundle"], state, basePath),
+    exportClassDefault: takeBoolean(config, ["exportClassDefault"], state, basePath),
+    allowCustomFetcher: takeBoolean(config, ["allowCustomFetcher"], state, basePath),
+    useBrandedStringAliases: takeBoolean(config, ["useBrandedStringAliases"], state, basePath),
+    useLegacyExports: takeBoolean(config, ["useLegacyExports"], state, basePath),
+    useBigInt: takeBoolean(config, ["useBigInt"], state, basePath),
+    serdeLayer: serdeLayer ?? (noSerdeLayer === void 0 ? void 0 : !noSerdeLayer)
+  });
+}
+function mapPython(config, state, packageConfig, basePath) {
+  const moduleName = takeString(config, ["packageName"], state, basePath);
+  const packageName = takeString(config, ["pypiPackageName"], state, basePath);
+  if (moduleName !== void 0) packageConfig.moduleName = moduleName;
+  if (packageName !== void 0) packageConfig.packageName = packageName;
+  return compact({
+    pythonVersion: takeString(config, ["pythonVersion", "pyprojectPythonVersion"], state, basePath),
+    pydanticVersion: takeString(config, ["pydanticVersion"], state, basePath),
+    alwaysInitializeOptionals: takeBoolean(config, ["alwaysInitializeOptionals"], state, basePath),
+    useTypedDictRequests: takeBoolean(config, ["useTypedDictRequests"], state, basePath)
+  });
+}
+function mapJvm(language, config, state, packageConfig, basePath) {
+  const namespace = takeString(config, ["packageName", "packagePrefix"], state, basePath);
+  const groupId = takeString(config, ["group", "groupId"], state, basePath);
+  const artifactId = takeString(config, ["artifact", "artifactId"], state, basePath);
+  if (namespace !== void 0) packageConfig.namespace = namespace;
+  if (groupId !== void 0) packageConfig.groupId = groupId;
+  if (artifactId !== void 0) packageConfig.artifactId = artifactId;
+  return compact({
+    packageLayout: takeEnum(config, ["packageLayout"], ["flat", "nested"], state, basePath),
+    useLocalDateForDates: takeBoolean(config, ["useLocalDateForDates"], state, basePath),
+    collapseOptionalNullable: takeBoolean(config, ["collapseOptionalNullable"], state, basePath),
+    gradleDistributionUrl: takeString(config, ["gradleDistributionUrl"], state, basePath),
+    gradlePluginManagement: takeString(config, ["gradlePluginManagement"], state, basePath),
+    gradleCentralDependencyManagement: takeBoolean(
+      config,
+      ["gradleCentralDependencyManagement"],
+      state,
+      basePath
+    ),
+    asyncStyle: takeEnum(
+      config,
+      ["asyncStyle"],
+      ["dedicated-client", "twin-methods"],
+      state,
+      basePath
+    ),
+    ...language === "java" ? {
+      includeKotlinSnippets: takeBoolean(config, ["includeKotlinSnippets"], state, basePath)
+    } : {}
+  });
+}
+function mapGo(config, state, packageConfig, basePath) {
+  const module = takeObject(config, ["module"], state, basePath);
+  const modulePath = module ? takeGoModulePath(module.value, ["path"], state, module.path) : void 0;
+  const packageName = takeString(config, ["packageName"], state, basePath);
+  if (modulePath !== void 0) packageConfig.modulePath = modulePath;
+  if (packageName !== void 0) packageConfig.packageName = packageName;
+  return compact({
+    legacyComplexModels: takeBoolean(config, ["legacyComplexModels"], state, basePath),
+    unionVersion: takeEnum(config, ["union"], ["v0", "v1"], state, basePath),
+    includeLegacyClientOptions: takeBoolean(
+      config,
+      ["includeLegacyClientOptions"],
+      state,
+      basePath
+    ),
+    clientConstructorName: takeString(config, ["clientConstructorName"], state, basePath)
+  });
+}
+function mapCsharp(config, state, packageConfig, basePath) {
+  const packageName = takeString(config, ["packageId"], state, basePath);
+  if (packageName !== void 0) packageConfig.packageName = packageName;
+  return compact({
+    useOptionalWrapper: takeBoolean(config, ["useOptionalWrapper"], state, basePath),
+    simplifyObjectDictionaries: takeBoolean(
+      config,
+      ["simplifyObjectDictionaries"],
+      state,
+      basePath
+    ),
+    explicitNamespaces: takeBoolean(config, ["explicitNamespaces"], state, basePath),
+    rootNamespaceForCoreClasses: takeBoolean(
+      config,
+      ["rootNamespaceForCoreClasses"],
+      state,
+      basePath
+    ),
+    includeExceptionHandler: takeBoolean(config, ["includeExceptionHandler"], state, basePath),
+    experimentalExplicitNullableOptional: takeBoolean(
+      config,
+      ["experimentalExplicitNullableOptional"],
+      state,
+      basePath
+    )
+  });
+}
+function mapPhp(config, state, packageConfig, basePath) {
+  const packageName = takeString(config, ["packageName"], state, basePath);
+  if (packageName !== void 0) packageConfig.packageName = packageName;
+  return compact({
+    propertyAccess: takeEnum(config, ["propertyAccess"], ["public", "private"], state, basePath),
+    generateClientInterfaces: takeBoolean(config, ["generateClientInterfaces"], state, basePath)
+  });
+}
+function mapRuby(config, state, packageConfig, basePath) {
+  const moduleName = takeString(config, ["moduleName"], state, basePath);
+  if (moduleName !== void 0) packageConfig.moduleName = moduleName;
+  return compact({ requirePaths: takeStringArray(config, ["requirePaths"], state, basePath) });
+}
+function mapRust(config, state, packageConfig, basePath) {
+  const packageName = takeString(config, ["crateName"], state, basePath);
+  const repository = takeString(config, ["packageRepository"], state, basePath);
+  const description = takeString(config, ["packageDescription"], state, basePath);
+  const documentationUrl = takeString(config, ["packageDocumentation"], state, basePath);
+  Object.assign(packageConfig, compact({ packageName, repository, description, documentationUrl }));
+  return compact({
+    dateTimeType: takeEnum(config, ["dateTimeType"], ["offset", "utc"], state, basePath),
+    capitalizeInitialisms: takeBoolean(config, ["capitalizeInitialisms"], state, basePath),
+    features: takeStringArrayRecord(config, ["features"], state, basePath),
+    defaultFeatures: takeStringArray(config, ["defaultFeatures"], state, basePath)
+  });
+}
+function mapCli(config, state, packageConfig, basePath) {
+  const identity = takeObject(config, ["packageIdentity"], state, basePath);
+  if (identity) {
+    Object.assign(
+      packageConfig,
+      compact({
+        packageName: takeString(identity.value, ["name"], state, identity.path),
+        repository: takeString(identity.value, ["repository"], state, identity.path),
+        description: takeString(identity.value, ["description"], state, identity.path)
+      })
+    );
+  }
+  return compact({
+    paginationParameters: takeStringArray(config, ["paginationParameters"], state, basePath),
+    skills: takeBoolean(config, ["skills"], state, basePath)
+  });
+}
+function mapTerraform(config, state, packageConfig, basePath) {
+  const providerModulePath = takeString(
+    config,
+    ["providerModulePath", "providerGoModuleName"],
+    state,
+    basePath
+  );
+  if (providerModulePath !== void 0) packageConfig.modulePath = providerModulePath;
+  return compact({
+    providerName: takeString(config, ["providerName"], state, basePath),
+    providerVersion: takeString(config, ["providerVersion"], state, basePath),
+    providerModulePath,
+    mockAcceptance: takeBoolean(config, ["mockAcceptance"], state, basePath),
+    hideComputedDiff: takeBoolean(config, ["hideComputedDiff"], state, basePath)
+  });
+}
+function mapMcp(config, state, basePath) {
+  return compact({
+    serverName: takeString(config, ["serverName"], state, basePath),
+    serverDescription: takeString(config, ["serverDescription"], state, basePath),
+    excludeAvailability: takeEnumArray(
+      config,
+      ["excludeAvailability"],
+      [
+        "IN_DEVELOPMENT",
+        "PRE_RELEASE",
+        "GENERAL_AVAILABILITY",
+        "DEPRECATED",
+        "ALPHA",
+        "BETA",
+        "PREVIEW",
+        "LEGACY"
+      ],
+      state,
+      basePath
+    ),
+    tools: takeToolFilter(config, ["tools"], state, basePath),
+    toolsets: takeToolsets(config, ["toolsets"], state, basePath)
+  });
+}
+function mapReadme(value, state, basePath) {
+  if (!isObject(value)) return {};
+  const readme = compact({
+    apiName: takeString(value, ["apiName"], state, basePath),
+    introduction: takeString(value, ["introduction"], state, basePath),
+    apiReferenceLink: takeString(value, ["apiReferenceLink"], state, basePath),
+    bannerLink: takeString(value, ["bannerLink"], state, basePath),
+    disabledSections: takeStringArray(value, ["disabledSections"], state, basePath),
+    customSections: takeCustomSections(value, state, basePath),
+    defaultEndpoint: takeReadmeEndpoint(value, ["defaultEndpoint"], state, basePath),
+    features: takeReadmeFeatures(value, state, basePath)
+  });
+  return Object.keys(readme).length ? { readme } : {};
+}
+function mapPublishMetadata(value, packageConfig) {
+  if (!isObject(value)) return;
+  const publisherName = stringValue(value.publisherName);
+  const publisherEmail = stringValue(value.publisherEmail);
+  Object.assign(
+    packageConfig,
+    compact({
+      description: stringValue(value.packageDescription),
+      documentationUrl: stringValue(value.referenceUrl),
+      authors: publisherName ? [{ name: publisherName, ...optional("email", publisherEmail) }] : void 0
+    })
+  );
+}
+function mapDependencies(config, state, packageConfig, basePath) {
+  for (const field of [
+    "extraDependencies",
+    "extraDevDependencies",
+    "extraPeerDependencies"
+  ]) {
+    const located = takeObject(config, [field], state, basePath);
+    if (!located) continue;
+    const dependencies = Object.entries(located.value).flatMap(
+      ([name, dependency]) => mapDependency(name, dependency, state, [...located.path, name])
+    );
+    if (dependencies.length) packageConfig[field] = dependencies;
+  }
+}
+function mapDependency(name, value, state, path) {
+  if (typeof value === "string" && value) {
+    consume(state, path);
+    return [{ name, version: value }];
+  }
+  if (!isObject(value)) return [];
+  const version = takeString(value, ["version"], state, path);
+  const gitUrl = takeString(value, ["git"], state, path);
+  const localPath = takeString(value, ["path"], state, path);
+  const source = gitUrl ? {
+    type: "git",
+    url: gitUrl,
+    ...optional("ref", takeString(value, ["ref"], state, path))
+  } : localPath ? { type: "path", path: localPath } : void 0;
+  if (!version && !source) return [];
+  return [
+    {
+      name,
+      ...optional("version", version),
+      ...optional("source", source),
+      ...optional("packageName", takeString(value, ["package"], state, path)),
+      ...optional("features", takeStringArray(value, ["features"], state, path)),
+      ...optional("extras", takeStringArray(value, ["extras"], state, path)),
+      ...optional("optional", takeBoolean(value, ["optional"], state, path)),
+      ...optional("defaultFeatures", takeBoolean(value, ["defaultFeatures"], state, path)),
+      ...optional("environmentMarker", takeString(value, ["python"], state, path))
+    }
+  ];
+}
+function takeCustomSections(value, state, basePath) {
+  const located = locate(value, ["customSections"], basePath);
+  if (!located || !Array.isArray(located.value)) return void 0;
+  const sections = located.value.flatMap(
+    (section) => isObject(section) && section.language === void 0 && typeof section.title === "string" && typeof section.content === "string" ? [{ title: section.title, content: section.content }] : []
+  );
+  if (sections.length !== located.value.length) return void 0;
+  consume(state, located.path);
+  return sections;
+}
+function takeReadmeEndpoint(value, aliases, state, basePath) {
+  const located = locate(value, aliases, basePath);
+  if (!located) return void 0;
+  const endpoint = parseReadmeEndpoint(located.value);
+  if (endpoint) consume(state, located.path);
+  return endpoint;
+}
+function takeReadmeFeatures(value, state, basePath) {
+  const located = locate(value, ["features"], basePath);
+  if (!located || !isObject(located.value)) return void 0;
+  const features = {};
+  for (const [name, endpoints] of Object.entries(located.value)) {
+    if (!Array.isArray(endpoints)) return void 0;
+    const parsed = endpoints.map(parseReadmeEndpoint);
+    if (parsed.some((endpoint) => !endpoint)) return void 0;
+    features[name] = parsed;
+  }
+  consume(state, located.path);
+  return features;
+}
+function parseReadmeEndpoint(value) {
+  if (typeof value === "string") {
+    const match = /^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE|CONNECT)\s+(\/\S*)$/.exec(
+      value.trim()
+    );
+    return match ? { method: match[1], path: match[2] } : void 0;
+  }
+  if (!isObject(value) || typeof value.method !== "string" || typeof value.path !== "string") {
+    return void 0;
+  }
+  const method = value.method.toUpperCase();
+  if (!["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "TRACE", "CONNECT"].includes(
+    method
+  )) {
+    return void 0;
+  }
+  return {
+    method,
+    path: value.path,
+    ...optional("stream", typeof value.stream === "boolean" ? value.stream : void 0)
+  };
+}
+function takeToolFilter(value, aliases, state, basePath) {
+  const located = takeObject(value, aliases, state, basePath);
+  if (!located) return void 0;
+  const filter = compact({
+    include: stringArrayValue(located.value.include),
+    exclude: stringArrayValue(located.value.exclude)
+  });
+  if (Object.keys(filter).length === 0 && Object.keys(located.value).length > 0) return void 0;
+  consume(state, located.path);
+  return filter;
+}
+function takeToolsets(value, aliases, state, basePath) {
+  const located = takeObject(value, aliases, state, basePath);
+  if (!located) return void 0;
+  const entries = Object.entries(located.value).map(([name, filter]) => {
+    if (name === "default" || !/^[a-z0-9-]+$/.test(name)) {
+      fail(
+        "FERN_MCP_TOOLSET_NAME_INVALID",
+        [...located.path, name],
+        `MCP toolset name "${name}" is not valid in SDK Config v1`,
+        'Rename the toolset to lowercase letters, numbers, or hyphens; "default" is reserved.',
+        ["targets", basePath[2], "generation", "toolsets", name]
+      );
+    }
+    if (!isObject(filter)) return void 0;
+    return [
+      name,
+      compact({
+        include: stringArrayValue(filter.include),
+        exclude: stringArrayValue(filter.exclude)
+      })
+    ];
+  });
+  if (entries.some((entry) => !entry)) return void 0;
+  consume(state, located.path);
+  return Object.fromEntries(entries.filter((entry) => entry !== void 0));
+}
+var unsupportedFieldSchema = z.strictObject({
+  source: z.enum(["fern", "postman", "sdk-config-ir"]),
+  path: z.array(z.union([nonEmptyStringSchema, z.number().int().nonnegative()])).min(1),
+  code: nonEmptyStringSchema.optional(),
+  reason: nonEmptyStringSchema,
+  severity: z.enum(["error", "warning", "info"]),
+  risk: z.enum(["high", "medium", "low"]),
+  owner: nonEmptyStringSchema,
+  suggestedAction: nonEmptyStringSchema
 });
-var projectUrlSchema = z.strictObject({
-  label: nonEmptyStringSchema,
-  url: nonEmptyStringSchema
+var postmanLegacyInputSchema = z.strictObject({
+  kind: z.literal("postman-build-parameters"),
+  value: jsonObjectSchema
 });
-var packageConfigSchema = z.strictObject({
-  packageName: nonEmptyStringSchema.optional(),
-  moduleName: nonEmptyStringSchema.optional(),
-  modulePath: goModulePathSchema.optional(),
-  namespace: nonEmptyStringSchema.optional(),
-  groupId: nonEmptyStringSchema.optional(),
-  artifactId: nonEmptyStringSchema.optional(),
-  description: z.string().optional(),
-  repository: nonEmptyStringSchema.optional(),
-  homepage: nonEmptyStringSchema.optional(),
-  documentationUrl: nonEmptyStringSchema.optional(),
-  authors: z.array(authorSchema).optional(),
-  developers: z.array(developerSchema).optional(),
-  license: licenseSchema.optional(),
-  keywords: z.array(nonEmptyStringSchema).optional(),
-  classifiers: z.array(nonEmptyStringSchema).optional(),
-  projectUrls: z.array(projectUrlSchema).optional(),
-  extraDependencies: z.array(dependencySchema).optional(),
-  extraDevDependencies: z.array(dependencySchema).optional(),
-  extraPeerDependencies: z.array(dependencySchema).optional()
+var fernLegacyInputSchema = z.strictObject({
+  kind: z.literal("fern-generator-invocation"),
+  value: jsonObjectSchema
 });
-
-// src/sdk-config-ir/v1/language/terraform.ts
-var planModifierSourceSchema = z.discriminatedUnion("enabled", [
-  z.strictObject({ enabled: z.literal(true), sourceDir: nonEmptyStringSchema }),
-  z.strictObject({ enabled: z.literal(false) })
+var legacyInputSchema = z.discriminatedUnion("kind", [
+  postmanLegacyInputSchema,
+  fernLegacyInputSchema
 ]);
-var planModifiersSchema = z.strictObject({
-  resources: planModifierSourceSchema,
-  attributes: planModifierSourceSchema
-});
-var providerSchemaSchema = z.strictObject({
-  addressKey: nonEmptyStringSchema,
-  authTokenKey: nonEmptyStringSchema
-});
-var terraformGenerationConfigSchema = z.strictObject({
-  providerName: nonEmptyStringSchema.optional(),
-  providerVersion: nonEmptyStringSchema.optional(),
-  providerModulePath: goModulePathSchema.optional(),
-  mockAcceptance: z.boolean().optional(),
-  hideComputedDiff: z.boolean().optional(),
-  providerSchema: providerSchemaSchema.optional(),
-  planModifiers: planModifiersSchema.optional()
+var compatibilityConfigSchema = z.strictObject({
+  outputProfile: z.enum(["converged", "postman-legacy", "fern-legacy"]),
+  legacyInput: legacyInputSchema.optional(),
+  unsupportedFields: z.array(unsupportedFieldSchema).optional()
 });
-
-// src/sdk-config-ir/v1/generation.ts
 var generationAssetSchema = z.strictObject({
   type: z.enum(["path", "url", "artifact"]),
   location: nonEmptyStringSchema
 });
-var hookDependencySchema = z.strictObject({
+var hookDependencySchema2 = z.strictObject({
   name: nonEmptyStringSchema,
   version: nonEmptyStringSchema,
   groupId: nonEmptyStringSchema.optional()
 });
-var hooksConfigSchema = z.strictObject({
+var hooksConfigSchema2 = z.strictObject({
   enabled: z.boolean(),
   source: generationAssetSchema.optional(),
-  dependencies: z.array(hookDependencySchema).optional()
+  dependencies: z.array(hookDependencySchema2).optional()
 });
-var customCodeConfigSchema = z.strictObject({
+var customCodeConfigSchema2 = z.strictObject({
   enabled: z.boolean(),
   source: generationAssetSchema.optional(),
   conflictStrategy: z.enum(["mark", "ours", "theirs"]).optional(),
@@ -525,19 +2235,19 @@ var customCodeConfigSchema = z.strictObject({
   previousBuildId: z.number().int().positive().optional(),
   protectedFiles: z.array(nonEmptyStringSchema).optional()
 });
-var workflowConfigSchema = z.strictObject({
+var workflowConfigSchema2 = z.strictObject({
   path: nonEmptyStringSchema,
   outputName: nonEmptyStringSchema.optional()
 });
-var analyticsHeaderSchema = z.union([
+var analyticsHeaderSchema2 = z.union([
   z.strictObject({ name: nonEmptyStringSchema, value: z.string() }),
   z.strictObject({ name: nonEmptyStringSchema, valueRef: nonEmptyStringSchema })
 ]);
-var analyticsConfigSchema = z.strictObject({
+var analyticsConfigSchema2 = z.strictObject({
   enabled: z.boolean(),
   endpoint: nonEmptyStringSchema.optional(),
   exporter: z.enum(["otlp-http", "console"]).optional(),
-  headers: z.array(analyticsHeaderSchema).optional(),
+  headers: z.array(analyticsHeaderSchema2).optional(),
   batchSize: z.number().int().positive().optional(),
   scheduledDelayMs: z.number().nonnegative().optional(),
   exportTimeoutMs: z.number().nonnegative().optional()
@@ -550,24 +2260,29 @@ var analyticsConfigSchema = z.strictObject({
     });
   }
 });
-var wireTestsSchema = z.strictObject({
+var wireTestsSchema2 = z.strictObject({
   enabled: z.boolean(),
   exclusions: z.array(nonEmptyStringSchema).optional(),
   fallbackToGeneratedErrorExamples: z.boolean().optional(),
   fixtureSource: z.enum(["synthetic", "recorded", "auto"]).optional()
 });
-var unitTestsSchema = z.strictObject({
+var unitTestsSchema2 = z.strictObject({
   enabled: z.boolean(),
   mode: z.enum(["core-runtime", "schema-driven", "both"]).optional(),
   exclusions: z.array(nonEmptyStringSchema).optional()
 });
-var streamsSchema = z.strictObject({
+var fernDefinitionMetadataSchema = z.strictObject({
+  definitionS3DownloadUrl: nonEmptyStringSchema,
+  outputPath: nonEmptyStringSchema.optional(),
+  cliVersion: nonEmptyStringSchema.optional()
+});
+var streamsSchema2 = z.strictObject({
   enabled: z.boolean(),
   responseType: z.enum(["wrapper", "native", "web"]).optional(),
   fileResponseType: z.enum(["stream", "binary-response"]).optional(),
   defaultChunkSizeBytes: z.number().int().positive().optional()
 });
-var namingConfigSchema = z.strictObject({
+var namingConfigSchema2 = z.strictObject({
   clientName: nonEmptyStringSchema.optional(),
   exportedClientName: nonEmptyStringSchema.optional(),
   environmentTypeName: nonEmptyStringSchema.optional(),
@@ -575,11 +2290,11 @@ var namingConfigSchema = z.strictObject({
   baseErrorName: nonEmptyStringSchema.optional(),
   pagerName: nonEmptyStringSchema.optional()
 });
-var layoutConfigSchema = z.strictObject({
+var layoutConfigSchema2 = z.strictObject({
   outputDirectory: z.enum(["project-root", "source-root"]).optional(),
   packagePath: nonEmptyStringSchema.optional()
 });
-var serializationConfigSchema = z.strictObject({
+var serializationConfigSchema2 = z.strictObject({
   enumRepresentation: z.enum(["enum", "union", "literal", "forward-compatible-enum", "language-default"]).optional(),
   additionalProperties: z.enum(["allow", "forbid", "ignore", "language-default"]).optional(),
   inlineTypes: z.boolean().optional(),
@@ -612,19 +2327,30 @@ var generationConfigSchema = z.strictObject({
   devContainer: z.boolean().default(false),
   allowMockClient: z.boolean().default(false),
   ignoreFiles: z.array(nonEmptyStringSchema).optional(),
+  /**
+   * Raw .fernignore file contents supplied to external publishers that need Fern ignore semantics.
+   * This is separate from generation.ignoreFiles because raw contents preserve comments, ordering,
+   * blank lines, and negation rules.
+   */
+  fernignoreContents: z.string().optional(),
+  /**
+   * Optional Fern definition metadata for publisher paths that need to write definition or
+   * mock-server support files. This is not required for core GitHub artifact publishing.
+   */
+  fernDefinitionMetadata: fernDefinitionMetadataSchema.optional(),
   reservedKeywords: z.array(nonEmptyStringSchema).optional(),
-  hooks: hooksConfigSchema.optional(),
-  customCode: customCodeConfigSchema.optional(),
-  workflows: z.array(workflowConfigSchema).optional(),
+  hooks: hooksConfigSchema2.optional(),
+  customCode: customCodeConfigSchema2.optional(),
+  workflows: z.array(workflowConfigSchema2).optional(),
   customQueryPaths: z.array(nonEmptyStringSchema).optional(),
-  analytics: analyticsConfigSchema.optional(),
-  wireTests: wireTestsSchema.optional(),
-  unitTests: unitTestsSchema.optional(),
+  analytics: analyticsConfigSchema2.optional(),
+  wireTests: wireTestsSchema2.optional(),
+  unitTests: unitTestsSchema2.optional(),
   webSockets: z.boolean().optional(),
-  streams: streamsSchema.optional(),
-  naming: namingConfigSchema.optional(),
-  layout: layoutConfigSchema.optional(),
-  serialization: serializationConfigSchema.optional(),
+  streams: streamsSchema2.optional(),
+  naming: namingConfigSchema2.optional(),
+  layout: layoutConfigSchema2.optional(),
+  serialization: serializationConfigSchema2.optional(),
   language: languageGenerationConfigSchema.optional()
 });
 var publishRegistrySchema = z.enum([
@@ -637,57 +2363,95 @@ var publishRegistrySchema = z.enum([
   "go",
   "composer"
 ]);
-var commonPublishShape = {
+var credentialResolutionSchema = z.enum([
+  "refs-only",
+  "resolved-by-orchestrator",
+  "resolved-by-fiddle"
+]);
+var commonPublishShape2 = {
   url: nonEmptyStringSchema.optional(),
+  /**
+   * Reference to registry publishing credentials. Raw tokens/passwords are intentionally not part of
+   * SDK Config IR; the external publisher or orchestrator resolves this reference before use.
+   */
   credentialsRef: nonEmptyStringSchema.optional(),
   releaseBranch: nonEmptyStringSchema.optional(),
   tolerateRepublish: z.boolean().optional()
 };
 var publishConfigSchema = z.discriminatedUnion("registry", [
-  z.strictObject({ registry: z.literal("npm"), ...commonPublishShape }),
-  z.strictObject({ registry: z.literal("pypi"), ...commonPublishShape }),
-  z.strictObject({ registry: z.literal("nuget"), ...commonPublishShape }),
-  z.strictObject({ registry: z.literal("rubygems"), ...commonPublishShape }),
-  z.strictObject({ registry: z.literal("crates"), ...commonPublishShape }),
-  z.strictObject({ registry: z.literal("go"), ...commonPublishShape }),
-  z.strictObject({ registry: z.literal("composer"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("npm"), ...commonPublishShape2 }),
+  z.strictObject({ registry: z.literal("pypi"), ...commonPublishShape2 }),
+  z.strictObject({ registry: z.literal("nuget"), ...commonPublishShape2 }),
+  z.strictObject({ registry: z.literal("rubygems"), ...commonPublishShape2 }),
+  z.strictObject({ registry: z.literal("crates"), ...commonPublishShape2 }),
+  z.strictObject({ registry: z.literal("go"), ...commonPublishShape2 }),
+  z.strictObject({ registry: z.literal("composer"), ...commonPublishShape2 }),
   z.strictObject({
     registry: z.literal("maven"),
+    /**
+     * Reference to Maven signing credentials. Raw signing keys are intentionally not part of SDK
+     * Config IR; the external publisher or orchestrator resolves this reference before use.
+     */
     signingCredentialsRef: nonEmptyStringSchema.optional(),
-    ...commonPublishShape
+    ...commonPublishShape2
   })
 ]);
-var reviewersSchema = z.strictObject({
+var reviewersSchema2 = z.strictObject({
   teams: z.array(nonEmptyStringSchema).optional(),
   users: z.array(nonEmptyStringSchema).optional()
 });
-var githubOutputSchema = z.strictObject({
+var replayControlSchema = z.strictObject({
+  enabled: z.boolean()
+});
+var githubOutputSchema2 = z.strictObject({
   repository: nonEmptyStringSchema,
   host: nonEmptyStringSchema.optional(),
   branch: nonEmptyStringSchema.optional(),
   mode: z.enum(["release", "pull-request", "push"]).optional(),
-  reviewers: reviewersSchema.optional(),
+  reviewers: reviewersSchema2.optional(),
+  /**
+   * Reference to GitHub credentials. Raw tokens are intentionally not part of SDK Config IR; the
+   * external publisher or orchestrator resolves this reference before use.
+   */
   credentialsRef: nonEmptyStringSchema.optional(),
-  privateRepository: z.boolean().optional()
-});
-var filesOutputSchema = z.strictObject({
+  privateRepository: z.boolean().optional(),
+  /** GitHub replay control. If omitted, the external publisher applies its default behavior. */
+  replay: replayControlSchema.optional(),
+  /** Run GitHub publishing verification. Defaults to false to match current Fiddle job behavior. */
+  verify: z.boolean().default(false),
+  /** Skip creating/updating a GitHub PR when no files changed. Defaults to false. */
+  skipIfNoDiff: z.boolean().default(false),
+  /** Automatically merge the GitHub publishing PR. Defaults to false. */
+  autoMerge: z.boolean().default(false)
+});
+var credentialResolutionShape = {
+  /**
+   * Where output credential references are resolved. SDK Config IR carries refs only; raw resolved
+   * credentials belong at the external publisher/orchestrator boundary, not in this config.
+   */
+  credentialResolution: credentialResolutionSchema.default("refs-only")
+};
+var filesOutputSchema2 = z.strictObject({
   delivery: z.literal("files"),
   path: nonEmptyStringSchema.optional(),
-  publish: publishConfigSchema.optional()
+  publish: publishConfigSchema.optional(),
+  ...credentialResolutionShape
 });
-var zipOutputSchema = z.strictObject({
+var zipOutputSchema2 = z.strictObject({
   delivery: z.literal("zip"),
   fileName: nonEmptyStringSchema.optional(),
-  publish: publishConfigSchema.optional()
+  publish: publishConfigSchema.optional(),
+  ...credentialResolutionShape
 });
-var githubDeliverySchema = z.strictObject({
+var githubDeliverySchema2 = z.strictObject({
   delivery: z.literal("github"),
-  github: githubOutputSchema,
-  publish: publishConfigSchema.optional()
+  github: githubOutputSchema2,
+  publish: publishConfigSchema.optional(),
+  ...credentialResolutionShape
 });
 var outputConfigSchema = z.discriminatedUnion(
   "delivery",
-  [filesOutputSchema, zipOutputSchema, githubDeliverySchema],
+  [filesOutputSchema2, zipOutputSchema2, githubDeliverySchema2],
   {
     error: 'output.delivery must be one of "files", "zip", or "github"'
   }
@@ -703,7 +2467,8 @@ var apiImportSettingsSchema = z.strictObject({
   onlyIncludeReferencedSchemas: z.boolean().optional(),
   objectQueryParameters: z.boolean().optional(),
   typeDatesAsStrings: z.boolean().optional(),
-  groupMultiApiEnvironments: z.boolean().optional()
+  groupMultiApiEnvironments: z.boolean().optional(),
+  defaultIntegerFormat: z.enum(["int32", "int64", "uint32", "uint64"]).optional()
 });
 var sourceSpecTypeSchema = z.enum([
   "openapi",
@@ -760,15 +2525,27 @@ var targetConfigSchema = z.strictObject({
   generatorVersion: exactSemverSchema.optional(),
   sourceOrigin: z.enum(["postman", "fern"]),
   sdkName: nonEmptyStringSchema,
+  /**
+   * Stable Fern/Fiddle API identity for external publishing.
+   * Producers must set this explicitly for GitHub or registry publishing; it is not inferred from
+   * target.sdkName because SDK display names and Fern API names are not equivalent.
+   */
+  apiName: nonEmptyStringSchema.optional(),
   organization: nonEmptyStringSchema.optional(),
+  /**
+   * Stable Fern/Fiddle organization identity for external publishing.
+   * Producers must set this explicitly for GitHub or registry publishing; it is not inferred from
+   * target.organization because source organization metadata is optional and may not match Fern.
+   */
+  organizationName: nonEmptyStringSchema.optional(),
   sdkVersion: nonEmptyStringSchema.default("1.0.0"),
   apiVersion: nonEmptyStringSchema.optional()
 });
 
 // src/sdk-config-ir/v1/sdk-config-ir-v1.ts
 var SDK_CONFIG_IR_V1_SCHEMA_VERSION = "sdk-config-ir/v1";
-var publishRegistryLanguages = {
-  npm: ["typescript"],
+var publishRegistryLanguages2 = {
+  npm: ["typescript", "mcp"],
   pypi: ["python"],
   maven: ["java", "kotlin"],
   nuget: ["csharp"],
@@ -777,7 +2554,7 @@ var publishRegistryLanguages = {
   go: ["go"],
   composer: ["php"]
 };
-var packageNameRegistries = /* @__PURE__ */ new Set([
+var packageNameRegistries2 = /* @__PURE__ */ new Set([
   "npm",
   "pypi",
   "nuget",
@@ -785,8 +2562,8 @@ var packageNameRegistries = /* @__PURE__ */ new Set([
   "crates",
   "composer"
 ]);
-function validatePublishingIdentity(packageConfig, registry, context) {
-  if (packageNameRegistries.has(registry) && !packageConfig.packageName) {
+function validatePublishingIdentity2(packageConfig, registry, context) {
+  if (packageNameRegistries2.has(registry) && !packageConfig.packageName) {
     context.addIssue({
       code: "custom",
       message: `package.packageName is required when publishing to "${registry}"`,
@@ -836,6 +2613,21 @@ var sdkConfigIrV1Schema = z.strictObject({
   compatibility: compatibilityConfigSchema.optional()
 }).superRefine(({ compatibility, generation, output, package: packageConfig, target }, context) => {
   const configuredLanguages = Object.keys(generation.language ?? {});
+  const requiresExternalPublishIdentity = output.delivery === "github" || output.publish !== void 0;
+  if (requiresExternalPublishIdentity) {
+    [
+      ["apiName", "target.apiName is required for external publishing"],
+      ["organizationName", "target.organizationName is required for external publishing"]
+    ].forEach(([field, message]) => {
+      if (!target[field]) {
+        context.addIssue({
+          code: "custom",
+          message,
+          path: ["target", field]
+        });
+      }
+    });
+  }
   configuredLanguages.forEach((language) => {
     if (language !== target.language) {
       context.addIssue({
@@ -845,7 +2637,7 @@ var sdkConfigIrV1Schema = z.strictObject({
       });
     }
   });
-  if (output.publish && !publishRegistryLanguages[output.publish.registry].some(
+  if (output.publish && !publishRegistryLanguages2[output.publish.registry].some(
     (language) => language === target.language
   )) {
     context.addIssue({
@@ -855,7 +2647,7 @@ var sdkConfigIrV1Schema = z.strictObject({
     });
   }
   if (output.publish) {
-    validatePublishingIdentity(packageConfig, output.publish.registry, context);
+    validatePublishingIdentity2(packageConfig, output.publish.registry, context);
   }
   if (compatibility?.legacyInput) {
     const expectedKind = target.sourceOrigin === "postman" ? "postman-build-parameters" : "fern-generator-invocation";
@@ -872,6 +2664,6 @@ function parseSdkConfigIrV1(value) {
   return sdkConfigIrV1Schema.parse(value);
 }
 
-export { SDK_CONFIG_IR_V1_SCHEMA_VERSION, apiConfigSchema, apiImportSettingsSchema, authConfigSchema, authSchemeSchema, cliGenerationConfigSchema, clientConfigSchema, compatibilityConfigSchema, composerPackageNameSchema, csharpGenerationConfigSchema, dependencySchema, docsConfigSchema, exactSemverSchema, generationConfigSchema, goGenerationConfigSchema, goModulePathSchema, javaGenerationConfigSchema, jsonObjectSchema, jsonValueSchema, kotlinGenerationConfigSchema, languageGenerationConfigSchema, legacyInputSchema, mcpGenerationConfigSchema, nonEmptyStringSchema, outputConfigSchema, packageConfigSchema, parseSdkConfigIrV1, phpGenerationConfigSchema, publishConfigSchema, publishRegistrySchema, pythonGenerationConfigSchema, readmeEndpointSchema, rubyGenerationConfigSchema, rustGenerationConfigSchema, sdkConfigIrV1Schema, sourceConfigSchema, sourceSpecConfigSchema, sourceSpecTypeSchema, swiftGenerationConfigSchema, targetConfigSchema, targetLanguageSchema, terraformGenerationConfigSchema, typescriptGenerationConfigSchema, unsupportedFieldSchema };
+export { FernConfigMappingError, SDK_CONFIG_IR_V1_SCHEMA_VERSION, SDK_CONFIG_V1_SCHEMA_VERSION, apiConfigSchema, apiImportSettingsSchema, authConfigSchema, authSchemeSchema, cliGenerationConfigSchema, clientConfigSchema, compatibilityConfigSchema, composerPackageNameSchema, csharpGenerationConfigSchema, dependencySchema, docsConfigSchema, exactSemverSchema, generationConfigSchema, goGenerationConfigSchema, goModulePathSchema, javaGenerationConfigSchema, jsonObjectSchema, jsonValueSchema, kotlinGenerationConfigSchema, languageGenerationConfigSchema, legacyInputSchema, mapFernConfigToSdkConfigV1, mcpAvailabilityStatuses, mcpGenerationConfigSchema, nonEmptyStringSchema, outputConfigSchema, packageConfigSchema, parseSdkConfigIrV1, parseSdkConfigV1, phpGenerationConfigSchema, publishConfigSchema, publishRegistrySchema, pythonGenerationConfigSchema, readmeCustomSectionSchema, readmeEndpointSchema, rubyGenerationConfigSchema, rustGenerationConfigSchema, sdkConfigIrV1Schema, sdkConfigV1ApiConfigSchema, sdkConfigV1AuthConfigSchema, sdkConfigV1AuthSchemeSchema, cliGenerationConfigSchema as sdkConfigV1CliGenerationConfigSchema, sdkConfigV1ClientConfigSchema, composerPackageNameSchema as sdkConfigV1ComposerPackageNameSchema, csharpGenerationConfigSchema as sdkConfigV1CsharpGenerationConfigSchema, sdkConfigV1DependencySchema, sdkConfigV1DocsConfigSchema, exactSemverSchema as sdkConfigV1ExactSemverSchema, sdkConfigV1GenerationConfigSchema, goGenerationConfigSchema as sdkConfigV1GoGenerationConfigSchema, goModulePathSchema as sdkConfigV1GoModulePathSchema, javaGenerationConfigSchema as sdkConfigV1JavaGenerationConfigSchema, kotlinGenerationConfigSchema as sdkConfigV1KotlinGenerationConfigSchema, mcpGenerationConfigSchema as sdkConfigV1McpGenerationConfigSchema, nonEmptyStringSchema as sdkConfigV1NonEmptyStringSchema, sdkConfigV1OutputConfigSchema, sdkConfigV1PackageConfigSchema, phpGenerationConfigSchema as sdkConfigV1PhpGenerationConfigSchema, sdkConfigV1PublishConfigSchema, sdkConfigV1PublishRegistrySchema, pythonGenerationConfigSchema as sdkConfigV1PythonGenerationConfigSchema, sdkConfigV1ReadmeCustomSectionSchema, sdkConfigV1ReadmeEndpointSchema, rubyGenerationConfigSchema as sdkConfigV1RubyGenerationConfigSchema, rustGenerationConfigSchema as sdkConfigV1RustGenerationConfigSchema, sdkConfigV1Schema, swiftGenerationConfigSchema as sdkConfigV1SwiftGenerationConfigSchema, sdkConfigV1TargetSchema, terraformGenerationConfigSchema as sdkConfigV1TerraformGenerationConfigSchema, typescriptGenerationConfigSchema as sdkConfigV1TypescriptGenerationConfigSchema, sourceConfigSchema, sourceSpecConfigSchema, sourceSpecTypeSchema, swiftGenerationConfigSchema, targetConfigSchema, targetLanguageSchema, terraformGenerationConfigSchema, typescriptGenerationConfigSchema, unsupportedFieldSchema };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map