@bridge_gpt/mcp-server 0.2.18 → 0.2.20

package/build/sfcc/ocapi-write-faults.js

@@ -0,0 +1,94 @@
+/**
+ * Shared OCAPI write fault-mapping primitives (BAPI-582 foundation).
+ *
+ * Centralizes the status/fault distinctions required by SFCC write plumbing so
+ * transport (client.ts) and future write tools do not each collapse write
+ * failures into a generic error. The known fault set below is the subset the
+ * ticket requires write handlers to be able to distinguish; unknown
+ * status/fault combinations are preserved verbatim rather than being coerced
+ * into one of the known types.
+ */
+// ---------------------------------------------------------------------------
+// Known (status, faultType) map
+// ---------------------------------------------------------------------------
+/** The exact (status → fault type) pairs the ticket requires callers to distinguish. */
+const KNOWN_WRITE_FAULTS = {
+    400: "MalformedKeyParameterException",
+    404: "AttributeDefinitionNotFoundException",
+    409: "IfMatchRequiredException",
+    412: "InvalidIfMatchException",
+};
+// ---------------------------------------------------------------------------
+// Fault extraction
+// ---------------------------------------------------------------------------
+/**
+ * Extract the OCAPI fault type from a response body.
+ *
+ * Handles the common SFCC shapes:
+ *   - `{ fault: { type: "..." } }`
+ *   - `{ type: "..." }`
+ *   - `{ fault: "..." }` (string-valued fault)
+ *
+ * Returns `undefined` when no usable fault type string is present.
+ */
+export function extractOcapiFaultType(body) {
+    if (body === null || typeof body !== "object")
+        return undefined;
+    const record = body;
+    // `{ fault: { type } }` or `{ fault: "..." }`
+    const fault = record.fault;
+    if (typeof fault === "string" && fault.length > 0)
+        return fault;
+    if (fault !== null && typeof fault === "object") {
+        const faultType = fault.type;
+        if (typeof faultType === "string" && faultType.length > 0)
+            return faultType;
+    }
+    // `{ type: "..." }`
+    const type = record.type;
+    if (typeof type === "string" && type.length > 0)
+        return type;
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Fault mapping
+// ---------------------------------------------------------------------------
+/**
+ * Map an OCAPI write response `(status, body)` into a structured fault.
+ *
+ * A fault is `known` only when BOTH the status and the extracted fault type
+ * match one of the ticket-required pairs. For everything else the numeric
+ * status and any extracted fault type are preserved without pretending the
+ * failure is one of the known faults.
+ */
+export function mapOcapiWriteFault(status, body) {
+    const faultType = extractOcapiFaultType(body);
+    const expected = KNOWN_WRITE_FAULTS[status];
+    const known = expected !== undefined && faultType === expected;
+    return {
+        status,
+        faultType,
+        known,
+        errorCode: known ? expected : "OCAPI_WRITE_FAULT",
+    };
+}
+// ---------------------------------------------------------------------------
+// Synthetic client-side bodies
+// ---------------------------------------------------------------------------
+/**
+ * Build an OCAPI-shaped synthetic body for the client-side missing-ETag case.
+ *
+ * Used by `ocapiPatch` when the GET round trip returned no ETag: rather than
+ * issuing a PATCH that SFCC would reject, the client synthesizes a
+ * `409 IfMatchRequiredException` body so callers see the same shape they would
+ * for a server-originated If-Match failure.
+ */
+export function buildSyntheticIfMatchRequiredBody(path) {
+    return {
+        fault: {
+            type: "IfMatchRequiredException",
+            message: `PATCH ${path} requires an ETag (If-Match) captured from the GET round trip, ` +
+                `but the GET response returned no ETag header. Cannot safely issue a conditional PATCH.`,
+        },
+    };
+}

package/build/sfcc/permissions.js

@@ -9,6 +9,7 @@
 import { ocapiGet } from "./client.js";
 import { normalizeOcapiPage } from "./ocapi-shape.js";
 import { DEFAULT_OCAPI_VERSION } from "./config.js";
+import { formatOcapiWriteGrantJson } from "./write-grants.js";
 // ---------------------------------------------------------------------------
 // OCAPI Settings JSON template
 // Operators paste this in: Administration > Site Development > Open Commerce API Settings → Data API tab.
@@ -47,28 +48,12 @@ const OCAPI_SETTINGS_READ_ONLY = (ocapiVersion) => JSON.stringify({
         },
     ],
 }, null, 2);
