@lowdefy/helpers 6.0.0 → 7.0.0

package/dist/appStorageKey.js

@@ -0,0 +1,20 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Browser storage is shared by every app on an origin, so each key Lowdefy writes names the app
+// it belongs to: its slug and the base path it is served under.
+function appStorageKey({ basePath, name, slug }) {
+    return `lowdefy:${slug ?? ''}:${basePath ?? ''}:${name}`;
+}
+export default appStorageKey;

package/dist/buildPagePath.js

@@ -0,0 +1,39 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import parsePathPattern from './parsePathPattern.js';
+import type from './type.js';
+// The URL path of a page, with no leading "/" and no basePath.
+function buildPagePath({ pageId, path, pathParams }) {
+    if (type.isUndefined(path)) {
+        return pageId;
+    }
+    const values = pathParams ?? {};
+    return parsePathPattern(path).map((segment)=>{
+        if (type.isString(segment.fixed)) {
+            return segment.fixed;
+        }
+        const value = values[segment.name];
+        if (type.isNone(value) || value === '') {
+            throw new Error(`Link to page "${pageId}" is missing a value for path placeholder "${segment.name}".`);
+        }
+        const text = String(value);
+        // The URL parser removes a "." or ".." segment, in any encoding, before the request is sent.
+        if (text === '.' || text === '..') {
+            throw new Error(`Link to page "${pageId}" has the value "${text}" for path placeholder "${segment.name}". A path value cannot be "." or "..".`);
+        }
+        return encodeURIComponent(text);
+    }).join('/');
+}
+export default buildPagePath;

package/dist/builtinMessages.js

@@ -21,15 +21,23 @@
     'client.requestError': 'Request error',
     'client.backAriaLabel': 'back',
     'client.shortcutThen': 'then',
+    'client.copy': 'Copy',
+    'client.copyValue': 'Copy: {value}',
+    'client.copied': 'Copied',
+    'client.copyFailed': 'Copy failed',
+    'client.confirm': 'Are you sure?',
     'errorPage.name': 'Error',
     'errorPage.message': 'An error has occurred.',
     'errorPage.homeLink': 'Return to home page',
+    'server.genericError': 'Something went wrong.',
     // Agent runtime — surfaces in browser as HTTP error responses / streamed errors
     'agent.runtime.methodNotAllowed': 'Only POST requests are supported.',
     'agent.runtime.invalidPath': 'Invalid agent path',
     'agent.runtime.messagesMustBeArray': 'messages must be an array',
     'agent.runtime.urlQueryMustBeObject': 'urlQuery must be an object',
+    'agent.runtime.pathParamsMustBeObject': 'pathParams must be an object',
     'agent.runtime.sharedStateMustBeObject': 'sharedState must be an object',
+    'agent.runtime.sharedStateReadOnlyMustBeBoolean': 'sharedStateReadOnly must be a boolean',
     'agent.runtime.agentNotFound': 'Agent "{agentId}" does not exist.',
     'agent.runtime.agentTypeNotFound': 'Agent type "{type}" can not be found.',
     'agent.runtime.toolExecutionFailed': 'Endpoint execution failed',

package/dist/callerHash.js

@@ -0,0 +1,28 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import stampHash from './stampHash.js';
+import type from './type.js';
+// A short fingerprint of the caller a response was answered as: the user id
+// and active organization together, so a switched organization reads as
+// another caller. Empty for an anonymous caller. It is the first part of the
+// caller stamp (see callerStamp), which the client compares with the caller it
+// renders.
+function callerHash({ user }) {
+    if (type.isNone(user)) {
+        return '';
+    }
+    return stampHash(`${user.id}:${user.organization_id ?? ''}`);
+}
+export default callerHash;

package/dist/callerStamp.js

