@drawbridge/drawbridge-utils 0.0.171 → 0.0.173

package/dist/connections/index.cjs

@@ -618,6 +618,7 @@ var row = ({ connection: connection2, data: data2, manifest, row: described }) =
   };
 };
 var segmentRowWrites = ({ connection: connection2, data: data2, manifest, row: described, segment }) => {
+  if ((described == null ? void 0 : described.id) === void 0 || (described == null ? void 0 : described.id) === null) return [];
   const built = row({ connection: connection2, data: data2, manifest, row: described });
   return [
     // PUSH IF ABSENT. The $ne guard is what makes a second concurrent register
@@ -2167,16 +2168,16 @@ var deliveryWrite = ({ at, code: code2, notification, permanent, provider, reaso
   };
 };
 var summariseEvents = (events) => {
-  const list = Array.isArray(events) ? events : [];
-  if (!list.length) return { message: "SendGrid delivered an empty event batch.", skipped: true };
+  const list2 = Array.isArray(events) ? events : [];
+  if (!list2.length) return { message: "SendGrid delivered an empty event batch.", skipped: true };
   const counts = {};
-  for (const { event } of list) {
+  for (const { event } of list2) {
     const name = event || "unknown";
     counts[name] = (counts[name] || 0) + 1;
   }
   const tally = Object.entries(counts).map(([name, count]) => count + " " + name).join(", ");
-  const refused = list.filter(({ event }) => REFUSALS.has(event)).slice(0, 5).map(({ email, reason, response, status }) => email + " \u2014 " + (reason || response || status || "no reason given"));
-  const writes = list.map((event) => {
+  const refused = list2.filter(({ event }) => REFUSALS.has(event)).slice(0, 5).map(({ email, reason, response, status }) => email + " \u2014 " + (reason || response || status || "no reason given"));
+  const writes = list2.map((event) => {
     var _a;
     return deliveryWrite({
       at: event.timestamp ? new Date(event.timestamp * 1e3) : void 0,
@@ -2196,7 +2197,7 @@ var summariseEvents = (events) => {
     });
   }).filter(Boolean);
   return {
-    message: [list.length + " SendGrid event(s): " + tally, ...refused].join(" | "),
+    message: [list2.length + " SendGrid event(s): " + tally, ...refused].join(" | "),
     ...writes.length ? { writes } : { skipped: true }
   };
 };
@@ -3063,6 +3064,14 @@ var klaviyo_default = `<svg width="500" height="500" viewBox="0 0 500 500" fill=
 <path d="M365.047 327.038H134.954V172.964H365.047L316.856 250.001L365.047 327.038Z" fill="#232121"/>
 </svg>`;
 
+// lib/connections/scopes.js
+var list = (value) => (Array.isArray(value) ? value.flatMap((entry) => String(entry).split(/\s+/)) : String(value ?? "").split(/\s+/)).map((entry) => entry.trim()).filter(Boolean);
+var missingScopes = ({ granted, required }) => {
+  if (granted === null || granted === void 0 || granted === "") return null;
+  const held = new Set(list(granted));
+  return list(required).filter((scope) => !held.has(scope));
+};
+
 // lib/connections/providers/klaviyo.js
 var api2 = async (path, { fetcher = fetch, method = "GET", payload, token }) => {
   const response = await fetcher("https://a.klaviyo.com/api" + path, {
@@ -3090,8 +3099,10 @@ var api2 = async (path, { fetcher = fetch, method = "GET", payload, token }) =>
   }
   return response.status === 204 ? null : response.json();
 };
-var segmentName = (title) => "Drawbridge: " + title;
-var canManageSegments = (settings) => String((settings == null ? void 0 : settings.scope) || "").split(/\s+/).includes("segments:write");
+var segmentName = (title, id) => "Drawbridge: " + title + " (" + String(id).slice(-6) + ")";
+var SCOPES = "accounts:read lists:read lists:write profiles:read profiles:write segments:read segments:write";
+var missing = (settings) => missingScopes({ granted: settings == null ? void 0 : settings.scope, required: SCOPES });
+var canManageSegments = (settings) => !(missing(settings) || []).includes("segments:write");
 var klaviyo_default2 = {
   // OAuth 2.1, and PKCE is REQUIRED rather than recommended: Klaviyo refuses an
   // exchange without a code_verifier matching the challenge the consent
@@ -3135,7 +3146,7 @@ var klaviyo_default2 = {
       // Update and Delete Segment each list `segments:write`
       // (raw.githubusercontent.com/klaviyo/openapi/main/openapi/stable.json,
       // revision 2026-07-15, fetched 2026-09-11).
-      scopes: "accounts:read lists:read lists:write profiles:read profiles:write segments:read segments:write",
+      scopes: SCOPES,
       // EVERY VENDOR URL, in one place. `revoke` used to be a literal inside
       // the disconnect hook — three vendor addresses, two of them declared,
       // which is exactly the kind of split that goes unnoticed.
@@ -3316,8 +3327,14 @@ var klaviyo_default2 = {
         });
         return { ok: Boolean(token) };
       },
-      // Klaviyo scopes are fixed at app level and re-consented, not drifted.
-      scopes: false,
+      // THEY DO DRIFT, and the comment here used to say they could not. Klaviyo
+      // scopes are fixed on the APP, so adding one re-consents every NEW grant
+      // and leaves every EXISTING one exactly as narrow as it was — with no
+      // error, no webhook, and nothing that notices. That is what left grants
+      // authenticating perfectly while silently unable to manage a segment.
+      //
+      // The same slot Shopify answers, so one caller can ask any vendor.
+      scopes: ({ scope }) => missingScopes({ granted: scope, required: SCOPES }),
       // KLAVIYO REQUIRES HTTP BASIC on the token endpoint and rejects the same
       // client_id/client_secret pair as body fields. Everything else about the
       // request is standard, so this is the shared implementation told the one
@@ -3338,9 +3355,9 @@ var klaviyo_default2 = {
       remove: false,
       sync: async ({ context, lead, segments, settings, suppressed, token }, { fetcher } = {}) => {
         var _a, _b, _c, _d, _e;
-        const list = settings == null ? void 0 : settings.list;
+        const list2 = settings == null ? void 0 : settings.list;
         const request2 = { email: ((_b = (_a = lead == null ? void 0 : lead.canonical) == null ? void 0 : _a.email) == null ? void 0 : _b.value) || (lead == null ? void 0 : lead.email) || null, list: (settings == null ? void 0 : settings.list) || null };
-        if (!list) return { message: "No Klaviyo list is chosen for this connection.", request: request2, skipped: true };
+        if (!list2) return { message: "No Klaviyo list is chosen for this connection.", request: request2, skipped: true };
         const email = ((_d = (_c = lead == null ? void 0 : lead.canonical) == null ? void 0 : _c.email) == null ? void 0 : _d.value) || (lead == null ? void 0 : lead.email);
         if (!email) return { message: "That lead has no email address to sync.", request: request2, skipped: true };
         const person = (context == null ? void 0 : context.contact) || null;
@@ -3419,7 +3436,7 @@ var klaviyo_default2 = {
                   }]
                 }
               },
-              relationships: { list: { data: { id: list, type: "list" } } },
+              relationships: { list: { data: { id: list2, type: "list" } } },
               type: "profile-subscription-bulk-create-job"
             }
           },
@@ -3465,7 +3482,7 @@ var klaviyo_default2 = {
             skipped: true
           };
         }
-        const name = segmentName(segment.title);
+        const name = segmentName(segment.title, segment.id);
         const existing = segmentRowFor({ connection: connection2, segment });
         let id = null;
         if (existing == null ? void 0 : existing.id) {
@@ -3592,7 +3609,7 @@ var klaviyo_default2 = {
       // The one call below proves the minted token is HONOURED — mint and
       // acceptance are different facts, and /accounts is already the call
       // the connect flow makes (auth.connect), so it needs no new scope.
-      health: async ({ connection: connection2, token }, { fetcher, read } = {}) => {
+      health: async ({ connection: connection2, settings, token }, { fetcher, read } = {}) => {
         const request2 = { connectionId: connection2.id };
         try {
           await api2("/accounts", { fetcher, token });
@@ -3644,8 +3661,8 @@ var klaviyo_default2 = {
         let pages = 0;
         while (next && audiences.length < limit && pages < 20) {
           const body = await api2(next, { fetcher, token });
-          for (const list of (body == null ? void 0 : body.data) || []) {
-            audiences.push({ id: list.id, title: ((_a = list == null ? void 0 : list.attributes) == null ? void 0 : _a.name) || list.id });
+          for (const list2 of (body == null ? void 0 : body.data) || []) {
+            audiences.push({ id: list2.id, title: ((_a = list2 == null ? void 0 : list2.attributes) == null ? void 0 : _a.name) || list2.id });
           }
           const link = (_b = body == null ? void 0 : body.links) == null ? void 0 : _b.next;
           next = link ? String(link).replace(/^https:\/\/a\.klaviyo\.com\/api/, "") : null;
@@ -3811,13 +3828,14 @@ var klaviyo_default2 = {
     var _a;
     if (!["active", "pending"].includes(data2 == null ? void 0 : data2.status)) return [];
     return [
-      // A connection made before segments were requested is authenticated and
-      // cannot manage them, and no error surfaces anywhere else — the register
-      // runs skip rather than fail.
-      ...canManageSegments(data2 == null ? void 0 : data2.settings) ? [] : [{
-        message: "Drawbridge now keeps a Klaviyo segment in step with each of your Drawbridge segments. Reconnect Klaviyo to allow it.",
-        title: "Reconnect Klaviyo"
-      }],
+      // THE MISSING SEGMENT SCOPE IS NOT HERE ANY MORE. It is an ERROR entry,
+      // written by the health check, because a task is quiet: it renders only in
+      // the body of this connection's own page, so a merchant who never opens it
+      // never learns that their segments stopped being published. An error entry
+      // reaches the card and the organization checklist too.
+      //
+      // Deliberately not a status change — see the health hook for why that
+      // would stop the contact sync that still works.
       ...((_a = data2 == null ? void 0 : data2.settings) == null ? void 0 : _a.list) ? [] : [{
         message: "Choose which Klaviyo list your contacts should sync into. Until you do, nothing is being synced.",
         title: "Choose a list"
@@ -3872,7 +3890,10 @@ var api3 = async (path, { dc, fetcher = fetch, method = "GET", payload, token })
 };
 var subscriberHash = (email) => (0, import_node_crypto5.createHash)("md5").update(String(email).trim().toLowerCase()).digest("hex");
 var TAG_NAME_LIMIT = 100;
-var tagName = (title) => ("Drawbridge: " + title).slice(0, TAG_NAME_LIMIT);
+var tagName = (title, id) => {
+  const suffix = " (" + String(id).slice(-6) + ")";
+  return ("Drawbridge: " + title).slice(0, TAG_NAME_LIMIT - suffix.length) + suffix;
+};
 var mailchimp_default2 = {
   // OAUTH 2, authorization code. Every url below is quoted from
   // mailchimp.com/developer/marketing/guides/access-user-data-oauth-2/ rather
@@ -4053,14 +4074,17 @@ var mailchimp_default2 = {
                 }
               },
               {
-                $project: { _id: 0, title: 1 }
+                // THE ID AS WELL AS THE TITLE, because the tag name carries it —
+                // see tagName. Without it every name here would end in the
+                // string 'undefined' and match nothing register wrote.
+                $project: { _id: 0, id: 1, title: 1 }
               }
             ]
           });
-          const joined = new Set(segments.map((entry) => entry.title));
-          const tags = (owned || []).map((entry) => entry.title).filter(Boolean).map((title) => ({
-            name: tagName(title),
-            status: joined.has(title) ? "active" : "inactive"
+          const joined = new Set(segments.map((entry) => entry.id));
+          const tags = (owned || []).filter((entry) => entry.id && entry.title).map((entry) => ({
+            name: tagName(entry.title, entry.id),
+            status: joined.has(entry.id) ? "active" : "inactive"
           }));
           if (tags.length > 0) {
             await api3("/lists/" + audience + "/members/" + hash + "/tags", {
@@ -4112,7 +4136,7 @@ var mailchimp_default2 = {
         if (!audience) return { message: "No Mailchimp audience is chosen for this connection.", skipped: true };
         const segment = await currentSegment({ read, segment: context == null ? void 0 : context.segment });
         if (!(segment == null ? void 0 : segment.id) || segment.system) return { message: "That segment is not one this connection publishes.", skipped: true };
-        const name = tagName(segment.title);
+        const name = tagName(segment.title, segment.id);
         const existing = segmentRowFor({ connection: connection2, segment });
         let id = null;
         if (existing == null ? void 0 : existing.id) {
@@ -4218,7 +4242,7 @@ var mailchimp_default2 = {
           "/lists?count=" + count + "&offset=" + offset + "&fields=lists.id,lists.name,total_items",
           { dc: settings == null ? void 0 : settings.dc, fetcher, token }
         );
-        const audiences = ((body == null ? void 0 : body.lists) || []).map((list) => ({ id: list.id, title: (list == null ? void 0 : list.name) || list.id }));
+        const audiences = ((body == null ? void 0 : body.lists) || []).map((list2) => ({ id: list2.id, title: (list2 == null ? void 0 : list2.name) || list2.id }));
         const term = String((search == null ? void 0 : search.value) || "").trim().toLowerCase();
         const items = term ? audiences.filter((entry) => entry.title.toLowerCase().includes(term)) : audiences;
         const nextOffset = offset + count;
@@ -4665,10 +4689,6 @@ var shopify_default2 = {
         if (!(context == null ? void 0 : context.lead)) return { message: "Lead id is missing.", request: request2, response: { skipped: true }, skipped: true };
         if (!(discount == null ? void 0 : discount.id)) return { message: "Discount is not configured on this step.", request: request2, response: { skipped: true }, skipped: true };
         const adminAccessToken = await adminToken();
-        if (!context.shopifyCustomerId) {
-          const customer = await shopify.admin.getOrCreateCustomer({ adminAccessToken, domain: connection2.shop, email: context.email });
-          if (!(customer == null ? void 0 : customer.id)) return { message: "Shopify did not return a customer id \u2014 create/lookup failed.", request: request2, response: { skipped: true }, skipped: true };
-        }
         const discountCode = await shopify.admin.createDiscountCode({
           adminAccessToken,
           code: "DB-" + generateDiscountCode(),

package/dist/connections/index.d.cts

@@ -854,6 +854,13 @@ const row = ({ connection, data, manifest, row : described }) => ({
 
 const segmentRowWrites = ({ connection, data, manifest, row : described, segment }) => {
 
+	// NO ID, NO ROW. `String( undefined )` is the string 'undefined', which is a
+	// perfectly valid string as far as the api's schema is concerned — so a row
+	// built without a vendor id would store and then render as a live-looking
+	// link to an object that does not exist. The three hooks all guard before
+	// they get here; this is the guard that does not depend on them remembering.
+	if( described?.id === undefined || described?.id === null ) return [];
+
 	const built = row({ connection, data, manifest, row : described });
 
 	return [
@@ -3495,6 +3502,39 @@ var icon$2 = `<svg width="500" height="500" viewBox="0 0 500 500" fill="none" xm
 <path d="M365.047 327.038H134.954V172.964H365.047L316.856 250.001L365.047 327.038Z" fill="#232121"/>
 </svg>`;
 
+// WHAT A GRANT IS MISSING, as set arithmetic and nothing else.
+//
+// Every vendor that can drift answers `auth.scopes` with what is absent from the
+// grant it was handed. The comparison itself is the same everywhere — which
+// strings did we ask for, which strings came back — so it lives here rather than
+// being retyped per manifest, where each copy is a chance to split on the wrong
+// character or forget to filter the empty string.
+//
+// SPACE SEPARATED IN, ARRAY OUT. OAuth scope strings are space separated by
+// RFC 6749 §3.3, and both halves are tolerated as arrays because a vendor SDK may
+// already have parsed one.
+//
+// AN EMPTY ANSWER IS NOT THE SAME AS AN UNKNOWN ONE. A caller with no grant
+// string has learned nothing and must not read "nothing missing" from that — so
+// an absent `granted` answers null, and only a grant we actually read answers a
+// list. Getting this wrong reports every connection healthy the moment a read
+// fails, which is the silent direction.
+const list = ( value ) => (
+	Array.isArray( value )
+		? value.flatMap( ( entry ) => String( entry ).split( /\s+/ ) )
+		: String( value ?? '' ).split( /\s+/ )
+).map( ( entry ) => entry.trim() ).filter( Boolean );
+
+const missingScopes = ({ granted, required }) => {
+
+	if( granted === null || granted === undefined || granted === '' ) return null;
+
+	const held = new Set( list( granted ) );
+
+	return list( required ).filter( ( scope ) => ! held.has( scope ) );
+
+};
+
 const api$1 = async ( path, { fetcher = fetch, method = 'GET', payload, token } ) => {
 
 	const response = await fetcher( 'https://a.klaviyo.com/api' + path, {
@@ -3531,22 +3571,59 @@ const api$1 = async ( path, { fetcher = fetch, method = 'GET', payload, token }
 
 // The segment's name at Klaviyo, spelled once. It is a LABEL — the definition
 // below keys on the id — so a rename never has to touch a profile.
-const segmentName = ( title ) => 'Drawbridge: ' + title;
-
-// THE GRANT THIS NEEDS. Klaviyo's scopes are set on the app and a token carries
-// only what the merchant consented to, so a connection made before segments were
-// asked for holds one that cannot write a segment — Create, Update and Delete
-// Segment each list `segments:write`
-// (raw.githubusercontent.com/klaviyo/openapi/main/openapi/stable.json, revision
-// 2026-07-15, fetched 2026-09-11). Answering 403 three times tells the merchant
-// nothing; this does.
 //
-// `scope` is the grant Klaviyo returned on the exchange, which its OAuth guide
-// describes as "The scopes that this access token has access to for accessing
-// API resources" (developers.klaviyo.com/en/docs/set_up_oauth, fetched
-// 2026-09-11) — not the list this manifest asks for, which is why a connection
-// older than the ask reads as false rather than true.
-const canManageSegments = ( settings ) => String( settings?.scope || '' ).split( /\s+/ ).includes( 'segments:write' );
+// THE ID IS IN THE NAME BECAUSE THE NAME IS NOT AN IDENTITY. Keyed on title
+// alone, a second segment called "VIP" found the first one's Klaviyo segment by
+// name and adopted it: both rows then pointed at one segment whose definition
+// computes the FIRST one's membership, so the merchant sent to the wrong people,
+// and deleting either segment deleted that object out from under the other with
+// nothing to repair it.
+//
+// The api now carries a unique index on (organization, title) and a 409 on both
+// create and rename, so that pair can no longer be created. The suffix stays
+// anyway: it is what makes the damage impossible rather than merely unlikely,
+// and it is the only part of this that holds if a title ever reaches Klaviyo
+// from somewhere that did not go through the route.
+//
+// KLAVIYO IS NOT DOING THIS FOR US. Create Segment describes `name` only as "A
+// helpful name to label the segment" and documents no uniqueness constraint and
+// no duplicate-name error (developers.klaviyo.com/en/reference/create_segment,
+// fetched 2026-09-12), so the search cannot lean on the vendor. What IS
+// documented is that filter comparisons are case-sensitive
+// (developers.klaviyo.com/en/docs/filtering_, same date), which is why the
+// find-by-name below re-checks with === and agrees with the vendor rather than
+// guessing.
+const segmentName = ( title, id ) => 'Drawbridge: ' + title + ' (' + String( id ).slice( -6 ) + ')';
+
+// `scope` on the stored settings is the grant Klaviyo RETURNED on the exchange,
+// which its OAuth guide describes as "The scopes that this access token has
+// access to for accessing API resources"
+// (developers.klaviyo.com/en/docs/set_up_oauth, fetched 2026-09-11) — not the
+// list this manifest asks for. That difference is the whole drift: a connection
+// older than the ask holds a narrower grant and nothing says so.
+//
+// THE SCOPES THIS APP ASKS FOR, named once. The consent url and the drift check
+// read the same constant, so a scope added to one is never missing from the
+// other — which is exactly how a grant ends up unable to do something nobody
+// noticed it could no longer do.
+//
+// Space separated. accounts:read is required by Klaviyo on every app; the rest
+// are what a contact sync and the segment hooks need — Get Segments lists
+// `segments:read`, and Create, Update and Delete Segment each list
+// `segments:write`
+// (raw.githubusercontent.com/klaviyo/openapi/main/openapi/stable.json, revision
+// 2026-07-15, fetched 2026-09-11).
+const SCOPES = 'accounts:read lists:read lists:write profiles:read profiles:write segments:read segments:write';
+
+// WHAT THIS GRANT CANNOT DO, through the shared comparison every vendor uses.
+// Answers null when there is no grant string to judge, which is not the same as
+// "nothing missing" — see lib/connections/scopes.js.
+const missing = ( settings ) => missingScopes({ granted : settings?.scope, required : SCOPES });
+
+// The register and remove hooks hard-skip on this rather than calling Klaviyo
+// and reading a 403 back. It asks the same question the drift check does, of the
+// same constant.
+const canManageSegments = ( settings ) => ! ( missing( settings ) || [] ).includes( 'segments:write' );
 
 // Klaviyo — contact sync, over OAuth.
 //
@@ -3611,7 +3688,7 @@ var klaviyo = {
 			// Update and Delete Segment each list `segments:write`
 			// (raw.githubusercontent.com/klaviyo/openapi/main/openapi/stable.json,
 			// revision 2026-07-15, fetched 2026-09-11).
-			scopes : 'accounts:read lists:read lists:write profiles:read profiles:write segments:read segments:write',
+			scopes : SCOPES,
 			// EVERY VENDOR URL, in one place. `revoke` used to be a literal inside
 			// the disconnect hook — three vendor addresses, two of them declared,
 			// which is exactly the kind of split that goes unnoticed.
@@ -3818,8 +3895,14 @@ var klaviyo = {
 
 			},
 
-			// Klaviyo scopes are fixed at app level and re-consented, not drifted.
-			scopes : false,
+			// THEY DO DRIFT, and the comment here used to say they could not. Klaviyo
+			// scopes are fixed on the APP, so adding one re-consents every NEW grant
+			// and leaves every EXISTING one exactly as narrow as it was — with no
+			// error, no webhook, and nothing that notices. That is what left grants
+			// authenticating perfectly while silently unable to manage a segment.
+			//
+			// The same slot Shopify answers, so one caller can ask any vendor.
+			scopes : ({ scope }) => missingScopes({ granted : scope, required : SCOPES }),
 
 			// KLAVIYO REQUIRES HTTP BASIC on the token endpoint and rejects the same
 			// client_id/client_secret pair as body fields. Everything else about the
@@ -4047,7 +4130,7 @@ var klaviyo = {
 
 				}
 
-				const name = segmentName( segment.title );
+				const name = segmentName( segment.title, segment.id );
 				const existing = segmentRowFor({ connection, segment });
 
 				let id = null;
@@ -4245,7 +4328,7 @@ var klaviyo = {
 			// The one call below proves the minted token is HONOURED — mint and
 			// acceptance are different facts, and /accounts is already the call
 			// the connect flow makes (auth.connect), so it needs no new scope.
-			health : async ( { connection, token }, { fetcher, read } = {} ) => {
+			health : async ( { connection, settings, token }, { fetcher, read } = {} ) => {
 
 				const request = { connectionId : connection.id };
 
@@ -4253,6 +4336,10 @@ var klaviyo = {
 
 					await api$1( '/accounts', { fetcher, token });
 
+					// SCOPE DRIFT IS NOT CHECKED HERE. The shell does it for every vendor
+					// after this step succeeds, by asking hooks.auth.scopes — see
+					// reconcileScopes in drawbridge-sync lib/step-runner.js. This hook
+					// answers only whether the token was minted and honoured.
 					return {
 						message : 'Health check passed — token minted and accepted.',
 						request,
@@ -4536,13 +4623,14 @@ var klaviyo = {
 		// discovers the second. The grant leads because reconnecting is the longer
 		// errand.
 		return [
-			// A connection made before segments were requested is authenticated and
-			// cannot manage them, and no error surfaces anywhere else — the register
-			// runs skip rather than fail.
-			...( canManageSegments( data?.settings ) ? [] : [ {
-				message : 'Drawbridge now keeps a Klaviyo segment in step with each of your Drawbridge segments. Reconnect Klaviyo to allow it.',
-				title : 'Reconnect Klaviyo'
-			} ] ),
+			// THE MISSING SEGMENT SCOPE IS NOT HERE ANY MORE. It is an ERROR entry,
+			// written by the health check, because a task is quiet: it renders only in
+			// the body of this connection's own page, so a merchant who never opens it
+			// never learns that their segments stopped being published. An error entry
+			// reaches the card and the organization checklist too.
+			//
+			// Deliberately not a status change — see the health hook for why that
+			// would stop the contact sync that still works.
 			...( data?.settings?.list ? [] : [ {
 				message : 'Choose which Klaviyo list your contacts should sync into. Until you do, nothing is being synced.',
 				title : 'Choose a list'
@@ -4657,13 +4745,29 @@ const subscriberHash = ( email ) => createHash( 'md5' )
 // server-side truncation is the worse outcome because register would then look
 // for a name Mailchimp had silently changed.
 //
-// ponytail: two segments whose first 88 characters match would share one tag.
-// The upgrade is to append a short hash of the segment id, which costs the name
-// its readability in the merchant's own audience — not worth it until somebody
-// actually collides.
+// THE SEGMENT ID IS IN THE NAME, and it has to be. Nothing makes a Drawbridge
+// segment title unique — no index on the collection, no check in the route, no
+// check in the form — so two segments called "VIP" are ordinary. Keyed on title
+// alone, the second one's register finds the first one's tag, adopts it, and
+// both rows point at one object: the merchant's two segments are one tag, and
+// deleting either segment deletes the tag out from under the other, leaving a
+// row pointing at an id that no longer exists and nothing to repair it.
+//
+// The last six characters of the id are enough to separate them and short
+// enough to leave the title readable in the merchant's own audience.
+//
+// A rename now changes the name and keeps the suffix, so register's find-by-name
+// still matches after one — and the truncation below cuts the TITLE rather than
+// the suffix for the same reason.
 const TAG_NAME_LIMIT = 100;
 
-const tagName = ( title ) => ( 'Drawbridge: ' + title ).slice( 0, TAG_NAME_LIMIT );
+const tagName = ( title, id ) => {
+
+	const suffix = ' (' + String( id ).slice( -6 ) + ')';
+
+	return ( 'Drawbridge: ' + title ).slice( 0, TAG_NAME_LIMIT - suffix.length ) + suffix;
+
+};
 
 // Mailchimp — contact sync, not a sender.
 var mailchimp = {
@@ -4958,19 +5062,21 @@ var mailchimp = {
 								}
 							},
 							{
-								$project : { _id : 0, title : 1 }
+								// THE ID AS WELL AS THE TITLE, because the tag name carries it —
+							// see tagName. Without it every name here would end in the
+							// string 'undefined' and match nothing register wrote.
+							$project : { _id : 0, id : 1, title : 1 }
 							}
 						]
 					});
 
-					const joined = new Set( segments.map( ( entry ) => entry.title ) );
+					const joined = new Set( segments.map( ( entry ) => entry.id ) );
 
 					const tags = ( owned || [] )
-						.map( ( entry ) => entry.title )
-						.filter( Boolean )
-						.map( ( title ) => ({
-							name : tagName( title ),
-							status : joined.has( title ) ? 'active' : 'inactive'
+						.filter( ( entry ) => entry.id && entry.title )
+						.map( ( entry ) => ({
+							name : tagName( entry.title, entry.id ),
+							status : joined.has( entry.id ) ? 'active' : 'inactive'
 						}) );
 
 					if( tags.length > 0 ){
@@ -5040,7 +5146,7 @@ var mailchimp = {
 
 				if( ! segment?.id || segment.system ) return { message : 'That segment is not one this connection publishes.', skipped : true };
 
-				const name = tagName( segment.title );
+				const name = tagName( segment.title, segment.id );
 				const existing = segmentRowFor({ connection, segment });
 
 				let id = null;
@@ -5768,23 +5874,33 @@ var shopify = {
 
 				const request = { email : context?.email || null, lead : context?.lead || null, shop : connection.shop };
 
+				// KEPT even though nothing below sends the address anywhere. A code
+				// that reaches nobody is a wasted action and a merchant's wasted
+				// allowance: issuing is only half a workflow, and the email step after
+				// it needs somewhere to send the code.
 				if( ! context?.email ) return { message : 'Lead email is missing.', request, response : { skipped : true }, skipped : true };
 				if( ! context?.lead ) return { message : 'Lead id is missing.', request, response : { skipped : true }, skipped : true };
 				if( ! discount?.id ) return { message : 'Discount is not configured on this step.', request, response : { skipped : true }, skipped : true };
 
 				const adminAccessToken = await adminToken();
 
-				// The customer must exist before a code is mapped to them. An earlier
-				// commerce.customer step usually did this and left the id on the
-				// context; when this step runs alone, it does it here.
-				if( ! context.shopifyCustomerId ){
-
-					const customer = await shopify.admin.getOrCreateCustomer({ adminAccessToken, domain : connection.shop, email : context.email });
-
-					if( ! customer?.id ) return { message : 'Shopify did not return a customer id — create/lookup failed.', request, response : { skipped : true }, skipped : true };
-
-				}
-
+				// NOTHING IS SENT TO SHOPIFY TO LINK THE CODE TO THE PERSON, because
+				// there is nothing to send: discountRedeemCodeBulkAdd takes a discount
+				// and a list of codes, and no customer
+				// (shopify.dev/docs/api/admin-graphql/2026-04/mutations/discountRedeemCodeBulkAdd).
+				// The link lives entirely on our side — `lead.shopifyDiscountCode`
+				// below — and attribution happens when the order comes back carrying
+				// the code, matched org-scoped against that field by commerce.order.
+				//
+				// This step used to call getOrCreateCustomer first, on the stated
+				// reasoning that "the customer must exist before a code is mapped to
+				// them". No code was ever mapped to them: the result was assigned and
+				// discarded, createDiscountCode never received it, and redemption
+				// attribution never consulted it. All it did was create a customer in
+				// the merchant's store as a side effect of issuing a discount — which
+				// QA reported as surprising, and was right to. A merchant who wants the
+				// buyer to exist at the store adds the Create customer step, which is
+				// what that step is for.
 				const discountCode = await shopify.admin.createDiscountCode({
 					adminAccessToken,
 					code : 'DB-' + generateDiscountCode(),