-const OCAPI_SETTINGS_WRITE_IMPORT = (ocapiVersion) => JSON.stringify({
-    _v: ocapiVersion,
-    clients: [
-        {
-            client_id: "<YOUR_CLIENT_ID>",
-            resources: [
-                {
-                    resource_id: "/system_object_definitions",
-                    methods: ["get", "put", "patch", "delete"],
-                    read_attributes: "(**)",
-                    write_attributes: "(**)",
-                },
-                {
-                    resource_id: "/system_object_definitions/**",
-                    methods: ["get", "put", "patch", "delete"],
-                    read_attributes: "(**)",
-                    write_attributes: "(**)",
-                },
-            ],
-        },
-    ],
-}, null, 2);
+// Write/import grants are sourced from the shared write-grants module so the
+// JSON printed here is byte-identical to what future write handlers echo on a
+// 403. This now covers all required write resource families:
+// /system_object_definitions, /system_object_definitions/**,
+// /custom_object_definitions/**, and /site_preferences/**.
+const OCAPI_SETTINGS_WRITE_IMPORT = (ocapiVersion) => formatOcapiWriteGrantJson(ocapiVersion);
 // ---------------------------------------------------------------------------
 // Tool implementation
 // ---------------------------------------------------------------------------

package/build/sfcc/reads-site-preference.js

@@ -2,10 +2,11 @@
  * SFCC site-preference introspection read tools (BAPI-403, T6 — optional).
  *
  * Implements:
- *   site_preference_get    — GET  /site_preferences/preference_groups/{group}/{instance}
- *   site_preference_search — POST /site_preferences/preference_groups/{group}/{instance}/preference_search
+ *   site_preference_group_list — GET  /system_object_definitions/SitePreferences/attribute_groups
+ *   site_preference_get        — match-all POST /site_preferences/preference_groups/{group}/{instance}/preference_search
+ *   site_preference_search     — POST /site_preferences/preference_groups/{group}/{instance}/preference_search
  *
- * Both tools are read-only, run behind the T1 call-time gate, and route
+ * All three tools are read-only, run behind the T1 call-time gate, and route
  * oversized payloads through the sfcc/output.ts truncate-and-save seam.
  *
  * NOTE: SCAPI Preferences API (sfcc.preferences) is intentionally NOT used.
