@factorialco/fcode-cli 3.5.0 → 3.6.0

package/dist/repositories/settings.js

@@ -1,13 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SETTINGS_FILENAME = void 0;
+exports.INHERITED_SETTINGS_FILENAME = exports.SETTINGS_FILENAME = void 0;
 exports.migrateLegacySettingsFile = migrateLegacySettingsFile;
 const fs = require("fs-extra");
 const path = require("node:path");
 const types_1 = require("../core/types");
 const workspace_1 = require("../config/workspace");
+const errors_1 = require("../core/errors");
 const file_utils_1 = require("../utils/file-utils");
 exports.SETTINGS_FILENAME = 'settings.json';
+exports.INHERITED_SETTINGS_FILENAME = 'settings.inherited.json';
+/** The inheritable settings settings.json manages, by their field name there. */
+const SETTING_FIELDS = {
+    ZONE_ID: 'zoneId',
+    ERROR_HANDLER: 'errorHandlerConfig',
+    WEBHOOK_AUTH: 'webhookAuth',
+    PRIMARY_LOCALE: 'primaryLocale',
+};
 const LEGACY_SETTINGS_FILENAME = 'team.json';
 /**
  * Workspaces cloned before the file was renamed carry team.json. Renaming it on first access keeps
@@ -22,6 +31,14 @@ function migrateLegacySettingsFile(workspaceDir = process.cwd()) {
         fs.renameSync(legacy, current);
     }
 }
+/** A setting settings.json holds a value of or leaves out: its own value, or inherit. */
+function ownOrInherit(value) {
+    return value === undefined ? { mode: 'INHERIT' } : { mode: 'OWN', value };
+}
+/** A setting settings.json leaves out (inherit) or sets to null (none). */
+function noneOrInherit(value) {
+    return value === null ? { mode: 'NONE' } : { mode: 'INHERIT' };
+}
 /**
  * Reads/writes the singleton settings.json (timezone, error handler, inheritance, webhook auth) at
  * the workspace root. Unlike collection resources this is not a ResourceRepositoryBase:
@@ -47,7 +64,7 @@ class SettingsRepository {
             raw = fs.readJsonSync(exports.SETTINGS_FILENAME) || {};
         }
         catch { }
-        const settings = new types_1.WorkspaceSettings(slug, this.parseParentTeams(raw.parentTeams), raw.zoneId, this.parseErrorHandler(raw.errorHandlerConfig), this.parseWebhookAuth(raw.webhookAuth), typeof raw.primaryLocale === 'string' && raw.primaryLocale.length > 0 ? raw.primaryLocale : undefined);
+        const settings = new types_1.WorkspaceSettings(slug, this.parseParentTeams(raw.parentTeams), this.parseString(raw.zoneId), raw.errorHandlerConfig === null ? null : this.parseErrorHandler(raw.errorHandlerConfig), raw.webhookAuth === null ? null : this.parseWebhookAuth(raw.webhookAuth), this.parseString(raw.primaryLocale));
         if (Array.isArray(raw.versions)) {
             settings.versions = this.parseVersions(raw.versions);
         }
@@ -60,16 +77,97 @@ class SettingsRepository {
         migrateLegacySettingsFile();
         (0, file_utils_1.outputFileSyncIfChanged)(exports.SETTINGS_FILENAME, JSON.stringify(this.toFile(settings), null, 2));
     }
-    /** Builds the settings from the cloud's raw payload, resolving the error-handler id to a slug. */
+    /** The settings a local run inherits; empty when the workspace inherits none. */
+    findInherited() {
+        let raw = {};
+        try {
+            raw = fs.readJsonSync(exports.INHERITED_SETTINGS_FILENAME) || {};
+        }
+        catch { }
+        return {
+            zoneId: this.parseString(raw.zoneId),
+            errorHandlerConfig: this.parseErrorHandler(raw.errorHandlerConfig),
+            webhookAuth: this.parseWebhookAuth(raw.webhookAuth),
+            primaryLocale: this.parseString(raw.primaryLocale),
+            inheritedFrom: raw.inheritedFrom ?? {},
+        };
+    }
+    /** Writes settings.inherited.json, or removes it when the workspace inherits no setting. */
+    saveInherited(inherited) {
+        if (!inherited) {
+            if (fs.pathExistsSync(exports.INHERITED_SETTINGS_FILENAME)) {
+                // Written read-only, so it has to be made writable before it can go.
+                fs.chmodSync(exports.INHERITED_SETTINGS_FILENAME, 0o644);
+                fs.removeSync(exports.INHERITED_SETTINGS_FILENAME);
+            }
+            return;
+        }
+        // Read-only like the other inherited files: the values belong to a parent workspace.
+        (0, file_utils_1.outputFileSyncIfChanged)(exports.INHERITED_SETTINGS_FILENAME, JSON.stringify(inherited, null, 2), { readOnly: true });
+    }
+    /**
+     * Builds the settings.json view of the cloud's raw payload: only the team's own values, null for a
+     * cleared setting, and nothing for an inherited or default one. Resolves the error-handler id to a
+     * slug.
+     */
     async fromRaw(raw) {
-        let errorHandlerConfig;
-        if (raw.errorHandlerConfig?.processId) {
-            errorHandlerConfig = {
-                processSlug: await this.resolveIdToSlug(raw.errorHandlerConfig.processId),
-                tag: raw.errorHandlerConfig.tag ?? null,
-            };
+        const origins = this.originsOf(raw);
+        const own = (setting, value) => {
+            const { mode } = origins[setting];
+            if (mode === 'NONE') {
+                return null;
+            }
+            return mode === 'OWN' ? value() : undefined;
+        };
+        return new types_1.WorkspaceSettings(raw.slug, raw.parentTeams ?? [], own('ZONE_ID', () => this.parseString(raw.zoneId)) ?? undefined, await own('ERROR_HANDLER', () => this.resolveErrorHandler(raw)), own('WEBHOOK_AUTH', () => this.parseWebhookAuth(raw.webhookAuth)), own('PRIMARY_LOCALE', () => this.parseString(raw.primaryLocale)) ?? undefined);
+    }
+    /** The settings.inherited.json view of the cloud's raw payload; undefined when nothing is inherited. */
+    async inheritedFromRaw(raw) {
+        const origins = this.originsOf(raw);
+        const inheritedFrom = {};
+        for (const [setting, field] of Object.entries(SETTING_FIELDS)) {
+            const { mode, from } = origins[setting];
+            if (mode === 'INHERIT' && from) {
+                inheritedFrom[field] = from;
+            }
+        }
+        if (Object.keys(inheritedFrom).length === 0) {
+            return undefined;
         }
-        return new types_1.WorkspaceSettings(raw.slug, raw.parentTeams ?? [], raw.zoneId, errorHandlerConfig, this.parseWebhookAuth(raw.webhookAuth), raw.primaryLocale ?? undefined);
+        // JSON.stringify drops the settings left undefined, so the file lists only inherited ones.
+        return {
+            zoneId: inheritedFrom.zoneId ? this.parseString(raw.zoneId) : undefined,
+            errorHandlerConfig: inheritedFrom.errorHandlerConfig ? await this.resolveErrorHandler(raw) : undefined,
+            webhookAuth: inheritedFrom.webhookAuth ? this.parseWebhookAuth(raw.webhookAuth) : undefined,
+            primaryLocale: inheritedFrom.primaryLocale ? this.parseString(raw.primaryLocale) : undefined,
+            inheritedFrom,
+        };
+    }
+    /**
+     * settings.json is the source of truth for the team's own values: a setting absent from it is
+     * reset to inherit, null leaves the team with none (a parent's included), and a value sets it.
+     */
+    async toTeamUpdate(settings) {
+        const { errorHandlerConfig, webhookAuth } = settings;
+        return {
+            parentTeams: settings.parentTeams,
+            inheritableSettings: {
+                zoneId: ownOrInherit(settings.zoneId),
+                errorHandlerConfig: errorHandlerConfig === undefined || errorHandlerConfig === null
+                    ? noneOrInherit(errorHandlerConfig)
+                    : {
+                        mode: 'OWN',
+                        value: {
+                            processId: await this.resolveSlugToId(errorHandlerConfig.processSlug),
+                            tag: errorHandlerConfig.tag ?? null,
+                        },
+                    },
+                webhookAuth: webhookAuth === undefined || webhookAuth === null
+                    ? noneOrInherit(webhookAuth)
+                    : { mode: 'OWN', value: { headerName: webhookAuth.headerName ?? null, variableKey: webhookAuth.variableKey } },
+                primaryLocale: ownOrInherit(settings.primaryLocale),
+            },
+        };
     }
     /**
      * Writes the cloud's workspace versions and aliases into the settings as the settings.json
@@ -99,6 +197,25 @@ class SettingsRepository {
         const match = Object.values(processes).find((process) => process.id === processId);
         return match?.slug ?? processId;
     }
+    /** Where each setting comes from; an API without it predates settings inheritance. */
+    originsOf(raw) {
+        if (!raw.origins) {
+            throw new errors_1.PlatformPredatesSettingsInheritance();
+        }
+        return raw.origins;
+    }
+    async resolveErrorHandler(raw) {
+        if (!raw.errorHandlerConfig?.processId) {
+            return undefined;
+        }
+        return {
+            processSlug: await this.resolveIdToSlug(raw.errorHandlerConfig.processId),
+            tag: raw.errorHandlerConfig.tag ?? null,
+        };
+    }
+    parseString(raw) {
+        return typeof raw === 'string' && raw.length > 0 ? raw : undefined;
+    }
     parseErrorHandler(raw) {
         if (!raw || !raw.processSlug) {
             return undefined;
@@ -194,7 +311,8 @@ class SettingsRepository {
         if (settings.errorHandlerConfig !== undefined) {
             file.errorHandlerConfig = settings.errorHandlerConfig;
         }
-        // Last, so adding webhook auth to an existing settings.json is a purely additive diff.
+        // Last, so adding webhook auth to an existing settings.json is a purely additive diff. null
+        // (cleared) is written as is: absent means inherit.
         if (settings.webhookAuth !== undefined) {
             file.webhookAuth = settings.webhookAuth;
         }

package/dist/runtime/libs/python/fcode/context.py

@@ -96,6 +96,7 @@ class I18n:
         payload = i18n_payload or {}
         self.__translations = payload.get("translations") or {}
         self.__by_locale = payload.get("byLocale") or {}
+        self.__primary_locale = payload.get("primaryLocale")
         self.locale = payload.get("locale")
 
     def __call__(self, key, args=None, options=None):
@@ -125,24 +126,43 @@ class I18n:
         """The maps a requested locale opens, most specific first.
 
         An identifier no locale matches is shortened one segment at a time ("en-gb" reads "en"),
-        by name first and ignoring case only as a last resort -- the same chain the cloud
-        executors resolve, so a local run answers a regional variant the same way.
+        by name first and ignoring case only as a last resort, and a language that still matches
+        nothing is broadened to a regional locale of it ("es" reads "es-ES", the primary one if it
+        is among them, else the alphabetically first) -- the same chain the cloud executors
+        resolve, so a local run answers the same identifiers the same way.
         """
         if locale is None or not self.__by_locale:
             return []
+        import re
+
         names = list(self.__by_locale.keys())
         chain = []
-        candidate = locale
-        while candidate:
+
+        def matching(candidate):
             if candidate in names:
-                match = candidate
-            else:
-                folded = sorted(n for n in names if n.lower() == candidate.lower())
-                match = folded[0] if folded else None
+                return candidate
+            folded = sorted(n for n in names if n.lower() == candidate.lower())
+            return folded[0] if folded else None
+
+        def add(match):
             if match is not None and match not in chain:
                 chain.append(match)
+
+        candidate = locale
+        language = None
+        while candidate:
+            add(matching(candidate))
+            language = candidate
             last_separator = max(candidate.rfind("-"), candidate.rfind("_"))
             candidate = candidate[:last_separator] if last_separator > 0 else None
+        if language and not re.search(r"[-_]", language) and matching(language) is None:
+            same_language = sorted(
+                n for n in names if re.split(r"[-_]", n)[0].lower() == language.lower()
+            )
+            if self.__primary_locale in same_language:
+                add(self.__primary_locale)
+            elif same_language:
+                add(same_language[0])
         return [self.__by_locale[name] for name in chain if self.__by_locale[name]]
 
 

package/dist/services/fcode-graphql-client.d.ts

@@ -88,9 +88,9 @@ declare class FcodeGraphQLClient {
     private mapFactorialSettings;
     mapProcess({ id, slug, name, description, tags, script, readme, manifest, settings, triggers, resolvingTeamSlug, lifecycleRole, deletedAt, retainingVersionTags, }: any): Process;
     /**
-     * GraphQL nests the webhook configuration under `settings`, while settings.json and the REST API
-     * keep it flat. Mapping it explicitly is what keeps that mismatch from silently reading as
-     * undefined.
+     * The team's inheritable settings, each read from its `{ mode, value, from }`: the value in effect
+     * and where it comes from. An API that predates settings inheritance has no such field, and leaves
+     * `origins` undefined so the settings commands refuse instead of reading every setting as inherited.
      */
     mapTeamSettings(team: any): RawTeamSettings;
     mapTeamVersion(teamVersion: any): TeamVersion;
@@ -105,6 +105,11 @@ declare class FcodeGraphQLClient {
     verifyTeamAccess(): Promise<void>;
     team(): Promise<RawTeamSettings>;
     pushTeam(update: TeamUpdateInput): Promise<RawTeamSettings>;
+    /**
+     * An API that predates settings inheritance rejects the query naming `inheritableSettings` as a
+     * schema error; that reads better as what it means than as GraphQL validation output.
+     */
+    cleanTeamSettingsError(error: any): any;
     mapProgrammingLanguageManifest(programmingLanguageManifest: any): ProgrammingLanguageManifest;
     private mapDependencies;
     /**

package/dist/services/fcode-graphql-client.js

@@ -3,7 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const graphql_request_1 = require("graphql-request");
 const types_1 = require("../core/types");
 const locale_merger_1 = require("./locale-merger");
+const cli_version_1 = require("../utils/cli-version");
+const errors_1 = require("../core/errors");
 const _ = require("lodash");
+// Source code travels base64 encoded: Cloudflare's WAF blocks requests whose body
+// looks like an attack payload, which source code often does. sourceCodeEncoding tells the
+// API to decode it back.
+const SOURCE_CODE_ENCODING = 'BASE64';
+const encodeSourceCode = (sourceCode) => sourceCode == null ? sourceCode : Buffer.from(sourceCode, 'utf8').toString('base64');
 // Manifest fields an fcode-api older than this CLI may not know. The manifest query falls back to a
 // narrower selection when the error names one of them, so a CLI stays usable against an
 // on-premises api that has not been updated yet.
@@ -132,6 +139,17 @@ const PROCESS_FIELDS = `
     }
   }
 `;
+// Each inheritable setting of a team: its mode, the value in effect and the parent it comes from.
+const INHERITABLE_SETTINGS_SELECTION = `
+  inheritableSettings {
+    zoneId { mode value from }
+    paramsSchemaValidationEnabled { mode value from }
+    errorHandlerConfig { mode value { processId tag } from }
+    webhookAuth { mode value { headerName variableKey } from }
+    primaryLocale { mode value from }
+  }
+`;
+const UNKNOWN_FIELD_ERROR = /FieldUndefined|WrongType|is undefined|not present|not in type/;
 const NETWORK_ERROR_CODES = ['ECONNREFUSED', 'ENOTFOUND', 'ECONNRESET', 'ETIMEDOUT', 'EAI_AGAIN'];
 class FcodeGraphQLClient {
     constructor(options) {
@@ -147,6 +165,7 @@ class FcodeGraphQLClient {
             headers: {
                 'Fcode-Team': options.teamSlug,
                 authorization: `Bearer ${options.accessToken}`,
+                [cli_version_1.CLI_VERSION_HEADER]: (0, cli_version_1.cliVersion)(),
             },
         });
     }
@@ -261,8 +280,19 @@ class FcodeGraphQLClient {
     createVersionedProcesses(versionedProcess) {
         return this.client
             .request((0, graphql_request_1.gql) `
-          mutation publishProcess($processId: ID!, $tag: String!, $sourceCode: String, $parametersSchema: JSON, $readme: String) {
-            publishProcess(processId: $processId, tag: $tag, input: { sourceCode: $sourceCode, parametersSchema: $parametersSchema, readme: $readme }) {
+          mutation publishProcess(
+            $processId: ID!
+            $tag: String!
+            $sourceCode: String
+            $sourceCodeEncoding: SourceCodeEncoding
+            $parametersSchema: JSON
+            $readme: String
+          ) {
+            publishProcess(
+              processId: $processId
+              tag: $tag
+              input: { sourceCode: $sourceCode, sourceCodeEncoding: $sourceCodeEncoding, parametersSchema: $parametersSchema, readme: $readme }
+            ) {
               id
             }
           }
@@ -271,7 +301,8 @@ class FcodeGraphQLClient {
             tag: versionedProcess.tag,
             parametersSchema: versionedProcess.script.parametersSchema,
             readme: versionedProcess.readme,
-            sourceCode: versionedProcess.script.sourceCode,
+            sourceCode: encodeSourceCode(versionedProcess.script.sourceCode),
+            sourceCodeEncoding: SOURCE_CODE_ENCODING,
         })
             .catch((error) => {
             return Promise.reject(this.cleanError(error));
@@ -330,15 +361,20 @@ class FcodeGraphQLClient {
     createVersionedScriptLibrary(versionedScriptLibrary) {
         return this.client
             .request((0, graphql_request_1.gql) `
-          mutation publishScriptLibrary($scriptLibraryId: ID!, $tag: String!, $sourceCode: String) {
-            publishScriptLibrary(scriptLibraryId: $scriptLibraryId, tag: $tag, input: { sourceCode: $sourceCode }) {
+          mutation publishScriptLibrary($scriptLibraryId: ID!, $tag: String!, $sourceCode: String, $sourceCodeEncoding: SourceCodeEncoding) {
+            publishScriptLibrary(
+              scriptLibraryId: $scriptLibraryId
+              tag: $tag
+              input: { sourceCode: $sourceCode, sourceCodeEncoding: $sourceCodeEncoding }
+            ) {
               id
             }
           }
         `, {
             scriptLibraryId: versionedScriptLibrary.id,
             tag: versionedScriptLibrary.tag,
-            sourceCode: versionedScriptLibrary.sourceCode,
+            sourceCode: encodeSourceCode(versionedScriptLibrary.sourceCode),
+            sourceCodeEncoding: SOURCE_CODE_ENCODING,
         })
             .catch((error) => {
             return Promise.reject(this.cleanError(error));
@@ -553,7 +589,8 @@ class FcodeGraphQLClient {
             parametersSchema: process.script.parametersSchema,
             readme: process.readme,
             tags: process.tags,
-            sourceCode: process.script.sourceCode,
+            sourceCode: encodeSourceCode(process.script.sourceCode),
+            sourceCodeEncoding: SOURCE_CODE_ENCODING,
             manifest: process.settings.dependencies.scopedToProcess ? process.manifest : null,
             settings,
         };
@@ -640,8 +677,8 @@ class FcodeGraphQLClient {
         if (scriptLibrary.id) {
             return this.client
                 .request((0, graphql_request_1.gql) `
-            mutation updateScriptLibrary($id: ID!, $sourceCode: String) {
-              updateScriptLibrary(id: $id, input: { sourceCode: $sourceCode }) {
+            mutation updateScriptLibrary($id: ID!, $sourceCode: String, $sourceCodeEncoding: SourceCodeEncoding) {
+              updateScriptLibrary(id: $id, input: { sourceCode: $sourceCode, sourceCodeEncoding: $sourceCodeEncoding }) {
                 id
                 name
                 programmingLanguage
@@ -650,7 +687,8 @@ class FcodeGraphQLClient {
             }
           `, {
                 id: scriptLibrary.id,
-                sourceCode: scriptLibrary.sourceCode,
+                sourceCode: encodeSourceCode(scriptLibrary.sourceCode),
+                sourceCodeEncoding: SOURCE_CODE_ENCODING,
             })
                 .then(({ updateScriptLibrary: scriptLibrary }) => new types_1.ScriptLibrary(scriptLibrary.id, scriptLibrary.name, scriptLibrary.sourceCode, scriptLibrary.programmingLanguage))
                 .catch((error) => {
@@ -659,8 +697,18 @@ class FcodeGraphQLClient {
         }
         return this.client
             .request((0, graphql_request_1.gql) `
-          mutation createScriptLibrary($name: String!, $sourceCode: String, $programmingLanguage: ProgrammingLanguage) {
-            createScriptLibrary(name: $name, programmingLanguage: $programmingLanguage, sourceCode: $sourceCode) {
+          mutation createScriptLibrary(
+            $name: String!
+            $sourceCode: String
+            $sourceCodeEncoding: SourceCodeEncoding
+            $programmingLanguage: ProgrammingLanguage
+          ) {
+            createScriptLibrary(
+              name: $name
+              programmingLanguage: $programmingLanguage
+              sourceCode: $sourceCode
+              sourceCodeEncoding: $sourceCodeEncoding
+            ) {
               id
               name
               sourceCode
@@ -669,7 +717,8 @@ class FcodeGraphQLClient {
           }
         `, {
             name: scriptLibrary.name,
-            sourceCode: scriptLibrary.sourceCode,
+            sourceCode: encodeSourceCode(scriptLibrary.sourceCode),
+            sourceCodeEncoding: SOURCE_CODE_ENCODING,
             programmingLanguage: scriptLibrary.programmingLanguage,
         })
             .then(({ createScriptLibrary: scriptLibrary }) => new types_1.ScriptLibrary(scriptLibrary.id, scriptLibrary.name, scriptLibrary.sourceCode, scriptLibrary.programmingLanguage))
@@ -1004,27 +1053,37 @@ class FcodeGraphQLClient {
         return process;
     }
     /**
-     * GraphQL nests the webhook configuration under `settings`, while settings.json and the REST API
-     * keep it flat. Mapping it explicitly is what keeps that mismatch from silently reading as
-     * undefined.
+     * The team's inheritable settings, each read from its `{ mode, value, from }`: the value in effect
+     * and where it comes from. An API that predates settings inheritance has no such field, and leaves
+     * `origins` undefined so the settings commands refuse instead of reading every setting as inherited.
      */
     mapTeamSettings(team) {
         const settings = {
             slug: team.slug,
-            zoneId: team.zoneId,
-            errorHandlerConfig: team.errorHandlerConfig,
             parentTeams: team.parentTeams ?? [],
         };
-        const webhookAuth = team.settings?.webhookAuth;
+        const inheritable = team.inheritableSettings;
+        if (!inheritable) {
+            return settings;
+        }
+        settings.zoneId = inheritable.zoneId?.value ?? undefined;
+        settings.errorHandlerConfig = inheritable.errorHandlerConfig?.value ?? null;
+        settings.primaryLocale = inheritable.primaryLocale?.value ?? null;
+        const webhookAuth = inheritable.webhookAuth?.value;
         if (webhookAuth?.variableKey) {
             settings.webhookAuth = { variableKey: webhookAuth.variableKey };
             if (webhookAuth.headerName && webhookAuth.headerName !== types_1.DEFAULT_WEBHOOK_AUTH_HEADER) {
                 settings.webhookAuth.headerName = webhookAuth.headerName;
             }
         }
-        if (team.settings?.primaryLocale) {
-            settings.primaryLocale = team.settings.primaryLocale;
-        }
+        const origin = (setting) => ({ mode: setting?.mode ?? 'INHERIT', from: setting?.from ?? null });
+        settings.origins = {
+            ZONE_ID: origin(inheritable.zoneId),
+            PARAMS_SCHEMA_VALIDATION: origin(inheritable.paramsSchemaValidationEnabled),
+            ERROR_HANDLER: origin(inheritable.errorHandlerConfig),
+            WEBHOOK_AUTH: origin(inheritable.webhookAuth),
+            PRIMARY_LOCALE: origin(inheritable.primaryLocale),
+        };
         return settings;
     }
     mapTeamVersion(teamVersion) {
@@ -1160,28 +1219,17 @@ class FcodeGraphQLClient {
           query team($slug: ID!) {
             team(slug: $slug) {
               slug
-              zoneId
-              errorHandlerConfig {
-                processId
-                tag
-              }
               parentTeams {
                 slug
                 version
               }
-              settings {
-                webhookAuth {
-                  headerName
-                  variableKey
-                }
-                primaryLocale
-              }
+              ${INHERITABLE_SETTINGS_SELECTION}
             }
           }
         `, { slug: this.teamSlug })
             .then(({ team }) => this.mapTeamSettings(team))
             .catch((error) => {
-            return Promise.reject(this.cleanError(error));
+            return Promise.reject(this.cleanTeamSettingsError(error));
         });
     }
     pushTeam(update) {
@@ -1190,30 +1238,32 @@ class FcodeGraphQLClient {
           mutation updateTeam($slug: String!, $update: TeamUpdateInput!) {
             updateTeam(slug: $slug, update: $update) {
               slug
-              zoneId
-              errorHandlerConfig {
-                processId
-                tag
-              }
               parentTeams {
                 slug
                 version
               }
-              settings {
-                webhookAuth {
-                  headerName
-                  variableKey
-                }
-                primaryLocale
-              }
+              ${INHERITABLE_SETTINGS_SELECTION}
             }
           }
         `, { slug: this.teamSlug, update })
             .then(({ updateTeam: team }) => this.mapTeamSettings(team))
             .catch((error) => {
-            return Promise.reject(this.cleanError(error));
+            return Promise.reject(this.cleanTeamSettingsError(error));
         });
     }
+    /**
+     * An API that predates settings inheritance rejects the query naming `inheritableSettings` as a
+     * schema error; that reads better as what it means than as GraphQL validation output.
+     */
+    cleanTeamSettingsError(error) {
+        const message = error?.response?.errors?.[0]?.message ?? '';
+        // Only the schema errors an older API answers with (an unknown output field, an unknown input
+        // field): the API's own validation errors also name inheritableSettings, and mean something else.
+        if (message.includes('inheritableSettings') && UNKNOWN_FIELD_ERROR.test(message)) {
+            return new errors_1.PlatformPredatesSettingsInheritance();
+        }
+        return this.cleanError(error);
+    }
     mapProgrammingLanguageManifest(programmingLanguageManifest) {
         const allDependencies = programmingLanguageManifest.nextInstallation?.dependencies || programmingLanguageManifest.dependencies;
         return new types_1.ProgrammingLanguageManifest(programmingLanguageManifest.id, programmingLanguageManifest.programmingLanguage, programmingLanguageManifest.programmingLanguage, this.mapDependencies(allDependencies), 

package/dist/services/locale-resolver.d.ts

@@ -16,7 +16,9 @@ export declare function flattenTranslations(document: unknown, prefix?: string,
  * publishes plain languages, so the request degrades one segment at a time — split on `-` or `_`,
  * without parsing a language tag, since any short slug is a legal identifier here — and every step
  * that matches stays in the chain: a variant file translates the keys that differ and leaves the
- * rest to the language it came from.
+ * rest to the language it came from. The opposite happens too — the host sends `es` while the
+ * workspace has `es-ES` — so a language layer that matches nothing, by name or ignoring case, is
+ * broadened to a regional file of that language, in the place the language would have taken.
  */
 export declare function localeFallbackChain(requested: string | undefined, primary: string | undefined, available: Array<string>): Array<string>;
 /**
@@ -25,10 +27,12 @@ export declare function localeFallbackChain(requested: string | undefined, prima
  * shorter form of the requested one the workspace publishes — layered underneath, plus each
  * locale's own map (inherited file layered under its own, but NOT merged over the primary) so a
  * call naming a locale (`fcode.i18n(key, args, { locale })`) resolves like the cloud's `by_locale`:
- * key by key in the requested locale first, falling back to the merged translations
+ * key by key in the requested locale first, falling back to the merged translations — and the
+ * primary locale, which a call naming a bare language prefers when it broadens to a regional file
  */
 export declare function resolveLocalTranslations(requestedLocale?: string, workspaceDir?: string): {
     locale?: string;
+    primaryLocale?: string;
     translations: Record<string, string>;
     byLocale: Record<string, Record<string, string>>;
 };