@@ -0,0 +1,59 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import callerHash from './callerHash.js';
+import listHash from './listHash.js';
+import rolesHash from './rolesHash.js';
+import stampHash from './stampHash.js';
+import type from './type.js';
+// The x-lowdefy-caller header value: who the server answered a page, request
+// or endpoint call as, in full.
+//
+//   <caller>; session=<hash>; roles=<hash>; memberships=<hash>
+//
+// caller is callerHash (user and active organization), session the hash of the
+// session id, roles the hash of the caller's app roles and organization role
+// tier in the active organization (rolesHash), memberships the hash of the ids
+// of every organization the person is a member of (under a pinned app, of this
+// app's organization alone - see resolveAuthentication). An anonymous caller is
+// the empty string with no fields. A field the server does not know is left
+// out: session for a caller with no session (an API strategy, an injected dev
+// caller), memberships when the server did not read the person's member rows.
+// parseCallerStamp reads it back.
+//
+// authSession is the session the caller was resolved from, as
+// resolveAuthentication records it: { id, memberOrganizationIds }.
+function callerStamp({ user, authSession }) {
+    if (type.isNone(user)) {
+        return '';
+    }
+    const parts = [
+        callerHash({
+            user
+        })
+    ];
+    if (!type.isNone(authSession)) {
+        parts.push(`session=${stampHash(authSession.id)}`);
+    }
+    parts.push(`roles=${rolesHash({
+        user
+    })}`);
+    if (!type.isNone(authSession?.memberOrganizationIds)) {
+        parts.push(`memberships=${listHash({
+            values: authSession.memberOrganizationIds
+        })}`);
+    }
+    return parts.join('; ');
+}
+export default callerStamp;

package/dist/cleanBuildArtifact.js

@@ -0,0 +1,24 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import serializer from './serializer.js';
+// Build artifacts carry serializer markers (~k, ~r, ~l) and wrap location-marked
+// arrays as { '~arr': [...], '~k': '...' }. serializer.deserialize un-wraps
+// ~arr back to a plain array and demotes markers to non-enumerable properties;
+// the subsequent JSON round-trip drops those non-enumerable markers, leaving a
+// plain structure (e.g. a payloadSchema as plain JSON Schema).
+function cleanBuildArtifact(obj) {
+    return JSON.parse(JSON.stringify(serializer.deserialize(obj)));
+}
+export default cleanBuildArtifact;

package/dist/createTraceId.js

@@ -0,0 +1,35 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ const SUFFIX_LENGTH = 6;
+function pad(number, length = 2) {
+    return String(number).padStart(length, '0');
+}
+function randomSuffix() {
+    let suffix = '';
+    while(suffix.length < SUFFIX_LENGTH){
+        suffix += Math.floor(Math.random() * 36).toString(36);
+    }
+    return suffix;
+}
+// `<yyyymmdd>T<hhmmss>Z-<6 base36>` in UTC. Names a recorded tab session or a
+// test run; ids sort by time, and the date part picks the trace's date
+// directory, so a session that crosses midnight stays in one file.
+function createTraceId({ now } = {}) {
+    const date = new Date(now ?? Date.now());
+    const day = `${date.getUTCFullYear()}${pad(date.getUTCMonth() + 1)}${pad(date.getUTCDate())}`;
+    const time = `${pad(date.getUTCHours())}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}`;
+    return `${day}T${time}Z-${randomSuffix()}`;
+}
+export default createTraceId;

package/dist/extractErrorProps.js

@@ -46,8 +46,22 @@ function symbolMarker(val) {
 }
 const MAX_CAUSE_DEPTH = 3;
 const MAX_OBJECT_DEPTH = 5;