@@ -35,20 +36,24 @@ const INSTANCE_ENUM = z.enum(["staging", "development", "sandbox", "production"]
 const INSTANCE_DESCRIBE = "OCAPI instance context. v1 supports the 'sandbox' context only; " +
     "any other value is rejected with a validation error. Defaults to 'sandbox'.";
 const sitePreferenceGetInput = z.object({
-    group: z.string().describe("Preference group ID, e.g. 'Account' or 'General'."),
+    group: z.string().describe("Custom site preference group ID, e.g. 'LLMIntegration'."),
     instance: INSTANCE_ENUM.optional().default("sandbox").describe(INSTANCE_DESCRIBE),
     start: z.number().optional().describe("Zero-based offset for paging."),
     count: z.number().optional().describe("Maximum number of preferences to return."),
 });
 const sitePreferenceSearchInput = z.object({
-    group: z.string().describe("Preference group ID to search within."),
+    group: z.string().describe("Custom site preference group ID to search within, e.g. 'LLMIntegration'."),
     instance: INSTANCE_ENUM.optional().default("sandbox").describe(INSTANCE_DESCRIBE),
-    query: z.union([z.string(), z.record(z.string(), z.any())]).describe("Search query. Pass a plain string for text search across preference ids and values, " +
+    query: z.union([z.string(), z.record(z.string(), z.any())]).describe("Search query. Pass a plain string for text search across preference ids, " +
         "or a structured OCAPI query object (term_query, filtered_query, etc.)."),
     start: z.number().optional().describe("Zero-based offset for paging."),
     count: z.number().optional().describe("Maximum number of results to return."),
     sorts: z.array(z.any()).optional().describe("Array of OCAPI sort descriptors."),
 });
+const sitePreferenceGroupListInput = z.object({
+    count: z.number().optional().describe("Maximum number of site preference groups to return."),
+    start: z.number().optional().describe("Zero-based offset for paging."),
+});
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -86,15 +91,14 @@ export function buildSitePreferenceGetHandler(gateDeps, getDocsDir) {
         if (guard)
             return guard;
         const encodedGroup = encodeURIComponent(group);
-        const queryParams = {};
+        const postBody = {
+            query: { match_all_query: {} },
+        };
         if (start !== undefined)
-            queryParams.start = String(start);
+            postBody.start = start;
         if (count !== undefined)
-            queryParams.count = String(count);
-        const queryStr = Object.keys(queryParams).length > 0
-            ? "?" + new URLSearchParams(queryParams).toString()
-            : "";
-        const result = await ocapiGet(`/site_preferences/preference_groups/${encodedGroup}/${instance}${queryStr}`, credentials);
+            postBody.count = count;
+        const result = await ocapiPost(`/site_preferences/preference_groups/${encodedGroup}/${instance}/preference_search`, postBody, credentials);
         if (!result.ok) {
             return textResult(JSON.stringify({ error: "OCAPI error", status: result.status, body: result.body }, null, 2));
         }
@@ -113,7 +117,7 @@ export function buildSitePreferenceSearchHandler(gateDeps, getDocsDir) {
         const encodedGroup = encodeURIComponent(group);
         // Coerce plain string queries into OCAPI text_query shape
         const resolvedQuery = typeof query === "string"
-            ? { text_query: { fields: ["id", "value"], search_phrase: query } }
+            ? { text_query: { fields: ["id"], search_phrase: query } }
             : query;
         const postBody = { query: resolvedQuery };
         if (start !== undefined)
@@ -132,25 +136,54 @@ export function buildSitePreferenceSearchHandler(gateDeps, getDocsDir) {
         return saveAndReturn(text, dir, `site-preference-search-${safeGroup(group)}-${safeTimestamp()}.json`);
     });
 }
+export function buildSitePreferenceGroupListHandler(gateDeps, getDocsDir) {
+    return withSfccGate(gateDeps, async (args, credentials) => {
+        const { count, start } = sitePreferenceGroupListInput.parse(args);
+        const queryParams = {};
+        if (count !== undefined)
+            queryParams.count = String(count);
+        if (start !== undefined)
+            queryParams.start = String(start);
+        const queryStr = Object.keys(queryParams).length > 0
+            ? "?" + new URLSearchParams(queryParams).toString()
+            : "";
+        const result = await ocapiGet(`/system_object_definitions/SitePreferences/attribute_groups${queryStr}`, credentials);
+        if (!result.ok) {
+            return textResult(JSON.stringify({ error: "OCAPI error", status: result.status, body: result.body }, null, 2));
+        }
+        const normalized = normalizeOcapiBody(result.body);
+        const text = JSON.stringify(normalized, null, 2);
+        const dir = path.join(await getDocsDir(), "sfcc");
+        return saveAndReturn(text, dir, `site-preference-group-list-${safeTimestamp()}.json`);
+    });
+}
 /**
- * Register the two SFCC site-preference introspection read tools.
+ * Register the three SFCC site-preference introspection read tools.
  *
  * Called from `registerSfccTools` — no direct `index.ts` edits needed.
  */
 export function registerSitePreferenceTools(registerTool, deps) {
     const { gateDeps, getDocsDir } = deps;
+    registerTool("site_preference_group_list", {
+        description: "List custom site preference group ids from the developer sandbox via " +
+            "GET /system_object_definitions/SitePreferences/attribute_groups. Read-only; " +
+            "use this to discover group ids before site_preference_get or site_preference_search. " +
+            "Accepts optional `count` and `start` for paging. Oversized outputs are auto-saved locally.",
+        inputSchema: sitePreferenceGroupListInput,
+        annotations: READ_ANNOTATIONS,
+    }, buildSitePreferenceGroupListHandler(gateDeps, getDocsDir));
     registerTool("site_preference_get", {
         description: "Read effective preferences for a site preference group from the developer sandbox " +
-            "via GET /site_preferences/preference_groups/{group}/sandbox. Read-only; v1 supports " +
-            "sandboxes only (non-sandbox instances are rejected). Accepts optional `start` and " +
-            "`count` for paging. Oversized payloads are auto-saved locally and previewed inline.",
+            "via a match-all POST /site_preferences/preference_groups/{group}/sandbox/preference_search. " +
+            "Read-only, sandbox-only. Accepts optional `start`/`count` paging in the POST body. " +
+            "Oversized payloads are auto-saved locally.",
         inputSchema: sitePreferenceGetInput,
         annotations: READ_ANNOTATIONS,
     }, buildSitePreferenceGetHandler(gateDeps, getDocsDir));
     registerTool("site_preference_search", {
         description: "Search/filter preferences within a site preference group from the developer sandbox " +
             "via POST /site_preferences/preference_groups/{group}/sandbox/preference_search. " +
-            "Read-only; v1 sandbox only. Pass a plain string for text search or a structured " +
+            "Read-only; v1 sandbox only. Pass a plain string for id-only text search or a structured " +
             "OCAPI query object. Oversized results are auto-saved locally.",
         inputSchema: sitePreferenceSearchInput,
         annotations: READ_ANNOTATIONS,

package/build/sfcc/register.js

@@ -13,6 +13,7 @@ import { checkPermissionsTool } from "./permissions.js";
 import { registerSystemObjectReadTools } from "./reads-system-object.js";
 import { registerSfccCustomObjectDefReadTools } from "./reads-custom-object-def.js";
 import { registerSitePreferenceTools } from "./reads-site-preference.js";
+import { registerSfccWriteTools } from "./writes.js";
 // ---------------------------------------------------------------------------
 // Registration
 // ---------------------------------------------------------------------------
@@ -69,5 +70,13 @@ export function registerSfccTools(registerTool, deps) {
             gateDeps,
             getDocsDir: deps.getDocsDir,
         });
+        // SFCC write registration seam (BAPI-582). No write tools ship yet — future
+        // write-surface tickets register here. Gated behind the same includeReadTools
+        // branch so writes become default-on with reads whenever the sfcc profile
+        // group is active.
+        registerSfccWriteTools(registerTool, {
+            gateDeps,
+            getDocsDir: deps.getDocsDir,
+        });
     }
 }

package/build/sfcc/write-grants.js

@@ -0,0 +1,80 @@
+/**
+ * Shared OCAPI write-grant JSON helpers (BAPI-582 foundation).
+ *
+ * This module is the single source of truth for the OCAPI write-grant JSON that
+ * is both echoed by future write handlers on a 403 and printed by the
+ * `check_permissions` diagnostic. Keeping one definition guarantees the
+ * remediation JSON an operator sees is identical no matter which surface it
+ * comes from.
+ */
+// ---------------------------------------------------------------------------
+// Write resource families
+// ---------------------------------------------------------------------------
+/**
+ * The OCAPI write resource families required by the SFCC write surface.
+ * Defined once here so the grant JSON and any future validation share the list.
+ */
+export const OCAPI_WRITE_RESOURCE_IDS = [
+    "/system_object_definitions",
+    "/system_object_definitions/**",
+    "/custom_object_definitions/**",
+    "/site_preferences/**",
+];
+// ---------------------------------------------------------------------------
+// Grant JSON builders
+// ---------------------------------------------------------------------------
+/**
+ * Build the OCAPI Settings write-grant object for the given version.
+ *
+ * The `clientIdPlaceholder` stays as `<YOUR_CLIENT_ID>` by default so the output
+ * is safe to print and paste — the real resolved client_id is never substituted.
+ */
+export function buildOcapiWriteGrantSettings(ocapiVersion, clientIdPlaceholder = "<YOUR_CLIENT_ID>") {
+    return {
+        _v: ocapiVersion,
+        clients: [
+            {
+                client_id: clientIdPlaceholder,
+                resources: OCAPI_WRITE_RESOURCE_IDS.map((resource_id) => ({
+                    resource_id,
+                    methods: ["get", "put", "patch", "delete"],
+                    read_attributes: "(**)",
+                    write_attributes: "(**)",
+                })),
+            },
+        ],
+    };
+}
+/** Pretty-printed JSON string of the write-grant settings. */
+export function formatOcapiWriteGrantJson(ocapiVersion, clientIdPlaceholder = "<YOUR_CLIENT_ID>") {
+    return JSON.stringify(buildOcapiWriteGrantSettings(ocapiVersion, clientIdPlaceholder), null, 2);
+}
+// ---------------------------------------------------------------------------
+// 403 write-grant UX
+// ---------------------------------------------------------------------------
+/**
+ * Build the human-facing 403 remediation text for a failed write operation.
+ * Includes the 403 status, the failed operation/path, and the exact write-grant
+ * JSON operators must paste in Business Manager.
+ */
+export function buildOcapiWriteGrant403Text(params) {
+    const { operation, path, ocapiVersion, body } = params;
+    const bodyLine = body === undefined
+        ? ""
+        : `\nResponse body:\n${JSON.stringify(body, null, 2)}\n`;
+    return (`HTTP 403: OCAPI write access denied for ${operation} ${path}.\n` +
+        bodyLine +
+        `\nTo grant write access, paste the JSON below in Business Manager:\n` +
+        `  Administration > Site Development > Open Commerce API Settings → Data API tab\n\n` +
+        `${formatOcapiWriteGrantJson(ocapiVersion)}\n\n` +
+        `Replace <YOUR_CLIENT_ID> with the client_id from your dw.json.`);
+}
+/**
+ * MCP-shaped wrapper around `buildOcapiWriteGrant403Text` so future write
+ * handlers can return the grant UX without re-implementing content wrapping.
+ */
+export function writeGrantForbiddenResult(params) {
+    return {
+        content: [{ type: "text", text: buildOcapiWriteGrant403Text(params) }],
+    };
+}

package/build/sfcc/write-guard.js

@@ -0,0 +1,39 @@
+/**
+ * Reusable sandbox-only write guard (BAPI-582 foundation).
+ *
+ * Future SFCC write handlers MUST call `rejectIfNotSandboxForWrite`
+ * immediately after input parsing and BEFORE any payload construction or OCAPI
+ * mutation. A non-null return value is
+ * the pre-formatted MCP rejection to return directly; a null return means the
+ * effective instance is a sandbox and the handler may proceed.
+ */
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Wrap text in the standard MCP text-result shape. */
+function textResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+// ---------------------------------------------------------------------------
+// Guard
+// ---------------------------------------------------------------------------
+/**
+ * Reject any write targeting a non-sandbox instance.
+ *
+ * SFCC write tools are sandbox-only in this foundation. The effective instance
+ * defaults to `"sandbox"` when `undefined` (some schemas default the value
+ * elsewhere), so an omitted instance is allowed. Any other value returns a
+ * structured JSON validation error naming the rejected instance; a sandbox
+ * returns `null` so the caller proceeds.
+ */
+export function rejectIfNotSandboxForWrite(instance) {
+    const effective = instance === undefined ? "sandbox" : instance;
+    if (effective === "sandbox")
+        return null;
+    return textResult(JSON.stringify({
+        error: "VALIDATION_ERROR",
+        status: 400,
+        message: `SFCC write tools are sandbox-only. Refusing to write against instance ` +
+            `'${effective}'. Re-run the write against a developer sandbox instance.`,
+    }));
+}

package/build/sfcc/write-result.js

@@ -0,0 +1,47 @@
+/**
+ * Shared write-result formatter (BAPI-582 foundation).
+ *
+ * This is the single formatting path for all future SFCC write tools. Handlers
+ * pass the raw `OcapiGetResult` from `ocapiPut`/`ocapiPatch` here rather than
+ * inventing their own 403/fault/success response logic, guaranteeing a
+ * consistent surface across every write tool.
+ */
+import { writeGrantForbiddenResult } from "./write-grants.js";
+import { DEFAULT_OCAPI_VERSION } from "./config.js";
+/** Wrap text in the standard MCP text-result shape. */
+function textResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+// ---------------------------------------------------------------------------
+// Formatter
+// ---------------------------------------------------------------------------
+/**
+ * Format an OCAPI write result into the standard MCP tool response.
+ *
+ *  - `403` → the paste-ready write-grant remediation (via write-grants.ts).
+ *  - success → JSON with `status`, `outcome`, and `body`.
+ *  - other failure → JSON with `error: "OCAPI_WRITE_ERROR"`, `status`, `fault`, `body`.
+ */
+export function formatOcapiWriteToolResult(result, operation, path, ocapiVersion = DEFAULT_OCAPI_VERSION) {
+    if (result.status === 403) {
+        return writeGrantForbiddenResult({
+            operation,
+            path,
+            ocapiVersion,
+            body: result.body,
+        });
+    }
+    if (result.ok) {
+        return textResult(JSON.stringify({
+            status: result.status,
+            outcome: result.outcome,
+            body: result.body,
+        }));
+    }
+    return textResult(JSON.stringify({
+        error: "OCAPI_WRITE_ERROR",
+        status: result.status,
+        fault: result.fault,
+        body: result.body,
+    }));
+}

package/build/sfcc/write-tool-common.js

@@ -0,0 +1,85 @@
+/**
+ * Shared helpers for the SFCC write MCP tools (BAPI-584).
+ *
+ * The two write-surface modules (`writes-custom-object-def.ts` and
+ * `writes-site-preference.ts`) both need the same small set of primitives:
+ * the destructive tool annotations, the MCP text-result shape, a consistent
+ * set of safe pre-transport error envelopes (validation / unexpected), and a
+ * single path-segment encoder. Centralizing them here guarantees every write
+ * tool returns an identical envelope shape and never leaks a stack trace or a
+ * raw thrown value to the caller.
+ */
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// Annotations
+// ---------------------------------------------------------------------------
+/**
+ * Annotations shared by every SFCC write tool. Writes are mutating and NOT
+ * read-only or idempotent; `openWorldHint` mirrors the read tools (OCAPI is an
+ * external system).
+ */
+export const WRITE_ANNOTATIONS = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: true,
+};
+/** Wrap text in the standard MCP text-result shape. */
+export function textResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+// ---------------------------------------------------------------------------
+// Pre-transport error envelopes
+// ---------------------------------------------------------------------------
+/**
+ * Convert a Zod validation failure into a safe `VALIDATION_ERROR` envelope.
+ * The flattened issues are surfaced so callers can see which field failed,
+ * without exposing any thrown-error internals.
+ */
+export function zodValidationEnvelope(err) {
+    return textResult(JSON.stringify({
+        error: "VALIDATION_ERROR",
+        status: 400,
+        message: "Input failed schema validation before any OCAPI call.",
+        issues: err.issues.map((issue) => ({
+            path: issue.path.join("."),
+            message: issue.message,
+        })),
+    }, null, 2));
+}
+/**
+ * A plain (non-Zod) validation rejection, e.g. a body/URL field mismatch that
+ * the schema alone cannot express. Same envelope shape as the Zod variant.
+ */
+export function validationEnvelope(message) {
+    return textResult(JSON.stringify({ error: "VALIDATION_ERROR", status: 400, message }, null, 2));
+}
+/**
+ * Safe fallback envelope for an unexpected thrown error inside a write handler
+ * (typically a transport-layer throw). Never includes a stack trace or the raw
+ * thrown value.
+ */
+export function unexpectedEnvelope() {
+    return textResult(JSON.stringify({
+        error: "INTERNAL_ERROR",
+        status: 500,
+        message: "Unexpected SFCC write tool failure.",
+    }, null, 2));
+}
+/**
+ * Map a pre-transport error to its envelope: Zod validation errors become a
+ * `VALIDATION_ERROR`, everything else becomes the generic `INTERNAL_ERROR`.
+ * Used for the `.parse()` boundary before any OCAPI mutation.
+ */
+export function preTransportErrorEnvelope(err) {
+    if (err instanceof z.ZodError)
+        return zodValidationEnvelope(err);
+    return unexpectedEnvelope();
+}
+// ---------------------------------------------------------------------------
+// Path encoding
+// ---------------------------------------------------------------------------
+/** URL-encode a single OCAPI path segment. */
+export function encodedSegment(segment) {
+    return encodeURIComponent(segment);
+}