@postman/sdk-config 0.0.4 → 0.1.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var semver__default = /*#__PURE__*/_interopDefault(semver);
 
-// src/sdk-config-ir/v1/api.ts
+// src/sdk-config-domain/v1/api.ts
 var nonEmptyStringSchema = zod.z.string().min(1);
 var exactSemverSchema = zod.z.string().refine(
   (value) => {
@@ -31,7 +31,7 @@ var jsonValueSchema = zod.z.lazy(
 );
 var jsonObjectSchema = zod.z.record(zod.z.string(), jsonValueSchema);
 
-// src/sdk-config-ir/v1/api.ts
+// src/sdk-config-domain/v1/api.ts
 var authVariableSchema = zod.z.strictObject({
   name: nonEmptyStringSchema.optional(),
   environmentVariable: nonEmptyStringSchema.optional(),
@@ -181,8 +181,20 @@ var apiConfigSchema = zod.z.strictObject({
   environmentVariables: zod.z.array(environmentVariableSchema).default([]),
   defaultEnvironment: nonEmptyStringSchema.optional(),
   auth: authConfigSchema.optional(),
-  headers: zod.z.array(headerSchema).optional()
+  headers: zod.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: zod.z.array(nonEmptyStringSchema).optional()
 });
+
+// src/sdk-config/v1/api.ts
+var sdkConfigV1AuthSchemeSchema = authSchemeSchema;
+var sdkConfigV1AuthConfigSchema = authConfigSchema;
+var sdkConfigV1ApiConfigSchema = apiConfigSchema;
 var retryConfigSchema = zod.z.strictObject({
   enabled: zod.z.boolean().default(true),
   maxAttempts: zod.z.number().int().min(1).default(3),
@@ -235,34 +247,89 @@ var clientConfigSchema = zod.z.strictObject({
   pathParameterStyle: parameterStyleSchema.optional(),
   filePropertyStyle: parameterStyleSchema.optional(),
   useDefaultRequestParameterValues: zod.z.boolean().optional(),
+  respectOptionalRequestBody: zod.z.boolean().optional(),
   tokenRefresh: tokenRefreshConfigSchema.optional()
 });
-var unsupportedFieldSchema = zod.z.strictObject({
-  source: zod.z.enum(["fern", "postman", "sdk-config-ir"]),
-  path: zod.z.array(zod.z.union([nonEmptyStringSchema, zod.z.number().int().nonnegative()])).min(1),
-  code: nonEmptyStringSchema.optional(),
-  reason: nonEmptyStringSchema,
-  severity: zod.z.enum(["error", "warning", "info"]),
-  risk: zod.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 = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  email: zod.z.email().optional()
 });
-var postmanLegacyInputSchema = zod.z.strictObject({
-  kind: zod.z.literal("postman-build-parameters"),
-  value: jsonObjectSchema
+var developerSchema = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  email: zod.z.email().optional(),
+  organization: nonEmptyStringSchema.optional(),
+  organizationUrl: nonEmptyStringSchema.optional()
 });
-var fernLegacyInputSchema = zod.z.strictObject({
-  kind: zod.z.literal("fern-generator-invocation"),
-  value: jsonObjectSchema
+var licenseSchema = zod.z.strictObject({
+  type: nonEmptyStringSchema,
+  name: nonEmptyStringSchema.optional(),
+  url: nonEmptyStringSchema.optional(),
+  path: nonEmptyStringSchema.optional()
 });
-var legacyInputSchema = zod.z.discriminatedUnion("kind", [
-  postmanLegacyInputSchema,
-  fernLegacyInputSchema
+var dependencySourceSchema = zod.z.discriminatedUnion("type", [
+  zod.z.strictObject({
+    type: zod.z.literal("registry"),
+    registry: nonEmptyStringSchema.optional()
+  }),
+  zod.z.strictObject({
+    type: zod.z.literal("git"),
+    url: nonEmptyStringSchema,
+    ref: nonEmptyStringSchema.optional(),
+    subdirectory: nonEmptyStringSchema.optional()
+  }),
+  zod.z.strictObject({
+    type: zod.z.literal("path"),
+    path: nonEmptyStringSchema
+  })
 ]);
-var compatibilityConfigSchema = zod.z.strictObject({
-  outputProfile: zod.z.enum(["converged", "postman-legacy", "fern-legacy"]),
-  legacyInput: legacyInputSchema.optional(),
-  unsupportedFields: zod.z.array(unsupportedFieldSchema).optional()
+var dependencySchema = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  version: nonEmptyStringSchema.optional(),
+  source: dependencySourceSchema.optional(),
+  packageName: nonEmptyStringSchema.optional(),
+  features: zod.z.array(nonEmptyStringSchema).optional(),
+  extras: zod.z.array(nonEmptyStringSchema).optional(),
+  optional: zod.z.boolean().optional(),
+  defaultFeatures: zod.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 = zod.z.strictObject({
+  label: nonEmptyStringSchema,
+  url: nonEmptyStringSchema
+});
+var packageConfigSchema = zod.z.strictObject({
+  packageName: nonEmptyStringSchema.optional(),
+  moduleName: nonEmptyStringSchema.optional(),
+  modulePath: goModulePathSchema.optional(),
+  namespace: nonEmptyStringSchema.optional(),
+  groupId: nonEmptyStringSchema.optional(),
+  artifactId: nonEmptyStringSchema.optional(),
+  description: zod.z.string().optional(),
+  repository: nonEmptyStringSchema.optional(),
+  homepage: nonEmptyStringSchema.optional(),
+  documentationUrl: nonEmptyStringSchema.optional(),
+  authors: zod.z.array(authorSchema).optional(),
+  developers: zod.z.array(developerSchema).optional(),
+  license: licenseSchema.optional(),
+  keywords: zod.z.array(nonEmptyStringSchema).optional(),
+  classifiers: zod.z.array(nonEmptyStringSchema).optional(),
+  projectUrls: zod.z.array(projectUrlSchema).optional(),
+  extraDependencies: zod.z.array(dependencySchema).optional(),
+  extraDevDependencies: zod.z.array(dependencySchema).optional(),
+  extraPeerDependencies: zod.z.array(dependencySchema).optional()
 });
 var httpMethodSchema = zod.z.enum([
   "GET",
@@ -280,12 +347,17 @@ var readmeEndpointSchema = zod.z.strictObject({
   path: nonEmptyStringSchema,
   stream: zod.z.boolean().optional()
 });
+var readmeCustomSectionSchema = zod.z.strictObject({
+  title: nonEmptyStringSchema,
+  content: zod.z.string()
+});
 var readmeConfigSchema = zod.z.strictObject({
   apiName: nonEmptyStringSchema.optional(),
   introduction: zod.z.string().optional(),
   apiReferenceLink: nonEmptyStringSchema.optional(),
   bannerLink: nonEmptyStringSchema.optional(),
   disabledSections: zod.z.array(nonEmptyStringSchema).optional(),
+  customSections: zod.z.array(readmeCustomSectionSchema).optional(),
   defaultEndpoint: readmeEndpointSchema.optional(),
   features: zod.z.record(zod.z.string(), zod.z.array(readmeEndpointSchema)).optional()
 });
@@ -300,6 +372,737 @@ var docsConfigSchema = zod.z.strictObject({
   referenceBaseUrl: nonEmptyStringSchema.optional(),
   includeApiReference: zod.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 = zod.z.discriminatedUnion("type", [
+  zod.z.strictObject({ type: zod.z.literal("path"), location: nonEmptyStringSchema }),
+  zod.z.strictObject({ type: zod.z.literal("url"), location: nonEmptyStringSchema })
+]);
+var hookDependencySchema = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  version: nonEmptyStringSchema,
+  groupId: nonEmptyStringSchema.optional()
+});
+var hooksConfigSchema = zod.z.strictObject({
+  enabled: zod.z.boolean(),
+  source: customerGenerationAssetSchema.optional(),
+  dependencies: zod.z.array(hookDependencySchema).optional()
+});
+var customCodeConfigSchema = zod.z.strictObject({
+  enabled: zod.z.boolean(),
+  source: customerGenerationAssetSchema.optional(),
+  conflictStrategy: zod.z.enum(["mark", "ours", "theirs"]).optional(),
+  trackChanges: zod.z.boolean().optional(),
+  protectedFiles: zod.z.array(nonEmptyStringSchema).optional()
+});
+var workflowConfigSchema = zod.z.strictObject({
+  path: nonEmptyStringSchema,
+  outputName: nonEmptyStringSchema.optional()
+});
+var analyticsHeaderSchema = zod.z.union([
+  zod.z.strictObject({ name: nonEmptyStringSchema, value: zod.z.string() }),
+  zod.z.strictObject({
+    name: nonEmptyStringSchema,
+    valueRef: nonEmptyStringSchema
+  })
+]);
+var analyticsConfigSchema = zod.z.strictObject({
+  enabled: zod.z.boolean(),
+  endpoint: nonEmptyStringSchema.optional(),
+  exporter: zod.z.enum(["otlp-http", "console"]).optional(),
+  headers: zod.z.array(analyticsHeaderSchema).optional(),
+  batchSize: zod.z.number().int().positive().optional(),
+  scheduledDelayMs: zod.z.number().nonnegative().optional(),
+  exportTimeoutMs: zod.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 = zod.z.strictObject({
+  enabled: zod.z.boolean(),
+  exclusions: zod.z.array(nonEmptyStringSchema).optional(),
+  fallbackToGeneratedErrorExamples: zod.z.boolean().optional(),
+  fixtureSource: zod.z.enum(["synthetic", "recorded", "auto"]).optional()
+});
+var unitTestsSchema = zod.z.strictObject({
+  enabled: zod.z.boolean(),
+  mode: zod.z.enum(["core-runtime", "schema-driven", "both"]).optional(),
+  exclusions: zod.z.array(nonEmptyStringSchema).optional()
+});
+var streamsSchema = zod.z.strictObject({
+  enabled: zod.z.boolean(),
+  responseType: zod.z.enum(["wrapper", "native", "web"]).optional(),
+  fileResponseType: zod.z.enum(["stream", "binary-response"]).optional(),
+  defaultChunkSizeBytes: zod.z.number().int().positive().optional()
+});
+var namingConfigSchema = zod.z.strictObject({
+  clientName: nonEmptyStringSchema.optional(),
+  exportedClientName: nonEmptyStringSchema.optional(),
+  environmentTypeName: nonEmptyStringSchema.optional(),
+  apiErrorName: nonEmptyStringSchema.optional(),
+  baseErrorName: nonEmptyStringSchema.optional(),
+  pagerName: nonEmptyStringSchema.optional()
+});
+var layoutConfigSchema = zod.z.strictObject({
+  outputDirectory: zod.z.enum(["project-root", "source-root"]).optional(),
+  packagePath: nonEmptyStringSchema.optional()
+});
+var serializationConfigSchema = zod.z.strictObject({
+  enumRepresentation: zod.z.enum(["enum", "union", "literal", "forward-compatible-enum", "language-default"]).optional(),
+  additionalProperties: zod.z.enum(["allow", "forbid", "ignore", "language-default"]).optional(),
+  inlineTypes: zod.z.boolean().optional(),
+  omitUndefined: zod.z.boolean().optional()
+});
+var sdkConfigV1GenerationConfigSchema = zod.z.strictObject({
+  includeWatermark: zod.z.boolean().default(false),
+  ai: zod.z.boolean().default(false),
+  includeOptionalSnippetParameters: zod.z.boolean().optional(),
+  buildAllModels: zod.z.boolean().default(false),
+  inferServiceNames: zod.z.boolean().default(false),
+  includeDeprecatedOperations: zod.z.boolean().default(true),
+  multipleResponses: zod.z.boolean().default(false),
+  devContainer: zod.z.boolean().default(false),
+  allowMockClient: zod.z.boolean().default(false),
+  ignoreFiles: zod.z.array(nonEmptyStringSchema).optional(),
+  reservedKeywords: zod.z.array(nonEmptyStringSchema).optional(),
+  hooks: hooksConfigSchema.optional(),
+  customCode: customCodeConfigSchema.optional(),
+  workflows: zod.z.array(workflowConfigSchema).optional(),
+  customQueryPaths: zod.z.array(nonEmptyStringSchema).optional(),
+  analytics: analyticsConfigSchema.optional(),
+  wireTests: wireTestsSchema.optional(),
+  unitTests: unitTestsSchema.optional(),
+  webSockets: zod.z.boolean().optional(),
+  streams: streamsSchema.optional(),
+  naming: namingConfigSchema.optional(),
+  layout: layoutConfigSchema.optional(),
+  serialization: serializationConfigSchema.optional()
+});
+var sdkConfigV1PublishRegistrySchema = zod.z.enum([
+  "npm",
+  "pypi",
+  "maven",
+  "nuget",
+  "rubygems",
+  "crates",
+  "go",
+  "composer"
+]);
+var commonPublishShape = {
+  url: nonEmptyStringSchema.optional(),
+  releaseBranch: nonEmptyStringSchema.optional(),
+  tolerateRepublish: zod.z.boolean().optional()
+};
+var sdkConfigV1PublishConfigSchema = zod.z.discriminatedUnion("registry", [
+  zod.z.strictObject({ registry: zod.z.literal("npm"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("pypi"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("maven"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("nuget"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("rubygems"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("crates"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("go"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("composer"), ...commonPublishShape })
+]);
+var reviewersSchema = zod.z.strictObject({
+  teams: zod.z.array(nonEmptyStringSchema).optional(),
+  users: zod.z.array(nonEmptyStringSchema).optional()
+});
+var githubOutputSchema = zod.z.strictObject({
+  repository: nonEmptyStringSchema,
+  host: nonEmptyStringSchema.optional(),
+  branch: nonEmptyStringSchema.optional(),
+  mode: zod.z.enum(["release", "pull-request", "push"]).optional(),
+  reviewers: reviewersSchema.optional(),
+  privateRepository: zod.z.boolean().optional()
+});
+var filesOutputSchema = zod.z.strictObject({
+  delivery: zod.z.literal("files"),
+  path: nonEmptyStringSchema.optional(),
+  publish: sdkConfigV1PublishConfigSchema.optional()
+});
+var zipOutputSchema = zod.z.strictObject({
+  delivery: zod.z.literal("zip"),
+  fileName: nonEmptyStringSchema.optional(),
+  publish: sdkConfigV1PublishConfigSchema.optional()
+});
+var githubDeliverySchema = zod.z.strictObject({
+  delivery: zod.z.literal("github"),
+  github: githubOutputSchema,
+  publish: sdkConfigV1PublishConfigSchema.optional()
+});
+var sdkConfigV1OutputConfigSchema = zod.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 = zod.z.strictObject({
   paginationParameters: zod.z.array(nonEmptyStringSchema).optional(),
   skills: zod.z.boolean().optional()
@@ -309,10 +1112,15 @@ var csharpGenerationConfigSchema = zod.z.strictObject({
   simplifyObjectDictionaries: zod.z.boolean().optional(),
   explicitNamespaces: zod.z.boolean().optional(),
   rootNamespaceForCoreClasses: zod.z.boolean().optional(),
-  includeExceptionHandler: zod.z.boolean().optional()
+  includeExceptionHandler: zod.z.boolean().optional(),
+  experimentalExplicitNullableOptional: zod.z.boolean().optional()
 });
 var goGenerationConfigSchema = zod.z.strictObject({
   legacyComplexModels: zod.z.boolean().optional(),
+  /** Uppercase common initialisms in generated names (`UserID` rather than `UserId`). */
+  smartCasing: zod.z.boolean().optional(),
+  /** Overrides the fern root-client constructor independently from the client type name. */
+  clientConstructorName: nonEmptyStringSchema.optional(),
   unionVersion: zod.z.enum(["v0", "v1"]).optional(),
   includeLegacyClientOptions: zod.z.boolean().optional()
 });
@@ -322,15 +1130,17 @@ var jvmGenerationConfigSchema = zod.z.strictObject({
   collapseOptionalNullable: zod.z.boolean().optional(),
   gradleDistributionUrl: zod.z.string().min(1).optional(),
   gradlePluginManagement: zod.z.string().optional(),
-  gradleCentralDependencyManagement: zod.z.boolean().optional()
+  gradleCentralDependencyManagement: zod.z.boolean().optional(),
+  /** Selects co-located async methods or a separate async client surface. */
+  asyncStyle: zod.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: zod.z.boolean().optional()
 });
 
-// src/sdk-config-ir/v1/language/kotlin.ts
+// src/sdk-config-domain/v1/language/kotlin.ts
 var kotlinGenerationConfigSchema = jvmGenerationConfigSchema;
 var compilerOptionsSchema = zod.z.strictObject({
   target: nonEmptyStringSchema.optional(),
@@ -362,8 +1172,32 @@ var typescriptGenerationConfigSchema = zod.z.strictObject({
   scripts: zod.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 = zod.z.strictObject({
+  include: zod.z.array(nonEmptyStringSchema).optional(),
+  exclude: zod.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: zod.z.array(zod.z.enum(mcpAvailabilityStatuses)).optional(),
+  tools: mcpToolFilterSchema.optional(),
+  toolsets: zod.z.record(mcpToolsetNameSchema, mcpToolFilterSchema).optional()
+});
 var phpGenerationConfigSchema = zod.z.strictObject({
   propertyAccess: zod.z.enum(["public", "private"]).optional(),
   generateClientInterfaces: zod.z.boolean().optional()
@@ -404,126 +1238,1002 @@ var rustGenerationConfigSchema = zod.z.strictObject({
   defaultFeatures: zod.z.array(nonEmptyStringSchema).optional()
 });
 var swiftGenerationConfigSchema = zod.z.strictObject({
-  moduleName: nonEmptyStringSchema.optional()
+  moduleName: nonEmptyStringSchema.optional(),
+  nullableAsOptional: zod.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 = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  email: zod.z.email().optional()
+var planModifierSourceSchema = zod.z.discriminatedUnion("enabled", [
+  zod.z.strictObject({ enabled: zod.z.literal(true), sourceDir: nonEmptyStringSchema }),
+  zod.z.strictObject({ enabled: zod.z.literal(false) })
+]);
+var planModifiersSchema = zod.z.strictObject({
+  resources: planModifierSourceSchema,
+  attributes: planModifierSourceSchema
 });
-var developerSchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  email: zod.z.email().optional(),
-  organization: nonEmptyStringSchema.optional(),
-  organizationUrl: nonEmptyStringSchema.optional()
+var providerSchemaSchema = zod.z.strictObject({
+  addressKey: nonEmptyStringSchema,
+  authTokenKey: nonEmptyStringSchema
 });
-var licenseSchema = zod.z.strictObject({
-  type: nonEmptyStringSchema,
-  name: nonEmptyStringSchema.optional(),
-  url: nonEmptyStringSchema.optional(),
-  path: nonEmptyStringSchema.optional()
+var terraformGenerationConfigSchema = zod.z.strictObject({
+  providerName: nonEmptyStringSchema.optional(),
+  providerVersion: nonEmptyStringSchema.optional(),
+  providerModulePath: goModulePathSchema.optional(),
+  mockAcceptance: zod.z.boolean().optional(),
+  hideComputedDiff: zod.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 = zod.z.discriminatedUnion("language", [
+  zod.z.strictObject({
+    language: zod.z.literal("typescript"),
+    generation: typescriptGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  zod.z.strictObject({
+    language: zod.z.literal("python"),
+    generation: pythonGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  zod.z.strictObject({
+    language: zod.z.literal("java"),
+    generation: javaGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  zod.z.strictObject({
+    language: zod.z.literal("kotlin"),
+    generation: kotlinGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  zod.z.strictObject({
+    language: zod.z.literal("go"),
+    generation: goGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  zod.z.strictObject({
+    language: zod.z.literal("csharp"),
+    generation: csharpGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  zod.z.strictObject({
+    language: zod.z.literal("php"),
+    generation: phpGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  zod.z.strictObject({
+    language: zod.z.literal("ruby"),
+    generation: rubyGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  zod.z.strictObject({
+    language: zod.z.literal("rust"),
+    generation: rustGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  zod.z.strictObject({
+    language: zod.z.literal("swift"),
+    generation: swiftGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  zod.z.strictObject({
+    language: zod.z.literal("cli"),
+    generation: cliGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  zod.z.strictObject({
+    language: zod.z.literal("mcp"),
+    generation: mcpGenerationConfigSchema.optional(),
+    ...targetOverrideShape
+  }),
+  zod.z.strictObject({
+    language: zod.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 = zod.z.strictObject({
+  schemaVersion: zod.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: zod.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 = zod.z.discriminatedUnion("type", [
-  zod.z.strictObject({
-    type: zod.z.literal("registry"),
-    registry: nonEmptyStringSchema.optional()
-  }),
-  zod.z.strictObject({
-    type: zod.z.literal("git"),
-    url: nonEmptyStringSchema,
-    ref: nonEmptyStringSchema.optional(),
-    subdirectory: nonEmptyStringSchema.optional()
-  }),
-  zod.z.strictObject({
-    type: zod.z.literal("path"),
-    path: nonEmptyStringSchema
-  })
-]);
-var dependencySchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  version: nonEmptyStringSchema.optional(),
-  source: dependencySourceSchema.optional(),
-  packageName: nonEmptyStringSchema.optional(),
-  features: zod.z.array(nonEmptyStringSchema).optional(),
-  extras: zod.z.array(nonEmptyStringSchema).optional(),
-  optional: zod.z.boolean().optional(),
-  defaultFeatures: zod.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 = zod.z.strictObject({
+  source: zod.z.enum(["fern", "postman", "sdk-config-ir"]),
+  path: zod.z.array(zod.z.union([nonEmptyStringSchema, zod.z.number().int().nonnegative()])).min(1),
+  code: nonEmptyStringSchema.optional(),
+  reason: nonEmptyStringSchema,
+  severity: zod.z.enum(["error", "warning", "info"]),
+  risk: zod.z.enum(["high", "medium", "low"]),
+  owner: nonEmptyStringSchema,
+  suggestedAction: nonEmptyStringSchema
 });
-var projectUrlSchema = zod.z.strictObject({
-  label: nonEmptyStringSchema,
-  url: nonEmptyStringSchema
+var postmanLegacyInputSchema = zod.z.strictObject({
+  kind: zod.z.literal("postman-build-parameters"),
+  value: jsonObjectSchema
 });
-var packageConfigSchema = zod.z.strictObject({
-  packageName: nonEmptyStringSchema.optional(),
-  moduleName: nonEmptyStringSchema.optional(),
-  modulePath: goModulePathSchema.optional(),
-  namespace: nonEmptyStringSchema.optional(),
-  groupId: nonEmptyStringSchema.optional(),
-  artifactId: nonEmptyStringSchema.optional(),
-  description: zod.z.string().optional(),
-  repository: nonEmptyStringSchema.optional(),
-  homepage: nonEmptyStringSchema.optional(),
-  documentationUrl: nonEmptyStringSchema.optional(),
-  authors: zod.z.array(authorSchema).optional(),
-  developers: zod.z.array(developerSchema).optional(),
-  license: licenseSchema.optional(),
-  keywords: zod.z.array(nonEmptyStringSchema).optional(),
-  classifiers: zod.z.array(nonEmptyStringSchema).optional(),
-  projectUrls: zod.z.array(projectUrlSchema).optional(),
-  extraDependencies: zod.z.array(dependencySchema).optional(),
-  extraDevDependencies: zod.z.array(dependencySchema).optional(),
-  extraPeerDependencies: zod.z.array(dependencySchema).optional()
+var fernLegacyInputSchema = zod.z.strictObject({
+  kind: zod.z.literal("fern-generator-invocation"),
+  value: jsonObjectSchema
 });
-
-// src/sdk-config-ir/v1/language/terraform.ts
-var planModifierSourceSchema = zod.z.discriminatedUnion("enabled", [
-  zod.z.strictObject({ enabled: zod.z.literal(true), sourceDir: nonEmptyStringSchema }),
-  zod.z.strictObject({ enabled: zod.z.literal(false) })
+var legacyInputSchema = zod.z.discriminatedUnion("kind", [
+  postmanLegacyInputSchema,
+  fernLegacyInputSchema
 ]);
-var planModifiersSchema = zod.z.strictObject({
-  resources: planModifierSourceSchema,
-  attributes: planModifierSourceSchema
-});
-var providerSchemaSchema = zod.z.strictObject({
-  addressKey: nonEmptyStringSchema,
-  authTokenKey: nonEmptyStringSchema
-});
-var terraformGenerationConfigSchema = zod.z.strictObject({
-  providerName: nonEmptyStringSchema.optional(),
-  providerVersion: nonEmptyStringSchema.optional(),
-  providerModulePath: goModulePathSchema.optional(),
-  mockAcceptance: zod.z.boolean().optional(),
-  hideComputedDiff: zod.z.boolean().optional(),
-  providerSchema: providerSchemaSchema.optional(),
-  planModifiers: planModifiersSchema.optional()
+var compatibilityConfigSchema = zod.z.strictObject({
+  outputProfile: zod.z.enum(["converged", "postman-legacy", "fern-legacy"]),
+  legacyInput: legacyInputSchema.optional(),
+  unsupportedFields: zod.z.array(unsupportedFieldSchema).optional()
 });
-
-// src/sdk-config-ir/v1/generation.ts
 var generationAssetSchema = zod.z.strictObject({
   type: zod.z.enum(["path", "url", "artifact"]),
   location: nonEmptyStringSchema
 });
-var hookDependencySchema = zod.z.strictObject({
+var hookDependencySchema2 = zod.z.strictObject({
   name: nonEmptyStringSchema,
   version: nonEmptyStringSchema,
   groupId: nonEmptyStringSchema.optional()
 });
-var hooksConfigSchema = zod.z.strictObject({
+var hooksConfigSchema2 = zod.z.strictObject({
   enabled: zod.z.boolean(),
   source: generationAssetSchema.optional(),
-  dependencies: zod.z.array(hookDependencySchema).optional()
+  dependencies: zod.z.array(hookDependencySchema2).optional()
 });
-var customCodeConfigSchema = zod.z.strictObject({
+var customCodeConfigSchema2 = zod.z.strictObject({
   enabled: zod.z.boolean(),
   source: generationAssetSchema.optional(),
   conflictStrategy: zod.z.enum(["mark", "ours", "theirs"]).optional(),
@@ -531,19 +2241,19 @@ var customCodeConfigSchema = zod.z.strictObject({
   previousBuildId: zod.z.number().int().positive().optional(),
   protectedFiles: zod.z.array(nonEmptyStringSchema).optional()
 });
-var workflowConfigSchema = zod.z.strictObject({
+var workflowConfigSchema2 = zod.z.strictObject({
   path: nonEmptyStringSchema,
   outputName: nonEmptyStringSchema.optional()
 });
-var analyticsHeaderSchema = zod.z.union([
+var analyticsHeaderSchema2 = zod.z.union([
   zod.z.strictObject({ name: nonEmptyStringSchema, value: zod.z.string() }),
   zod.z.strictObject({ name: nonEmptyStringSchema, valueRef: nonEmptyStringSchema })
 ]);
-var analyticsConfigSchema = zod.z.strictObject({
+var analyticsConfigSchema2 = zod.z.strictObject({
   enabled: zod.z.boolean(),
   endpoint: nonEmptyStringSchema.optional(),
   exporter: zod.z.enum(["otlp-http", "console"]).optional(),
-  headers: zod.z.array(analyticsHeaderSchema).optional(),
+  headers: zod.z.array(analyticsHeaderSchema2).optional(),
   batchSize: zod.z.number().int().positive().optional(),
   scheduledDelayMs: zod.z.number().nonnegative().optional(),
   exportTimeoutMs: zod.z.number().nonnegative().optional()
@@ -556,24 +2266,29 @@ var analyticsConfigSchema = zod.z.strictObject({
     });
   }
 });
-var wireTestsSchema = zod.z.strictObject({
+var wireTestsSchema2 = zod.z.strictObject({
   enabled: zod.z.boolean(),
   exclusions: zod.z.array(nonEmptyStringSchema).optional(),
   fallbackToGeneratedErrorExamples: zod.z.boolean().optional(),
   fixtureSource: zod.z.enum(["synthetic", "recorded", "auto"]).optional()
 });
-var unitTestsSchema = zod.z.strictObject({
+var unitTestsSchema2 = zod.z.strictObject({
   enabled: zod.z.boolean(),
   mode: zod.z.enum(["core-runtime", "schema-driven", "both"]).optional(),
   exclusions: zod.z.array(nonEmptyStringSchema).optional()
 });
-var streamsSchema = zod.z.strictObject({
+var fernDefinitionMetadataSchema = zod.z.strictObject({
+  definitionS3DownloadUrl: nonEmptyStringSchema,
+  outputPath: nonEmptyStringSchema.optional(),
+  cliVersion: nonEmptyStringSchema.optional()
+});
+var streamsSchema2 = zod.z.strictObject({
   enabled: zod.z.boolean(),
   responseType: zod.z.enum(["wrapper", "native", "web"]).optional(),
   fileResponseType: zod.z.enum(["stream", "binary-response"]).optional(),
   defaultChunkSizeBytes: zod.z.number().int().positive().optional()
 });
-var namingConfigSchema = zod.z.strictObject({
+var namingConfigSchema2 = zod.z.strictObject({
   clientName: nonEmptyStringSchema.optional(),
   exportedClientName: nonEmptyStringSchema.optional(),
   environmentTypeName: nonEmptyStringSchema.optional(),
@@ -581,11 +2296,11 @@ var namingConfigSchema = zod.z.strictObject({
   baseErrorName: nonEmptyStringSchema.optional(),
   pagerName: nonEmptyStringSchema.optional()
 });
-var layoutConfigSchema = zod.z.strictObject({
+var layoutConfigSchema2 = zod.z.strictObject({
   outputDirectory: zod.z.enum(["project-root", "source-root"]).optional(),
   packagePath: nonEmptyStringSchema.optional()
 });
-var serializationConfigSchema = zod.z.strictObject({
+var serializationConfigSchema2 = zod.z.strictObject({
   enumRepresentation: zod.z.enum(["enum", "union", "literal", "forward-compatible-enum", "language-default"]).optional(),
   additionalProperties: zod.z.enum(["allow", "forbid", "ignore", "language-default"]).optional(),
   inlineTypes: zod.z.boolean().optional(),
@@ -618,19 +2333,30 @@ var generationConfigSchema = zod.z.strictObject({
   devContainer: zod.z.boolean().default(false),
   allowMockClient: zod.z.boolean().default(false),
   ignoreFiles: zod.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: zod.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: zod.z.array(nonEmptyStringSchema).optional(),
-  hooks: hooksConfigSchema.optional(),
-  customCode: customCodeConfigSchema.optional(),
-  workflows: zod.z.array(workflowConfigSchema).optional(),
+  hooks: hooksConfigSchema2.optional(),
+  customCode: customCodeConfigSchema2.optional(),
+  workflows: zod.z.array(workflowConfigSchema2).optional(),
   customQueryPaths: zod.z.array(nonEmptyStringSchema).optional(),
-  analytics: analyticsConfigSchema.optional(),
-  wireTests: wireTestsSchema.optional(),
-  unitTests: unitTestsSchema.optional(),
+  analytics: analyticsConfigSchema2.optional(),
+  wireTests: wireTestsSchema2.optional(),
+  unitTests: unitTestsSchema2.optional(),
   webSockets: zod.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 = zod.z.enum([
@@ -643,57 +2369,95 @@ var publishRegistrySchema = zod.z.enum([
   "go",
   "composer"
 ]);
-var commonPublishShape = {
+var credentialResolutionSchema = zod.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: zod.z.boolean().optional()
 };
 var publishConfigSchema = zod.z.discriminatedUnion("registry", [
-  zod.z.strictObject({ registry: zod.z.literal("npm"), ...commonPublishShape }),
-  zod.z.strictObject({ registry: zod.z.literal("pypi"), ...commonPublishShape }),
-  zod.z.strictObject({ registry: zod.z.literal("nuget"), ...commonPublishShape }),
-  zod.z.strictObject({ registry: zod.z.literal("rubygems"), ...commonPublishShape }),
-  zod.z.strictObject({ registry: zod.z.literal("crates"), ...commonPublishShape }),
-  zod.z.strictObject({ registry: zod.z.literal("go"), ...commonPublishShape }),
-  zod.z.strictObject({ registry: zod.z.literal("composer"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("npm"), ...commonPublishShape2 }),
+  zod.z.strictObject({ registry: zod.z.literal("pypi"), ...commonPublishShape2 }),
+  zod.z.strictObject({ registry: zod.z.literal("nuget"), ...commonPublishShape2 }),
+  zod.z.strictObject({ registry: zod.z.literal("rubygems"), ...commonPublishShape2 }),
+  zod.z.strictObject({ registry: zod.z.literal("crates"), ...commonPublishShape2 }),
+  zod.z.strictObject({ registry: zod.z.literal("go"), ...commonPublishShape2 }),
+  zod.z.strictObject({ registry: zod.z.literal("composer"), ...commonPublishShape2 }),
   zod.z.strictObject({
     registry: zod.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 = zod.z.strictObject({
+var reviewersSchema2 = zod.z.strictObject({
   teams: zod.z.array(nonEmptyStringSchema).optional(),
   users: zod.z.array(nonEmptyStringSchema).optional()
 });
-var githubOutputSchema = zod.z.strictObject({
+var replayControlSchema = zod.z.strictObject({
+  enabled: zod.z.boolean()
+});
+var githubOutputSchema2 = zod.z.strictObject({
   repository: nonEmptyStringSchema,
   host: nonEmptyStringSchema.optional(),
   branch: nonEmptyStringSchema.optional(),
   mode: zod.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: zod.z.boolean().optional()
-});
-var filesOutputSchema = zod.z.strictObject({
+  privateRepository: zod.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: zod.z.boolean().default(false),
+  /** Skip creating/updating a GitHub PR when no files changed. Defaults to false. */
+  skipIfNoDiff: zod.z.boolean().default(false),
+  /** Automatically merge the GitHub publishing PR. Defaults to false. */
+  autoMerge: zod.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 = zod.z.strictObject({
   delivery: zod.z.literal("files"),
   path: nonEmptyStringSchema.optional(),
-  publish: publishConfigSchema.optional()
+  publish: publishConfigSchema.optional(),
+  ...credentialResolutionShape
 });
-var zipOutputSchema = zod.z.strictObject({
+var zipOutputSchema2 = zod.z.strictObject({
   delivery: zod.z.literal("zip"),
   fileName: nonEmptyStringSchema.optional(),
-  publish: publishConfigSchema.optional()
+  publish: publishConfigSchema.optional(),
+  ...credentialResolutionShape
 });
-var githubDeliverySchema = zod.z.strictObject({
+var githubDeliverySchema2 = zod.z.strictObject({
   delivery: zod.z.literal("github"),
-  github: githubOutputSchema,
-  publish: publishConfigSchema.optional()
+  github: githubOutputSchema2,
+  publish: publishConfigSchema.optional(),
+  ...credentialResolutionShape
 });
 var outputConfigSchema = zod.z.discriminatedUnion(
   "delivery",
-  [filesOutputSchema, zipOutputSchema, githubDeliverySchema],
+  [filesOutputSchema2, zipOutputSchema2, githubDeliverySchema2],
   {
     error: 'output.delivery must be one of "files", "zip", or "github"'
   }
@@ -709,7 +2473,8 @@ var apiImportSettingsSchema = zod.z.strictObject({
   onlyIncludeReferencedSchemas: zod.z.boolean().optional(),
   objectQueryParameters: zod.z.boolean().optional(),
   typeDatesAsStrings: zod.z.boolean().optional(),
-  groupMultiApiEnvironments: zod.z.boolean().optional()
+  groupMultiApiEnvironments: zod.z.boolean().optional(),
+  defaultIntegerFormat: zod.z.enum(["int32", "int64", "uint32", "uint64"]).optional()
 });
 var sourceSpecTypeSchema = zod.z.enum([
   "openapi",
@@ -766,15 +2531,27 @@ var targetConfigSchema = zod.z.strictObject({
   generatorVersion: exactSemverSchema.optional(),
   sourceOrigin: zod.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"],
@@ -783,7 +2560,7 @@ var publishRegistryLanguages = {
   go: ["go"],
   composer: ["php"]
 };
-var packageNameRegistries = /* @__PURE__ */ new Set([
+var packageNameRegistries2 = /* @__PURE__ */ new Set([
   "npm",
   "pypi",
   "nuget",
@@ -791,8 +2568,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}"`,
@@ -842,6 +2619,21 @@ var sdkConfigIrV1Schema = zod.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({
@@ -851,7 +2643,7 @@ var sdkConfigIrV1Schema = zod.z.strictObject({
       });
     }
   });
-  if (output.publish && !publishRegistryLanguages[output.publish.registry].some(
+  if (output.publish && !publishRegistryLanguages2[output.publish.registry].some(
     (language) => language === target.language
   )) {
     context.addIssue({
@@ -861,7 +2653,7 @@ var sdkConfigIrV1Schema = zod.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";
@@ -878,7 +2670,9 @@ function parseSdkConfigIrV1(value) {
   return sdkConfigIrV1Schema.parse(value);
 }
 
+exports.FernConfigMappingError = FernConfigMappingError;
 exports.SDK_CONFIG_IR_V1_SCHEMA_VERSION = SDK_CONFIG_IR_V1_SCHEMA_VERSION;
+exports.SDK_CONFIG_V1_SCHEMA_VERSION = SDK_CONFIG_V1_SCHEMA_VERSION;
 exports.apiConfigSchema = apiConfigSchema;
 exports.apiImportSettingsSchema = apiImportSettingsSchema;
 exports.authConfigSchema = authConfigSchema;
@@ -900,19 +2694,55 @@ exports.jsonValueSchema = jsonValueSchema;
 exports.kotlinGenerationConfigSchema = kotlinGenerationConfigSchema;
 exports.languageGenerationConfigSchema = languageGenerationConfigSchema;
 exports.legacyInputSchema = legacyInputSchema;
+exports.mapFernConfigToSdkConfigV1 = mapFernConfigToSdkConfigV1;
+exports.mcpAvailabilityStatuses = mcpAvailabilityStatuses;
 exports.mcpGenerationConfigSchema = mcpGenerationConfigSchema;
 exports.nonEmptyStringSchema = nonEmptyStringSchema;
 exports.outputConfigSchema = outputConfigSchema;
 exports.packageConfigSchema = packageConfigSchema;
 exports.parseSdkConfigIrV1 = parseSdkConfigIrV1;
+exports.parseSdkConfigV1 = parseSdkConfigV1;
 exports.phpGenerationConfigSchema = phpGenerationConfigSchema;
 exports.publishConfigSchema = publishConfigSchema;
 exports.publishRegistrySchema = publishRegistrySchema;
 exports.pythonGenerationConfigSchema = pythonGenerationConfigSchema;
+exports.readmeCustomSectionSchema = readmeCustomSectionSchema;
 exports.readmeEndpointSchema = readmeEndpointSchema;
 exports.rubyGenerationConfigSchema = rubyGenerationConfigSchema;
 exports.rustGenerationConfigSchema = rustGenerationConfigSchema;
 exports.sdkConfigIrV1Schema = sdkConfigIrV1Schema;
+exports.sdkConfigV1ApiConfigSchema = sdkConfigV1ApiConfigSchema;
+exports.sdkConfigV1AuthConfigSchema = sdkConfigV1AuthConfigSchema;
+exports.sdkConfigV1AuthSchemeSchema = sdkConfigV1AuthSchemeSchema;
+exports.sdkConfigV1CliGenerationConfigSchema = cliGenerationConfigSchema;
+exports.sdkConfigV1ClientConfigSchema = sdkConfigV1ClientConfigSchema;
+exports.sdkConfigV1ComposerPackageNameSchema = composerPackageNameSchema;
+exports.sdkConfigV1CsharpGenerationConfigSchema = csharpGenerationConfigSchema;
+exports.sdkConfigV1DependencySchema = sdkConfigV1DependencySchema;
+exports.sdkConfigV1DocsConfigSchema = sdkConfigV1DocsConfigSchema;
+exports.sdkConfigV1ExactSemverSchema = exactSemverSchema;
+exports.sdkConfigV1GenerationConfigSchema = sdkConfigV1GenerationConfigSchema;
+exports.sdkConfigV1GoGenerationConfigSchema = goGenerationConfigSchema;
+exports.sdkConfigV1GoModulePathSchema = goModulePathSchema;
+exports.sdkConfigV1JavaGenerationConfigSchema = javaGenerationConfigSchema;
+exports.sdkConfigV1KotlinGenerationConfigSchema = kotlinGenerationConfigSchema;
+exports.sdkConfigV1McpGenerationConfigSchema = mcpGenerationConfigSchema;
+exports.sdkConfigV1NonEmptyStringSchema = nonEmptyStringSchema;
+exports.sdkConfigV1OutputConfigSchema = sdkConfigV1OutputConfigSchema;
+exports.sdkConfigV1PackageConfigSchema = sdkConfigV1PackageConfigSchema;
+exports.sdkConfigV1PhpGenerationConfigSchema = phpGenerationConfigSchema;
+exports.sdkConfigV1PublishConfigSchema = sdkConfigV1PublishConfigSchema;
+exports.sdkConfigV1PublishRegistrySchema = sdkConfigV1PublishRegistrySchema;
+exports.sdkConfigV1PythonGenerationConfigSchema = pythonGenerationConfigSchema;
+exports.sdkConfigV1ReadmeCustomSectionSchema = sdkConfigV1ReadmeCustomSectionSchema;
+exports.sdkConfigV1ReadmeEndpointSchema = sdkConfigV1ReadmeEndpointSchema;
+exports.sdkConfigV1RubyGenerationConfigSchema = rubyGenerationConfigSchema;
+exports.sdkConfigV1RustGenerationConfigSchema = rustGenerationConfigSchema;
+exports.sdkConfigV1Schema = sdkConfigV1Schema;
+exports.sdkConfigV1SwiftGenerationConfigSchema = swiftGenerationConfigSchema;
+exports.sdkConfigV1TargetSchema = sdkConfigV1TargetSchema;
+exports.sdkConfigV1TerraformGenerationConfigSchema = terraformGenerationConfigSchema;
+exports.sdkConfigV1TypescriptGenerationConfigSchema = typescriptGenerationConfigSchema;
 exports.sourceConfigSchema = sourceConfigSchema;
 exports.sourceSpecConfigSchema = sourceSpecConfigSchema;
 exports.sourceSpecTypeSchema = sourceSpecTypeSchema;