-const NO_OMIT = [];
-function cleanValue(val, seen, objectDepth, causeDepth, omit) {
+// Today's fields in today's order. The own `cause` key is skipped in the spread
+// so an assigned (and therefore enumerable) cause is not listed twice.
+function defaultProjection(err) {
+    const props = {
+        message: err.message,
+        name: err.name,
+        stack: err.stack,
+        cause: err.cause
+    };
+    for (const key of Object.keys(err)){
+        if (key === 'cause') continue;
+        props[key] = err[key];
+    }
+    return props;
+}
+function cleanValue(val, seen, objectDepth, causeDepth, project) {
     if (objectDepth > MAX_OBJECT_DEPTH) return '[Truncated]';
     if (typeof val === 'function') return functionMarker(val);
     if (typeof val === 'bigint') return bigintMarker(val);
@@ -56,81 +70,73 @@ function cleanValue(val, seen, objectDepth, causeDepth, omit) {
     if (seen.has(val)) return '[Circular]';
     seen.add(val);
     if (Array.isArray(val)) {
-        return val.map((item)=>cleanValue(item, seen, objectDepth + 1, causeDepth, omit));
+        return val.map((item)=>cleanValue(item, seen, objectDepth + 1, causeDepth, project));
     }
     if (val instanceof Date) return val;
-    if (val instanceof Error) return _extractErrorProps(val, seen, objectDepth, causeDepth, omit);
+    if (val instanceof Error) return _extractErrorProps(val, seen, objectDepth, causeDepth, project);
     if (!isPlainObject(val)) return classInstanceMarker(val);
     const cleaned = {};
     for (const [k, v] of Object.entries(val)){
-        const cv = cleanValue(v, seen, objectDepth + 1, causeDepth, omit);
+        const cv = cleanValue(v, seen, objectDepth + 1, causeDepth, project);
         if (cv !== undefined) cleaned[k] = cv;
     }
     return cleaned;
 }
-function _extractErrorProps(err, seen, objectDepth, causeDepth, omit) {
+function cleanCause(cause, seen, objectDepth, causeDepth, project) {
+    if (!(cause instanceof Error)) {
+        return cleanValue(cause, seen, objectDepth + 1, causeDepth, project);
+    }
+    if (seen.has(cause)) return '[Circular]';
+    if (causeDepth >= MAX_CAUSE_DEPTH) return '[Truncated]';
+    return _extractErrorProps(cause, seen, objectDepth, causeDepth + 1, project);
+}
+function cleanPropValue(value, seen, objectDepth, causeDepth, project) {
+    if (typeof value === 'function') return functionMarker(value);
+    if (typeof value === 'bigint') return bigintMarker(value);
+    if (typeof value === 'symbol') return symbolMarker(value);
+    if (value === null || typeof value !== 'object') return value;
+    if (value instanceof Date) return value;
+    if (Array.isArray(value)) return cleanValue(value, seen, objectDepth + 1, causeDepth, project);
+    if (value instanceof Error) {
+        if (seen.has(value)) return '[Circular]';
+        return _extractErrorProps(value, seen, objectDepth, causeDepth, project);
+    }
+    if (isPlainObject(value)) return cleanValue(value, seen, objectDepth + 1, causeDepth, project);
+    // A class instance (Socket, Agent, ClientRequest, ...). Its internals are never exposed —
+    // only the type name — but the key must not vanish: an absent key is indistinguishable
+    // from "no such field", and this output is now read by `get` as app-visible config data.
+    return classInstanceMarker(value);
+}
+function _extractErrorProps(err, seen, objectDepth, causeDepth, project) {
     if (!err) return err;
     seen.add(err);
     // Called at every error node rather than once for the walk, so a caller's
     // policy can key on the node itself - its class, or its own cause value.
     // Which fields an audience may see is the caller's decision, never this
-    // walk's; this function only applies the keys it is handed. Omitted fields
-    // are skipped before they are built, so a dropped cause is never deep-copied
-    // and never marked in `seen`.
-    const omitted = omit?.(err) ?? NO_OMIT;
+    // walk's; this function only cleans the entries it is handed. An entry the
+    // projection leaves out is never built, so a dropped cause is never
+    // deep-copied and never marked in `seen`.
+    const projected = (project ?? defaultProjection)(err);
     const props = {};
-    if (!omitted.includes('message')) props.message = err.message;
-    if (!omitted.includes('name')) props.name = err.name;
-    if (!omitted.includes('stack')) props.stack = err.stack;
-    if (err.cause !== undefined && !omitted.includes('cause')) {
-        if (!(err.cause instanceof Error)) {
-            props.cause = cleanValue(err.cause, seen, objectDepth + 1, causeDepth, omit);
-        } else if (seen.has(err.cause)) {
-            props.cause = '[Circular]';
-        } else if (causeDepth >= MAX_CAUSE_DEPTH) {
-            props.cause = '[Truncated]';
-        } else {
-            props.cause = _extractErrorProps(err.cause, seen, objectDepth, causeDepth + 1, omit);
-        }
-    }
-    for (const key of Object.keys(err)){
-        if (key === 'cause' || omitted.includes(key)) continue;
-        const value = err[key];
-        if (typeof value === 'function') {
-            props[key] = functionMarker(value);
-        } else if (typeof value === 'bigint') {
-            props[key] = bigintMarker(value);
-        } else if (typeof value === 'symbol') {
-            props[key] = symbolMarker(value);
-        } else if (value === null || typeof value !== 'object') {
-            props[key] = value;
-        } else if (value instanceof Date) {
-            props[key] = value;
-        } else if (Array.isArray(value)) {
-            props[key] = cleanValue(value, seen, objectDepth + 1, causeDepth, omit);
-        } else if (value instanceof Error) {
-            if (seen.has(value)) {
-                props[key] = '[Circular]';
-            } else {
-                props[key] = _extractErrorProps(value, seen, objectDepth, causeDepth, omit);
-            }
-        } else if (isPlainObject(value)) {
-            props[key] = cleanValue(value, seen, objectDepth + 1, causeDepth, omit);
+    for (const [key, value] of Object.entries(projected)){
+        if (value === undefined) continue;
+        if (key === 'cause') {
+            props.cause = cleanCause(value, seen, objectDepth, causeDepth, project);
         } else {
-            // A class instance (Socket, Agent, ClientRequest, ...). Its internals are never exposed —
-            // only the type name — but the key must not vanish: an absent key is indistinguishable
-            // from "no such field", and this output is now read by `get` as app-visible config data.
-            props[key] = classInstanceMarker(value);
+            props[key] = cleanPropValue(value, seen, objectDepth, causeDepth, project);
         }
     }
     return props;
 }
-// omit: (err) => string[] - the field names to leave off THIS error node, called
-// once per node. Returning 'message' or 'name' is legal but degrades the wire
-// format rather than just trimming it: serializer's propsToError revives a cause
-// as an Error only when it has a `message`, and looks the Lowdefy error class up
-// by `name`. Omit either and a round-trip yields plain objects.
-function extractErrorProps(err, { omit } = {}) {
-    return _extractErrorProps(err, new Set(), 0, 0, omit);
+// project: (err) => object - the props to emit for THIS error node, called once
+// per node. Entries are cleaned as own properties are: Errors recurse through
+// the same `project`, the returned `cause` is walked in place of the original,
+// and `undefined` entries are dropped. Returning neither `message` nor `name` is
+// legal but degrades the wire format rather than just trimming it: serializer's
+// propsToError revives a cause as an Error only when it has a `message`, and
+// looks the Lowdefy error class up by `name`. Leave either out and a round-trip
+// yields plain objects.
+function extractErrorProps(err, { project } = {}) {
+    return _extractErrorProps(err, new Set(), 0, 0, project);
 }
 export default extractErrorProps;

package/dist/filterElementsChain.js

@@ -0,0 +1,68 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import isChainHeaderEnd from './isChainHeaderEnd.js';
+import readChainValue from './readChainValue.js';
+import type from './type.js';
+// posthog-js escapes a quote in a value as \", and an existing \" the same way.
+function escapeValue(value) {
+    return value.replace(/"|\\"/g, '\\"');
+}
+// Rewrites the attributes of a posthog-js `$elements_chain`, read the way parseElementsChain
+// reads them. filterAttribute({ key, value }) is called for every `key="value"` pair (the
+// `text=` entries included) and returns the value to keep (the same string keeps the pair byte
+// for byte, another string replaces its value), or null to drop the pair. Tags, classes and
+// separators are left as they were. A malformed tail that parseElementsChain would stop at is
+// dropped, so nothing unread is sent on.
+function filterElementsChain({ chain, filterAttribute }) {
+    let output = '';
+    let index = 0;
+    while(index < chain.length){
+        let headerEnd = index;
+        while(headerEnd < chain.length && chain[headerEnd] !== ';' && !isChainHeaderEnd(chain, headerEnd)){
+            headerEnd += 1;
+        }
+        output += chain.slice(index, headerEnd);
+        if (chain[headerEnd] === ':') {
+            output += ':';
+            index = headerEnd + 1;
+            while(index < chain.length && chain[index] !== ';'){
+                const keyEnd = chain.indexOf('="', index);
+                if (keyEnd === -1) {
+                    return output;
+                }
+                const key = chain.slice(index, keyEnd);
+                const { value, end } = readChainValue(chain, keyEnd + 2);
+                const kept = filterAttribute({
+                    key,
+                    value
+                });
+                if (kept === value) {
+                    output += chain.slice(index, end);
+                } else if (type.isString(kept)) {
+                    output += `${key}="${escapeValue(kept)}"`;
+                }
+                index = end;
+            }
+        } else {
+            index = headerEnd;
+        }
+        if (index < chain.length) {
+            output += ';';
+        }
+        index += 1;
+    }
+    return output;
+}
+export default filterElementsChain;

package/dist/findInteractiveControls.js

@@ -0,0 +1,25 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import isInteractiveControl from './isInteractiveControl.js';
+import journeyTargetSelectors from './journeyTargetSelectors.js';
+const candidates = journeyTargetSelectors.interactiveControlRules.map(({ selector })=>selector).join(', ');
+// The interactive controls inside root, in document order, as
+// root.querySelectorAll(journeyTargetSelectors.interactiveControl) finds them.
+function findInteractiveControls(root) {
+    return [
+        ...root.querySelectorAll(candidates)
+    ].filter(isInteractiveControl);
+}
+export default findInteractiveControls;

package/dist/getSafeHref.js

@@ -0,0 +1,49 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import type from './type.js';
+// DOMPurify's default allowed URI schemes, so an href set as a block property
+// links exactly when the same URL would survive in sanitised HTML.
+const safeSchemes = new Set([
+    'callto',
+    'cid',
+    'ftp',
+    'ftps',
+    'http',
+    'https',
+    'mailto',
+    'matrix',
+    'sms',
+    'tel',
+    'xmpp'
+]);
+const schemePattern = /^([a-z][a-z0-9+.-]*):/i;
+// The browser's URL parser drops leading spaces and controls, and tabs and
+// newlines anywhere, before it reads the scheme. A value it would read
+// differently from how it is written is refused rather than normalised.
+const leadingSpacePattern = /^\s/;
+// eslint-disable-next-line no-control-regex
+const controlCharacterPattern = /[\u0000-\u001f\u007f]/;
+// The href a block renders, or undefined when the value must not become a link:
+// URLs with a scheme DOMPurify allows by default pass, as do relative paths,
+// query-only and fragment URLs. Any other scheme renders the element without an href.
+function getSafeHref(href) {
+    if (!type.isString(href) || href === '') return undefined;
+    if (leadingSpacePattern.test(href) || controlCharacterPattern.test(href)) return undefined;
+    const scheme = schemePattern.exec(href);
+    if (scheme === null) return href;
+    if (safeSchemes.has(scheme[1].toLowerCase())) return href;
+    return undefined;
+}
+export default getSafeHref;

package/dist/index.js

@@ -13,30 +13,55 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import applyArrayIndices from './applyArrayIndices.js';
+import appStorageKey from './appStorageKey.js';
 import builtinMessages from './builtinMessages.js';
+import buildPagePath from './buildPagePath.js';
 import cachedPromises from './cachedPromises.js';
+import callerHash from './callerHash.js';
+import callerStamp from './callerStamp.js';
+import cleanBuildArtifact from './cleanBuildArtifact.js';
+import createTraceId from './createTraceId.js';
 import extractErrorProps from './extractErrorProps.js';
+import filterElementsChain from './filterElementsChain.js';
+import findInteractiveControls from './findInteractiveControls.js';
 import get from './get.js';
 import getKey from './getKey.js';
 import getLocaleDateFormat from './getLocaleDateFormat.js';
 import getLocaleDecimalSeparator from './getLocaleDecimalSeparator.js';
 import getLocaleGroupSeparator from './getLocaleGroupSeparator.js';
 import getOperatorType from './getOperatorType.js';
+import getSafeHref from './getSafeHref.js';
+import isInteractiveControl from './isInteractiveControl.js';
+import isMountEventName from './isMountEventName.js';
+import isTraceId from './isTraceId.js';
 import { isReserved, ReservedKeyError } from './ReservedKeyError.js';
 import joinPath from './joinPath.js';
+import journeyTargetSelectors from './journeyTargetSelectors.js';
 import LRUCache from './LRUCache.js';
+import mapPlainValues from './mapPlainValues.js';
 import mergeObjects from './mergeObjects.js';
+import normalizeCaller from './normalizeCaller.js';
 import omit from './omit.js';
+import pageInstanceKey from './pageInstanceKey.js';
+import pairTraceEvents from './pairTraceEvents.js';
+import parseCallerStamp from './parseCallerStamp.js';
+import parsePageId from './parsePageId.js';
+import parsePathPattern from './parsePathPattern.js';
+import parseRowIndex from './parseRowIndex.js';
+import projectCaughtError from './projectCaughtError.js';
+import rolesHash from './rolesHash.js';
 import serializer from './serializer.js';
 import set from './set.js';
 import setKey from './setKey.js';
 import splitPath from './splitPath.js';
 import stableStringify from './stableStringify.js';
 import swap from './swap.js';
+import traceIdDate from './traceIdDate.js';
+import targetFromElementsChain from './targetFromElementsChain.js';
 import translate from './translate.js';
 import type from './type.js';
 import unset from './unset.js';
 import unsetKey from './unsetKey.js';
 import urlQuery from './urlQuery.js';
 import wait from './wait.js';
-export { applyArrayIndices, builtinMessages, cachedPromises, extractErrorProps, get, getKey, getLocaleDateFormat, getLocaleDecimalSeparator, getLocaleGroupSeparator, getOperatorType, isReserved, joinPath, LRUCache, mergeObjects, omit, ReservedKeyError, serializer, set, setKey, splitPath, stableStringify, swap, translate, type, unset, unsetKey, urlQuery, wait };
+export { applyArrayIndices, appStorageKey, buildPagePath, builtinMessages, cachedPromises, callerHash, callerStamp, cleanBuildArtifact, createTraceId, extractErrorProps, filterElementsChain, findInteractiveControls, get, getKey, getLocaleDateFormat, getLocaleDecimalSeparator, getLocaleGroupSeparator, getOperatorType, getSafeHref, isInteractiveControl, isMountEventName, isTraceId, isReserved, joinPath, journeyTargetSelectors, LRUCache, mapPlainValues, mergeObjects, normalizeCaller, omit, pageInstanceKey, pairTraceEvents, parseCallerStamp, parsePageId, parsePathPattern, parseRowIndex, projectCaughtError, ReservedKeyError, rolesHash, serializer, set, setKey, splitPath, stableStringify, swap, traceIdDate, targetFromElementsChain, translate, type, unset, unsetKey, urlQuery, wait };

package/dist/isChainHeaderEnd.js

@@ -0,0 +1,33 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Every entry's attributes start with one of these keys, since posthog-js sorts them and always
+// writes nth-child: the colon before one ends the tag and class part, which can itself hold a
+// colon (a Tailwind class like `md:flex`).
+const FIRST_ATTRIBUTE_PREFIXES = [
+    'attr_',
+    'href="',
+    'nth-child="'
+];
+function isChainHeaderEnd(chain, index) {
+    if (chain[index] !== ':') {
+        return false;
+    }
+    const next = index + 1;
+    if (next === chain.length || chain[next] === ';') {
+        return true;
+    }
+    return FIRST_ATTRIBUTE_PREFIXES.some((prefix)=>chain.startsWith(prefix, next));
+}
+export default isChainHeaderEnd;

package/dist/isInteractiveControl.js

@@ -0,0 +1,22 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import journeyTargetSelectors from './journeyTargetSelectors.js';
+// Whether an element is an interactive control in the journey runner's sense: it matches
+// journeyTargetSelectors.interactiveControl. Reads the rules one by one, so it also works in DOMs
+// that cannot parse the combined selector (jsdom).
+function isInteractiveControl(element) {
+    return journeyTargetSelectors.interactiveControlRules.some(({ selector, has, not = [] })=>element.matches(selector) && (!has || element.querySelector(has) !== null) && !not.some((excluded)=>element.matches(excluded)));
+}
+export default isInteractiveControl;