@remogram/core 0.1.0-beta.3 → 0.1.0-beta.5

package/merge-blockers.js

@@ -1,3 +1,5 @@
+import { allPathsAllowed } from './path-allowlist.js';
+
 /**
  * Derive merge blockers from already-fetched PR view and checks facts.
  * Shared by merge plan and cr inventory aggregation.
@@ -6,7 +8,12 @@ export function isOpenPrState(state) {
   return String(state ?? '').toLowerCase() === 'open';
 }
 
-export function mergeBlockersFromFacts(view, checks) {
+/**
+ * @param {object} view
+ * @param {object} checks
+ * @param {{ allowed_paths?: string[], changed_paths?: string[] | null }} [pathScope]
+ */
+export function mergeBlockersFromFacts(view, checks, pathScope = {}) {
   const blockers = [];
   if (view.mergeability === 'conflicted') blockers.push('merge_conflict');
   if (!isOpenPrState(view.state)) blockers.push('pr_not_open');
@@ -14,5 +21,16 @@ export function mergeBlockersFromFacts(view, checks) {
   if (checks.check_conclusion === 'failure') blockers.push('checks_failed');
   if (checks.check_conclusion === 'missing') blockers.push('checks_missing');
   if (checks.check_conclusion === 'pending') blockers.push('checks_pending');
+
+  const allowedPaths = pathScope.allowed_paths;
+  if (Array.isArray(allowedPaths) && allowedPaths.length > 0) {
+    const changedPaths = pathScope.changed_paths;
+    if (changedPaths == null) {
+      blockers.push('changed_paths_unavailable');
+    } else if (!allPathsAllowed(allowedPaths, changedPaths)) {
+      blockers.push('path_scope_violation');
+    }
+  }
+
   return blockers;
 }

package/merge-plan.js

@@ -0,0 +1,37 @@
+import { gitDiffNameOnly } from './git-local.js';
+import { mergeBlockersFromFacts } from './merge-blockers.js';
+
+function normalizeAllowedPaths(allowedPaths) {
+  if (!Array.isArray(allowedPaths)) return null;
+  const normalized = allowedPaths.filter((entry) => typeof entry === 'string' && entry.length > 0);
+  return normalized.length > 0 ? normalized : null;
+}
+
+export function resolveMergePlanPathScope(ctx, view, opts = {}) {
+  const allowedPaths = normalizeAllowedPaths(opts.allowed_paths);
+  if (!allowedPaths) {
+    return { allowed_paths: null, changed_paths: null };
+  }
+  if (Array.isArray(opts.changed_paths)) {
+    return { allowed_paths: allowedPaths, changed_paths: opts.changed_paths };
+  }
+  if (!view.base_sha || !view.head_sha) {
+    return { allowed_paths: allowedPaths, changed_paths: null };
+  }
+  const changedPaths = gitDiffNameOnly(ctx.cwd, view.base_sha, view.head_sha);
+  return { allowed_paths: allowedPaths, changed_paths: changedPaths };
+}
+
+export function buildMergePlanBody(view, checks, pathScope = {}) {
+  return {
+    pr_number: view.pr_number,
+    mergeability: view.mergeability,
+    checks_conclusion: checks.check_conclusion,
+    blockers: mergeBlockersFromFacts(view, checks, pathScope),
+  };
+}
+
+export function buildMergePlanBodyFromFacts(ctx, view, checks, opts = {}) {
+  const pathScope = resolveMergePlanPathScope(ctx, view, opts);
+  return buildMergePlanBody(view, checks, pathScope);
+}

package/open-pull-list.js

@@ -0,0 +1,256 @@
+import { ERROR_CODES, forgeError } from './contracts/errors.js';
+
+/** Normalized slice sort keys exposed on CLI/MCP and success packets. */
+export const CR_INVENTORY_SLICE_SORTS = Object.freeze([
+  'number_asc',
+  'number_desc',
+  'recent_update',
+  'recent_created',
+]);
+
+export const DEFAULT_CR_INVENTORY_SLICE_SORT = 'number_asc';
+
+/**
+ * @param {unknown} value
+ * @returns {typeof CR_INVENTORY_SLICE_SORTS[number]}
+ */
+export function normalizeCrInventorySort(value) {
+  if (value == null || value === '') return DEFAULT_CR_INVENTORY_SLICE_SORT;
+  const sort = String(value).trim().toLowerCase();
+  if (!CR_INVENTORY_SLICE_SORTS.includes(sort)) {
+    throw Object.assign(new Error('Invalid cr inventory sort'), {
+      forgeError: forgeError(
+        ERROR_CODES.INVALID_ARGS,
+        `--sort must be one of: ${CR_INVENTORY_SLICE_SORTS.join(', ')}`,
+      ),
+    });
+  }
+  return sort;
+}
+
+/**
+ * Parse forge total-count response header as a positive integer within sanity bounds.
+ * @param {Headers | Record<string, string> | null | undefined} headers
+ * @param {string} headerName
+ * @param {{ maxTrusted: number }} opts
+ * @returns {number | null}
+ */
+export function parseTotalCountHeader(headers, headerName, { maxTrusted }) {
+  if (headers == null || maxTrusted <= 0) return null;
+  const read =
+    typeof headers.get === 'function'
+      ? (name) => headers.get(name)
+      : (name) => headers[name] ?? headers[String(name).toLowerCase()];
+  const raw = read(headerName) ?? read(String(headerName).toLowerCase());
+  if (raw == null || raw === '') return null;
+  const n = Number.parseInt(String(raw).trim(), 10);
+  if (!Number.isFinite(n) || n <= 0 || n > maxTrusted) return null;
+  return n;
+}
+
+/**
+ * Fast path applies to cr inventory retain_max slices, not idempotency scans.
+ * @param {{ retain_max?: number | null, limit?: number | null }} opts
+ */
+export function isCrInventoryFastPathEligible(opts = {}) {
+  return (
+    opts.retain_max != null &&
+    Number.isInteger(Number(opts.retain_max)) &&
+    Number(opts.retain_max) > 0
+  );
+}
+
+/**
+ * When forge order is authoritative, skip client-side number reordering.
+ * @param {string} sliceSort
+ */
+export function forgeOrderAuthoritative(sliceSort) {
+  return sliceSort === 'recent_update' || sliceSort === 'recent_created';
+}
+
+/**
+ * Fast path requires the first page to contain the expected item count.
+ * @param {number} totalCount
+ * @param {number} requestLimit
+ * @param {number} bodyLength
+ */
+export function validateFastPathPageLength(totalCount, requestLimit, bodyLength) {
+  const expected = Math.min(totalCount, requestLimit);
+  return bodyLength === expected;
+}
+
+/**
+ * Number sorts need full local reorder; skip fast path when total exceeds retain_max.
+ * @param {number} totalCount
+ * @param {number} retainMax
+ * @param {string} sliceSort
+ */
+export function isNumberSortFastPathEligible(totalCount, retainMax, sliceSort) {
+  if (sliceSort !== 'number_asc' && sliceSort !== 'number_desc') return true;
+  return totalCount <= retainMax;
+}
+
+/**
+ * Prefer forge header/search total over summed pagination lengths on fallback.
+ * @param {number | null | undefined} trustedTotal
+ * @param {number} summedCount
+ */
+export function resolvePaginatedEntryCount(trustedTotal, summedCount) {
+  if (trustedTotal != null && Number.isInteger(trustedTotal) && trustedTotal > 0) {
+    return trustedTotal;
+  }
+  return summedCount;
+}
+
+/**
+ * When forge total is trusted but pagination walked fewer items, mark truncated.
+ * @param {{ listTruncated: boolean, trustedTotalCount?: number | null, walkedCount: number, fullCollect?: boolean }} opts
+ */
+export function resolveListTruncatedWithTrustedTotal({
+  listTruncated,
+  trustedTotalCount,
+  walkedCount,
+  fullCollect = false,
+}) {
+  if (
+    trustedTotalCount != null &&
+    Number.isInteger(trustedTotalCount) &&
+    trustedTotalCount > 0 &&
+    walkedCount < trustedTotalCount
+  ) {
+    return true;
+  }
+  return listTruncated;
+}
+
+/**
+ * Gitea recent_created uses oldest sort; fast path only when total fits retain_max.
+ * @param {number} totalCount
+ * @param {number} retainMax
+ * @param {string} sliceSort
+ * @param {string} providerId
+ */
+export function isRecentCreatedFastPathEligible(totalCount, retainMax, sliceSort, providerId) {
+  if (sliceSort !== 'recent_created' || providerId !== 'gitea-api') return true;
+  return totalCount <= retainMax;
+}
+
+/**
+ * Last page index for Gitea sort=oldest when fetching globally newest-created slice.
+ * @param {number} totalCount
+ * @param {number} pageSize
+ */
+export function giteaRecentCreatedTailPage(totalCount, pageSize) {
+  if (!Number.isInteger(totalCount) || totalCount <= 0) return 1;
+  if (!Number.isInteger(pageSize) || pageSize <= 0) return 1;
+  return Math.max(1, Math.ceil(totalCount / pageSize));
+}
+
+/**
+ * Number sorts need full local reorder when total exceeds retain_max.
+ * @param {number} totalCount
+ * @param {number} retainMax
+ * @param {string} sliceSort
+ */
+export function isNumberSortFullCollectRequired(totalCount, retainMax, sliceSort) {
+  if (forgeOrderAuthoritative(sliceSort)) return false;
+  return !isNumberSortFastPathEligible(totalCount, retainMax, sliceSort);
+}
+
+/**
+ * Gitea sort=oldest returns oldest-first; recent_created needs newest-first.
+ * @param {unknown[]} items
+ * @param {string} sliceSort
+ */
+export function prepareGiteaOpenPullPageItems(items, sliceSort) {
+  if (sliceSort !== 'recent_created' || !Array.isArray(items)) return items;
+  return items.slice().reverse();
+}
+
+/**
+ * @param {unknown[]} items
+ * @param {(item: unknown) => number | null | undefined} getNumber
+ * @param {string} sliceSort
+ * @returns {number[]}
+ */
+export function orderOpenPullNumbers(items, getNumber, sliceSort) {
+  const numbers = items
+    .map(getNumber)
+    .filter((number) => Number.isInteger(number));
+  if (forgeOrderAuthoritative(sliceSort)) return numbers;
+  numbers.sort((a, b) => (sliceSort === 'number_desc' ? b - a : a - b));
+  return numbers;
+}
+
+/**
+ * @param {{ totalCount?: number | null, numbers: number[], listTruncated: boolean, sliceSort?: string }} meta
+ */
+export function buildOpenPullListMeta({ totalCount, numbers, listTruncated, sliceSort }) {
+  return {
+    numbers,
+    list_truncated: listTruncated,
+    ...(totalCount != null ? { entry_count: totalCount } : {}),
+    ...(sliceSort ? { slice_sort: sliceSort } : {}),
+  };
+}
+
+/**
+ * Gitea query params for normalized slice sort.
+ * @param {string} sliceSort
+ */
+export function giteaOpenPullSortQuery(sliceSort) {
+  switch (sliceSort) {
+    case 'recent_update':
+      return { sort: 'recentupdate' };
+    case 'recent_created':
+      return { sort: 'oldest' };
+    default:
+      return {};
+  }
+}
+
+/**
+ * GitLab query params for normalized slice sort.
+ * @param {string} sliceSort
+ */
+export function gitlabOpenPullSortQuery(sliceSort) {
+  switch (sliceSort) {
+    case 'recent_update':
+      return { order_by: 'updated_at', sort: 'desc' };
+    case 'recent_created':
+      return { order_by: 'created_at', sort: 'desc' };
+    case 'number_desc':
+      return { order_by: 'created_at', sort: 'desc' };
+    default:
+      return { order_by: 'created_at', sort: 'asc' };
+  }
+}
+
+/**
+ * GitHub query params for normalized slice sort on list pulls.
+ * @param {string} sliceSort
+ */
+export function githubOpenPullSortQuery(sliceSort) {
+  switch (sliceSort) {
+    case 'recent_update':
+      return { sort: 'updated', direction: 'desc' };
+    case 'recent_created':
+      return { sort: 'created', direction: 'desc' };
+    case 'number_desc':
+      return { sort: 'created', direction: 'desc' };
+    default:
+      return { sort: 'created', direction: 'asc' };
+  }
+}
+
+/**
+ * Append URLSearchParams for forge sort query entries.
+ * @param {string} path
+ * @param {Record<string, string>} query
+ */
+export function appendSortQuery(path, query) {
+  if (!query || Object.keys(query).length === 0) return path;
+  const sep = path.includes('?') ? '&' : '?';
+  const params = new URLSearchParams(query);
+  return `${path}${sep}${params.toString()}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remogram/core",
-  "version": "0.1.0-beta.3",
+  "version": "0.1.0-beta.5",
   "description": "Remogram forge envelope, config, caps, and HTTP utilities",
   "type": "module",
   "license": "MIT",

package/path-allowlist.js

@@ -0,0 +1,63 @@
+/**
+ * Glob allowlist matching for autonomous Observer auto-merge scope checks.
+ * Supports `**`, `*`, and literal path segments (e.g. README.md).
+ */
+
+function globToRegExp(glob) {
+  let pattern = '';
+  for (let i = 0; i < glob.length; i += 1) {
+    const ch = glob[i];
+    if (ch === '*' && glob[i + 1] === '*') {
+      pattern += '.*';
+      i += 1;
+      if (glob[i + 1] === '/') i += 1;
+    } else if (ch === '*') {
+      pattern += '[^/]*';
+    } else if (/[+?^${}()|[\]\\]/.test(ch)) {
+      pattern += `\\${ch}`;
+    } else {
+      pattern += ch;
+    }
+  }
+  return new RegExp(`^${pattern}$`);
+}
+
+/**
+ * @param {string} glob
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+export function matchPathAllowlist(glob, filePath) {
+  if (typeof glob !== 'string' || typeof filePath !== 'string') return false;
+  const normalized = filePath.replace(/\\/g, '/').replace(/^\.\//, '');
+  return globToRegExp(glob).test(normalized);
+}
+
+/**
+ * @param {string[]} allowedPaths
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+export function isPathAllowed(allowedPaths, filePath) {
+  if (!Array.isArray(allowedPaths) || allowedPaths.length === 0) return false;
+  return allowedPaths.some((glob) => matchPathAllowlist(glob, filePath));
+}
+
+/**
+ * @param {string[]} allowedPaths
+ * @param {string[]} changedPaths
+ * @returns {string[]}
+ */
+export function pathsOutsideAllowlist(allowedPaths, changedPaths) {
+  if (!Array.isArray(changedPaths)) return [];
+  return changedPaths.filter((filePath) => !isPathAllowed(allowedPaths, filePath));
+}
+
+/**
+ * @param {string[]} allowedPaths
+ * @param {string[]} changedPaths
+ * @returns {boolean}
+ */
+export function allPathsAllowed(allowedPaths, changedPaths) {
+  return pathsOutsideAllowlist(allowedPaths, changedPaths).length === 0;
+}

package/status-set.js

@@ -0,0 +1,87 @@
+import { sanitizeField, sanitizeUrl } from './caps.js';
+import { ERROR_CODES, forgeError } from './contracts/errors.js';
+
+/** Supported commit status states (Gitea/GitHub parity). */
+export const STATUS_SET_STATES = Object.freeze(['pending', 'success', 'failure', 'error']);
+
+const STATUS_SET_STATE_SET = new Set(STATUS_SET_STATES);
+
+const FULL_SHA_RE = /^[0-9a-fA-F]{40}$/;
+
+export function assertCommitSha(sha, label = 'sha') {
+  const value = String(sha ?? '').trim();
+  if (!FULL_SHA_RE.test(value)) {
+    throw Object.assign(new Error(`Invalid ${label}`), {
+      forgeError: forgeError(
+        ERROR_CODES.INVALID_ARGS,
+        `${label} must be a 40-character hexadecimal commit SHA`,
+      ),
+    });
+  }
+  return value.toLowerCase();
+}
+
+export function normalizeStatusSetState(state) {
+  const normalized = String(state ?? '').toLowerCase();
+  if (STATUS_SET_STATE_SET.has(normalized)) return normalized;
+  if (normalized === 'pass') return 'success';
+  if (normalized === 'fail') return 'failure';
+  throw Object.assign(new Error('Invalid status state'), {
+    forgeError: forgeError(
+      ERROR_CODES.INVALID_ARGS,
+      `state must be one of: ${STATUS_SET_STATES.join(', ')}`,
+    ),
+  });
+}
+
+export function parseStatusSetArgs({ sha, context, state, target_url, description }) {
+  const parsedSha = assertCommitSha(sha, '--sha');
+  if (context == null || String(context).trim() === '') {
+    throw Object.assign(new Error('--context required'), {
+      forgeError: forgeError(ERROR_CODES.INVALID_ARGS, '--context required for status set'),
+    });
+  }
+  if (state == null || String(state).trim() === '') {
+    throw Object.assign(new Error('--state required'), {
+      forgeError: forgeError(ERROR_CODES.INVALID_ARGS, '--state required for status set'),
+    });
+  }
+  const parsed = {
+    sha: parsedSha,
+    context: sanitizeField(String(context)),
+    state: normalizeStatusSetState(state),
+  };
+  if (target_url != null && String(target_url).trim() !== '') {
+    parsed.target_url = sanitizeUrl(String(target_url));
+  }
+  if (description != null && String(description).trim() !== '') {
+    parsed.description = sanitizeField(String(description));
+  }
+  return parsed;
+}
+
+/** Normalize forge commit status POST/GET response into commit_status_set body fields. */
+export function buildCommitStatusSetBody(
+  response,
+  args,
+  { reusedExisting = false } = {},
+) {
+  const state = normalizeStatusSetState(response?.status ?? response?.state ?? args.state);
+  const body = {
+    sha: args.sha,
+    context: sanitizeField(args.context),
+    state,
+  };
+  const description = response?.description ?? args.description;
+  if (description != null && String(description).trim() !== '') {
+    body.description = sanitizeField(String(description));
+  }
+  const targetUrl = response?.target_url ?? args.target_url;
+  if (targetUrl != null && String(targetUrl).trim() !== '') {
+    body.target_url = sanitizeUrl(String(targetUrl));
+  }
+  if (reusedExisting) {
+    body.reused_existing = true;
+  }
+  return body;
+}

package/stub-provider.js

@@ -29,5 +29,12 @@ export function createStubProvider(id) {
     prChecks: unsupported,
     mergePlan: unsupported,
     syncPlan: unsupported,
+    whoami: unsupported,
+    branchProtection: unsupported,
+    crFiles: unsupported,
+    crComments: unsupported,
+    forgeChanges: unsupported,
+    crOpen: unsupported,
+    statusSet: unsupported,
   };
 }

package/whoami.js

@@ -0,0 +1,114 @@
+import { sanitizeField } from './caps.js';
+
+/** Gitea does not expose OAuth scope or token expiry on GET /user. */
+export function unimplementedTokenScopeSignal() {
+  return { implemented: false, scopes: null };
+}
+
+export function unimplementedTokenExpirySignal() {
+  return { implemented: false, expires_at: null };
+}
+
+/** Restricted Gitea users are read-only; others may write per forge policy. */
+export function normalizeGiteaCanWrite(user) {
+  if (user == null || typeof user !== 'object') return false;
+  if (user.restricted === true) return false;
+  return true;
+}
+
+export function buildProviderIdentityBody({
+  login,
+  can_write,
+  token_scope_signal,
+  token_expiry_signal,
+}) {
+  return {
+    login: sanitizeField(login),
+    can_write: Boolean(can_write),
+    token_scope_signal,
+    token_expiry_signal,
+  };
+}
+
+export function buildProviderIdentityFromGiteaUser(user) {
+  return buildProviderIdentityBody({
+    login: user?.login ?? '',
+    can_write: normalizeGiteaCanWrite(user),
+    token_scope_signal: unimplementedTokenScopeSignal(),
+    token_expiry_signal: unimplementedTokenExpirySignal(),
+  });
+}
+
+export function parseGitHubOAuthScopes(headerValue) {
+  if (headerValue == null || String(headerValue).trim() === '') {
+    return unimplementedTokenScopeSignal();
+  }
+  const scopes = String(headerValue)
+    .split(',')
+    .map((scope) => sanitizeField(scope.trim()))
+    .filter(Boolean);
+  if (scopes.length === 0) {
+    return unimplementedTokenScopeSignal();
+  }
+  return { implemented: true, scopes };
+}
+
+export function githubCanWriteFromScopes(tokenScopeSignal) {
+  if (!tokenScopeSignal?.implemented || !Array.isArray(tokenScopeSignal.scopes)) {
+    return false;
+  }
+  return tokenScopeSignal.scopes.some(
+    (scope) => scope === 'repo' || scope === 'public_repo' || scope.startsWith('repo:'),
+  );
+}
+
+export function buildProviderIdentityFromGitHubUser(user, oauthScopesHeader) {
+  const token_scope_signal = parseGitHubOAuthScopes(oauthScopesHeader);
+  return buildProviderIdentityBody({
+    login: user?.login ?? '',
+    can_write: githubCanWriteFromScopes(token_scope_signal),
+    token_scope_signal,
+    token_expiry_signal: unimplementedTokenExpirySignal(),
+  });
+}
+
+export function normalizeGitLabCanWrite(user) {
+  if (user == null || typeof user !== 'object') return false;
+  if (user.state != null && user.state !== 'active') return false;
+  if (user.can_create_project === false) return false;
+  return true;
+}
+
+export function parseGitLabPatSelfSignals(patSelf) {
+  if (patSelf == null || typeof patSelf !== 'object') {
+    return {
+      token_scope_signal: unimplementedTokenScopeSignal(),
+      token_expiry_signal: unimplementedTokenExpirySignal(),
+    };
+  }
+  let token_scope_signal = unimplementedTokenScopeSignal();
+  if (Array.isArray(patSelf.scopes)) {
+    const scopes = patSelf.scopes.map((scope) => sanitizeField(String(scope))).filter(Boolean);
+    if (scopes.length > 0) {
+      token_scope_signal = { implemented: true, scopes };
+    }
+  }
+  const token_expiry_signal =
+    'expires_at' in patSelf
+      ? {
+          implemented: true,
+          expires_at: patSelf.expires_at == null ? null : sanitizeField(String(patSelf.expires_at)),
+        }
+      : unimplementedTokenExpirySignal();
+  return { token_scope_signal, token_expiry_signal };
+}
+
+export function buildProviderIdentityFromGitLabUser(user, patSelf) {
+  const { token_scope_signal, token_expiry_signal } = parseGitLabPatSelfSignals(patSelf);
+  return buildProviderIdentityBody({
+    login: user?.username ?? user?.login ?? '',
+    can_write: normalizeGitLabCanWrite(user),
+    token_scope_signal,
+    token_expiry_signal,
+  });
+}

package/write-config.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { ERROR_CODES, forgeError } from './contracts/errors.js';
+
+/** Canonical v1 consumer write command ids (schema + gate single source). */
+export const WRITE_COMMAND_IDS = Object.freeze(['cr_open', 'status_set']);
+
+export const writeCommandSchema = z.enum(WRITE_COMMAND_IDS);
+
+/** @deprecated use WRITE_COMMAND_IDS */
+export const CONFIGURED_WRITE_COMMANDS = WRITE_COMMAND_IDS;
+
+export function isWriteCommandConfigured(config, commandName) {
+  if (!writeCommandSchema.safeParse(commandName).success) return false;
+  const allowed = config?.write_commands;
+  return Array.isArray(allowed) && allowed.includes(commandName);
+}
+
+/** Consumer-facing message when a write command is not opted in via write_commands. */
+export function writeNotConfiguredMessage(commandName) {
+  return (
+    `Command "${commandName}" is not in write_commands; add it to .remogram.json `
+    + 'for Remogram CLI/MCP writes, or use your forge/CI tooling outside Remogram '
+    + '(read commands still work)'
+  );
+}
+
+export function assertWriteCommandConfigured(config, commandName) {
+  if (!writeCommandSchema.safeParse(commandName).success) {
+    throw Object.assign(new Error(`Unknown write command: ${commandName}`), {
+      forgeError: forgeError(
+        ERROR_CODES.INVALID_ARGS,
+        `Unknown write command "${commandName}"; supported: ${WRITE_COMMAND_IDS.join(', ')}`,
+      ),
+    });
+  }
+  if (isWriteCommandConfigured(config, commandName)) return;
+  throw Object.assign(new Error(`Write command not configured: ${commandName}`), {
+    forgeError: forgeError(
+      ERROR_CODES.WRITE_NOT_CONFIGURED,
+      writeNotConfiguredMessage(commandName),
+    ),
+  });
+}