@brytdesigns/shopify-utils 1.2.21 → 3.0.0

package/dist/main/effect/Ajax/index.js

@@ -1,4 +1,2 @@
-export * from './Window/index.js';
-export * from './Sections/index.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+import "./Sections/index.js";
+import "./Window/index.js";

package/dist/main/effect/Logging/index.js

@@ -1,13 +1,2 @@
-import * as Effect from 'effect/Effect';
-import * as FiberRef from 'effect/FiberRef';
-import 'effect/LogLevel';
-
-const filterLevelOrNever = (level, effect) => Effect.gen(function* () {
-  const logLevel = yield* FiberRef.get(FiberRef.currentMinimumLogLevel);
-  if (logLevel._tag !== level._tag) return yield* effect;
-});
-const makeNamespacedLogSpan = (prefix) => (label) => Effect.withLogSpan(`${prefix}:${label}`);
-
-export { filterLevelOrNever, makeNamespacedLogSpan };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+import "effect/Effect";
+import "effect/References";

package/dist/main/effect/Resource/data.js

@@ -1,33 +1,23 @@
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-import * as ParseResult from 'effect/ParseResult';
-import { ID, Type, GID } from './schema.js';
-
-const format = ({
-  id,
-  type
-}) => Effect.gen(function* () {
-  const [actualId, actualType] = yield* Effect.all(
-    [Schema.decode(ID)(id), Schema.decode(Type)(type)],
-    {
-      concurrency: "unbounded"
-    }
-  );
-  return `gid://shopify/${actualType}/${actualId}`;
+import { GID, ID, Type } from "./schema.js";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as SchemaGetter from "effect/SchemaGetter";
+//#region src/effect/Resource/data.ts
+var format = ({ id, type }) => Effect.gen(function* () {
+	const [actualId, actualType] = yield* Effect.all([Schema.decodeEffect(ID)(id), Schema.decodeEffect(Type)(type)], { concurrency: "unbounded" });
+	return `gid://shopify/${actualType}/${actualId}`;
 });
-const parse = (input) => Schema.decode(
-  Schema.transformOrFail(GID, ID, {
-    encode: (value, _, ast) => ParseResult.fail(
-      new ParseResult.Forbidden(
-        ast,
-        value,
-        "Encoding an ID to a GID is not allowed. Use the format function to convert IDs to GIDs."
-      )
-    ),
-    decode: (value) => ParseResult.succeed(`${value}`.split("/").pop())
-  })
-)(input);
-
+/**
+* v4 replaces `Schema.transformOrFail` with `decodeTo` plus `SchemaGetter`
+* transformations. The decode direction never fails, so it is a plain
+* `transform`; the encode direction is refused outright, which `forbidden`
+* expresses directly rather than by constructing an issue by hand.
+*/
+var parse = (input) => Schema.decodeEffect(GID.pipe(Schema.decodeTo(ID, {
+	decode: SchemaGetter.transform((value) => `${value}`.split("/").pop()),
+	encode: SchemaGetter.forbidden(() => "Encoding an ID to a GID is not allowed. Use the format function to convert IDs to GIDs.")
+})))(input);
+//#endregion
 export { format, parse };
-//# sourceMappingURL=data.js.map
+
 //# sourceMappingURL=data.js.map

package/dist/main/effect/Resource/data.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/effect/Resource/data.ts"],"names":[],"mappings":";;;;;AAYO,MAAM,SAAS,CAA2C;AAAA,EAC/D,EAAA;AAAA,EACA;AACF,CAKE,KAAA,MAAA,CAAO,IAAI,aAAa;AACtB,EAAA,MAAM,CAAC,QAAA,EAAU,UAAU,CAAA,GAAI,OAAO,MAAO,CAAA,GAAA;AAAA,IAC3C,CAAC,MAAA,CAAO,MAAO,CAAA,EAAE,CAAE,CAAA,EAAE,CAAG,EAAA,MAAA,CAAO,MAAO,CAAA,IAAI,CAAE,CAAA,IAAI,CAAC,CAAA;AAAA,IACjD;AAAA,MACE,WAAa,EAAA;AAAA;AACf,GACF;AACA,EAAO,OAAA,CAAA,cAAA,EAAiB,UAAU,CAAA,CAAA,EAAI,QAAQ,CAAA,CAAA;AAChD,CAAC;AAEU,MAAA,KAAA,GAAQ,CAAC,KAAA,KACpB,MAAO,CAAA,MAAA;AAAA,EACL,MAAA,CAAO,eAAgB,CAAA,GAAA,EAAK,EAAI,EAAA;AAAA,IAC9B,MAAQ,EAAA,CAAC,KAAO,EAAA,CAAA,EAAG,QACjB,WAAY,CAAA,IAAA;AAAA,MACV,IAAI,WAAY,CAAA,SAAA;AAAA,QACd,GAAA;AAAA,QACA,KAAA;AAAA,QACA;AAAA;AACF,KACF;AAAA,IACF,MAAQ,EAAA,CAAC,KAAU,KAAA,WAAA,CAAY,OAAQ,CAAA,CAAA,EAAG,KAAK,CAAA,CAAA,CAAG,KAAM,CAAA,GAAG,CAAE,CAAA,GAAA,EAAM;AAAA,GACpE;AACH,CAAA,CAAE,KAAK","file":"data.js","sourcesContent":["import type { ParseError } from \"effect/ParseResult\";\n\nimport * as Effect from \"effect/Effect\";\nimport * as Schema from \"effect/Schema\";\nimport * as ParseResult from \"effect/ParseResult\";\nimport { ID, GID, Type } from \"./schema.js\";\n\ntype FormatOptions<T extends ID, R extends Type> = {\n  id: T;\n  type: R;\n};\n\nexport const format = <const T extends ID, const R extends Type>({\n  id,\n  type,\n}: FormatOptions<T, R>): Effect.Effect<\n  `gid://shopify/${R}/${T}`,\n  ParseError,\n  never\n> =>\n  Effect.gen(function* () {\n    const [actualId, actualType] = yield* Effect.all(\n      [Schema.decode(ID)(id), Schema.decode(Type)(type)],\n      {\n        concurrency: \"unbounded\",\n      },\n    );\n    return `gid://shopify/${actualType}/${actualId}` as `gid://shopify/${R}/${T}`;\n  });\n\nexport const parse = (input: string) =>\n  Schema.decode(\n    Schema.transformOrFail(GID, ID, {\n      encode: (value, _, ast) =>\n        ParseResult.fail(\n          new ParseResult.Forbidden(\n            ast,\n            value,\n            \"Encoding an ID to a GID is not allowed. Use the format function to convert IDs to GIDs.\",\n          ),\n        ),\n      decode: (value) => ParseResult.succeed(`${value}`.split(\"/\").pop()!),\n    }),\n  )(input);\n"]}
+{"version":3,"file":"data.js","names":[],"sources":["../../../../src/effect/Resource/data.ts"],"sourcesContent":["import * as Effect from \"effect/Effect\";\nimport * as Schema from \"effect/Schema\";\nimport * as SchemaGetter from \"effect/SchemaGetter\";\nimport { GID, ID, Type } from \"./schema.js\";\n\ntype FormatOptions<T extends ID, R extends Type> = {\n\tid: T;\n\ttype: R;\n};\n\nexport const format = <const T extends ID, const R extends Type>({\n\tid,\n\ttype,\n}: FormatOptions<T, R>) =>\n\tEffect.gen(function* () {\n\t\tconst [actualId, actualType] = yield* Effect.all(\n\t\t\t[Schema.decodeEffect(ID)(id), Schema.decodeEffect(Type)(type)],\n\t\t\t{\n\t\t\t\tconcurrency: \"unbounded\",\n\t\t\t},\n\t\t);\n\t\treturn `gid://shopify/${actualType}/${actualId}` as `gid://shopify/${R}/${T}`;\n\t});\n\n/**\n * v4 replaces `Schema.transformOrFail` with `decodeTo` plus `SchemaGetter`\n * transformations. The decode direction never fails, so it is a plain\n * `transform`; the encode direction is refused outright, which `forbidden`\n * expresses directly rather than by constructing an issue by hand.\n */\nexport const parse = (input: string) =>\n\tSchema.decodeEffect(\n\t\tGID.pipe(\n\t\t\tSchema.decodeTo(ID, {\n\t\t\t\tdecode: SchemaGetter.transform(\n\t\t\t\t\t(value: string) => `${value}`.split(\"/\").pop() as ID,\n\t\t\t\t),\n\t\t\t\tencode: SchemaGetter.forbidden(\n\t\t\t\t\t() =>\n\t\t\t\t\t\t\"Encoding an ID to a GID is not allowed. Use the format function to convert IDs to GIDs.\",\n\t\t\t\t),\n\t\t\t}),\n\t\t),\n\t)(input);\n"],"mappings":";;;;;AAUA,IAAa,UAAoD,EAChE,IACA,WAEA,OAAO,IAAI,aAAa;CACvB,MAAM,CAAC,UAAU,cAAc,OAAO,OAAO,IAC5C,CAAC,OAAO,aAAa,EAAE,CAAC,CAAC,EAAE,GAAG,OAAO,aAAa,IAAI,CAAC,CAAC,IAAI,CAAC,GAC7D,EACC,aAAa,YACd,CACD;CACA,OAAO,iBAAiB,WAAW,GAAG;AACvC,CAAC;;;;;;;AAQF,IAAa,SAAS,UACrB,OAAO,aACN,IAAI,KACH,OAAO,SAAS,IAAI;CACnB,QAAQ,aAAa,WACnB,UAAkB,GAAG,QAAQ,MAAM,GAAG,CAAC,CAAC,IAAI,CAC9C;CACA,QAAQ,aAAa,gBAEnB,yFACF;AACD,CAAC,CACF,CACD,CAAC,CAAC,KAAK"}

package/dist/main/effect/Resource/index.js

@@ -1,4 +1,3 @@
-export { GID, ID, Type } from './schema.js';
-export * from './data.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+import "./schema.js";
+import { format, parse } from "./data.js";
+export { format, parse };

package/dist/main/effect/Resource/schema.js

@@ -1,47 +1,47 @@
-import * as Schema from 'effect/Schema';
-
-const Type = Schema.Literal(
-  "Cart",
-  "Collection",
-  "Customer",
-  "DeliveryCarrierService",
-  "DeliveryLocationGroup",
-  "DeliveryProfile",
-  "DeliveryZone",
-  "DraftOrder",
-  "DraftOrderLineItem",
-  "Duty",
-  "EmailTemplate",
-  "Fulfillment",
-  "FulfullmentEvent",
-  "FullfullmentService",
-  "InventoryItem",
-  "InventoryLevel",
-  "LineItem",
-  "Location",
-  "MarketingEvent",
-  "MediaImage",
-  "Metafield",
-  "OnlineStoreArticle",
-  "OnlineStoreBlog",
-  "OnlineStorePage",
-  "Order",
-  "OrderTransaction",
-  "Product",
-  "ProductImage",
-  "ProductVariant",
-  "Refund",
-  "Shop",
-  "StaffMember",
-  "Theme"
-);
-const GID = Schema.String.pipe(Schema.startsWith("gid://shopify/"));
-const ID = Schema.Union(
-  Schema.Number,
-  Schema.NumberFromString,
-  Schema.String
-);
-
+import * as Schema from "effect/Schema";
+//#region src/effect/Resource/schema.ts
+var Type = Schema.Literals([
+	"Cart",
+	"Collection",
+	"Customer",
+	"DeliveryCarrierService",
+	"DeliveryLocationGroup",
+	"DeliveryProfile",
+	"DeliveryZone",
+	"DraftOrder",
+	"DraftOrderLineItem",
+	"Duty",
+	"EmailTemplate",
+	"Fulfillment",
+	"FulfullmentEvent",
+	"FullfullmentService",
+	"InventoryItem",
+	"InventoryLevel",
+	"LineItem",
+	"Location",
+	"MarketingEvent",
+	"MediaImage",
+	"Metafield",
+	"OnlineStoreArticle",
+	"OnlineStoreBlog",
+	"OnlineStorePage",
+	"Order",
+	"OrderTransaction",
+	"Product",
+	"ProductImage",
+	"ProductVariant",
+	"Refund",
+	"Shop",
+	"StaffMember",
+	"Theme"
+]);
+var GID = Schema.String.check(Schema.isStartingWith("gid://shopify/"));
+var ID = Schema.Union([
+	Schema.Number,
+	Schema.NumberFromString,
+	Schema.String
+]);
+//#endregion
 export { GID, ID, Type };
-//# sourceMappingURL=schema.js.map
+
 //# sourceMappingURL=schema.js.map

package/dist/main/effect/Resource/schema.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/effect/Resource/schema.ts"],"names":[],"mappings":";;AAGO,MAAM,OAAO,MAAO,CAAA,OAAA;AAAA,EACzB,MAAA;AAAA,EACA,YAAA;AAAA,EACA,UAAA;AAAA,EACA,wBAAA;AAAA,EACA,uBAAA;AAAA,EACA,iBAAA;AAAA,EACA,cAAA;AAAA,EACA,YAAA;AAAA,EACA,oBAAA;AAAA,EACA,MAAA;AAAA,EACA,eAAA;AAAA,EACA,aAAA;AAAA,EACA,kBAAA;AAAA,EACA,qBAAA;AAAA,EACA,eAAA;AAAA,EACA,gBAAA;AAAA,EACA,UAAA;AAAA,EACA,UAAA;AAAA,EACA,gBAAA;AAAA,EACA,YAAA;AAAA,EACA,WAAA;AAAA,EACA,oBAAA;AAAA,EACA,iBAAA;AAAA,EACA,iBAAA;AAAA,EACA,OAAA;AAAA,EACA,kBAAA;AAAA,EACA,SAAA;AAAA,EACA,cAAA;AAAA,EACA,gBAAA;AAAA,EACA,QAAA;AAAA,EACA,MAAA;AAAA,EACA,aAAA;AAAA,EACA;AACF;AAGO,MAAM,MAAM,MAAO,CAAA,MAAA,CAAO,KAAK,MAAO,CAAA,UAAA,CAAW,gBAAgB,CAAC;AAGlE,MAAM,KAAK,MAAO,CAAA,KAAA;AAAA,EACvB,MAAO,CAAA,MAAA;AAAA,EACP,MAAO,CAAA,gBAAA;AAAA,EACP,MAAO,CAAA;AACT","file":"schema.js","sourcesContent":["import * as Schema from \"effect/Schema\";\n\nexport type Type = Schema.Schema.Type<typeof Type>;\nexport const Type = Schema.Literal(\n  \"Cart\",\n  \"Collection\",\n  \"Customer\",\n  \"DeliveryCarrierService\",\n  \"DeliveryLocationGroup\",\n  \"DeliveryProfile\",\n  \"DeliveryZone\",\n  \"DraftOrder\",\n  \"DraftOrderLineItem\",\n  \"Duty\",\n  \"EmailTemplate\",\n  \"Fulfillment\",\n  \"FulfullmentEvent\",\n  \"FullfullmentService\",\n  \"InventoryItem\",\n  \"InventoryLevel\",\n  \"LineItem\",\n  \"Location\",\n  \"MarketingEvent\",\n  \"MediaImage\",\n  \"Metafield\",\n  \"OnlineStoreArticle\",\n  \"OnlineStoreBlog\",\n  \"OnlineStorePage\",\n  \"Order\",\n  \"OrderTransaction\",\n  \"Product\",\n  \"ProductImage\",\n  \"ProductVariant\",\n  \"Refund\",\n  \"Shop\",\n  \"StaffMember\",\n  \"Theme\",\n);\n\nexport type GID = Schema.Schema.Encoded<typeof GID>;\nexport const GID = Schema.String.pipe(Schema.startsWith(\"gid://shopify/\"));\n\nexport type ID = Schema.Schema.Encoded<typeof ID>;\nexport const ID = Schema.Union(\n  Schema.Number,\n  Schema.NumberFromString,\n  Schema.String,\n);\n"]}
+{"version":3,"file":"schema.js","names":[],"sources":["../../../../src/effect/Resource/schema.ts"],"sourcesContent":["import * as Schema from \"effect/Schema\";\n\nexport type Type = Schema.Schema.Type<typeof Type>;\nexport const Type = Schema.Literals([\n\t\"Cart\",\n\t\"Collection\",\n\t\"Customer\",\n\t\"DeliveryCarrierService\",\n\t\"DeliveryLocationGroup\",\n\t\"DeliveryProfile\",\n\t\"DeliveryZone\",\n\t\"DraftOrder\",\n\t\"DraftOrderLineItem\",\n\t\"Duty\",\n\t\"EmailTemplate\",\n\t\"Fulfillment\",\n\t\"FulfullmentEvent\",\n\t\"FullfullmentService\",\n\t\"InventoryItem\",\n\t\"InventoryLevel\",\n\t\"LineItem\",\n\t\"Location\",\n\t\"MarketingEvent\",\n\t\"MediaImage\",\n\t\"Metafield\",\n\t\"OnlineStoreArticle\",\n\t\"OnlineStoreBlog\",\n\t\"OnlineStorePage\",\n\t\"Order\",\n\t\"OrderTransaction\",\n\t\"Product\",\n\t\"ProductImage\",\n\t\"ProductVariant\",\n\t\"Refund\",\n\t\"Shop\",\n\t\"StaffMember\",\n\t\"Theme\",\n]);\n\nexport type GID = Schema.Codec.Encoded<typeof GID>;\nexport const GID = Schema.String.check(Schema.isStartingWith(\"gid://shopify/\"));\n\nexport type ID = Schema.Codec.Encoded<typeof ID>;\nexport const ID = Schema.Union([\n\tSchema.Number,\n\tSchema.NumberFromString,\n\tSchema.String,\n]);\n"],"mappings":";;AAGA,IAAa,OAAO,OAAO,SAAS;CACnC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACD,CAAC;AAGD,IAAa,MAAM,OAAO,OAAO,MAAM,OAAO,eAAe,gBAAgB,CAAC;AAG9E,IAAa,KAAK,OAAO,MAAM;CAC9B,OAAO;CACP,OAAO;CACP,OAAO;AACR,CAAC"}

package/dist/main/effect/index.js

@@ -1,8 +1,4 @@
-import * as index_js$2 from './Resource/index.js';
-export { index_js$2 as Resource };
-import * as index_js from './Ajax/index.js';
-export { index_js as Ajax };
-import * as index_js$1 from './Logging/index.js';
-export { index_js$1 as Logging };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+import "./Actions/index.js";
+import "./Ajax/index.js";
+import "./Logging/index.js";
+import "./Resource/index.js";

package/dist/main/index.d.ts

@@ -1,12 +1,311 @@
 // Generated by dts-bundle-generator v9.5.1
 
+import * as Cause from 'effect/Cause';
+import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 import * as LogLevel from 'effect/LogLevel';
-import { ParseError } from 'effect/ParseResult';
 import * as Schema from 'effect/Schema';
+import * as Scope from 'effect/Scope';
 
+declare const toAsyncCallback: <Args extends ReadonlyArray<unknown>, A, E, R>(services: Context.Context<R>, f: (...args: Args) => Effect.Effect<A, E, R>) => (...args: Args) => Promise<A>;
+declare const toSyncCallback: <Args extends ReadonlyArray<unknown>, A, R>(services: Context.Context<R>, f: (...args: Args) => Effect.Effect<A, never, R>, onAbnormal: (cause: Cause.Cause<never>) => A) => (...args: Args) => A;
+declare const fromPromiseThunk: <A, E>(thunk: () => Promise<A>, onReject: (cause: unknown) => E) => Effect.Effect<A, E>;
+/** Every action exposed on `window.Shopify.actions`. */
+export type ActionName = "getCart" | "updateCart" | "openCart";
+/**
+ * Only `updateCart` and `openCart` are `ActionFunction`s — `getCart` is a bare
+ * callable with no `configure()` / `isDefault()`.
+ */
+export type ConfigurableActionName = Exclude<ActionName, "getCart">;
+declare const ActionsUnavailableError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{
+	readonly [P in keyof A as P extends "_tag" ? never : P]: A[P];
+}>) => import("effect/Cause").YieldableError & {
+	readonly _tag: "@brytdesigns/shopify-utils/ActionsUnavailableError";
+} & Readonly<A>;
+declare class ActionsUnavailableError extends ActionsUnavailableError_base<{
+	readonly action: ActionName;
+	readonly message: string;
+}> {
+	constructor(options: {
+		readonly action: ActionName;
+	});
+}
+declare const ActionConfigurationRejectedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{
+	readonly [P in keyof A as P extends "_tag" ? never : P]: A[P];
+}>) => import("effect/Cause").YieldableError & {
+	readonly _tag: "@brytdesigns/shopify-utils/ActionConfigurationRejectedError";
+} & Readonly<A>;
+declare class ActionConfigurationRejectedError extends ActionConfigurationRejectedError_base<{
+	readonly action: ConfigurableActionName;
+	readonly message: string;
+}> {
+	constructor(options: {
+		readonly action: ConfigurableActionName;
+	});
+}
+declare const ActionInvocationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{
+	readonly [P in keyof A as P extends "_tag" ? never : P]: A[P];
+}>) => import("effect/Cause").YieldableError & {
+	readonly _tag: "@brytdesigns/shopify-utils/ActionInvocationError";
+} & Readonly<A>;
+declare class ActionInvocationError extends ActionInvocationError_base<{
+	readonly action: ActionName;
+	readonly cause: unknown;
+	readonly message: string;
+}> {
+	constructor(options: {
+		readonly action: ActionName;
+		readonly cause: unknown;
+	});
+}
+// -----------------------------------------------------------------------------
+// VENDORED FILE — DO NOT EDIT BY HAND.
+//
+// Source:    https://cdn.shopify.com/storefront/standard-actions.d.ts
+// Vendored:  2026-08-13
+// Upstream version (see `// version:` line below): 977e4f914dd2b3eca85ad01dee81c2c96eb1b2e5
+// sha256 (upstream body only, i.e. everything below this header):
+//            2f0fc044f35999cd09550b8b68620077601d1409817edae16745e600417788e7
+//
+// Everything below this header is the upstream file byte-for-byte. To diff
+// against a future revision:
+//
+//   curl -sSL https://cdn.shopify.com/storefront/standard-actions.d.ts \
+//     | diff - <(tail -n +25 shopify/utils/src/types/standard-actions.d.ts)
+//
+// There is NO npm package for this. Shopify injects the runtime on every Liquid
+// storefront as `window.Shopify.actions`; a module build for import maps lives
+// at https://cdn.shopify.com/storefront/standard-actions.js. Do not add a
+// dependency — import types via the `@theme/standard-actions` alias
+// (see tsconfig.json `paths`), which is marked `external` in tsup.config.ts.
+//
+// This file is excluded from Biome in the root biome.json so formatting/lint
+// never rewrites upstream content and pollutes the diff.
+// -----------------------------------------------------------------------------
+// version: 977e4f914dd2b3eca85ad01dee81c2c96eb1b2e5
+export interface Price {
+	amount: string;
+	currencyCode: string;
+}
+export interface CartDiscountCode {
+	applicable: boolean;
+	code: string;
+}
+export interface CartCost {
+	totalAmount: Price;
+}
+export interface CartLine {
+	id: string;
+	quantity: number;
+	cost: CartCost;
+}
+export interface CartMutationUserError {
+	code?: string;
+	field?: string[];
+	message: string;
+}
+export interface CartMutationWarning {
+	code?: string;
+	message: string;
+	target?: string;
+}
+declare const CART_UPDATE_CONTEXTS: readonly [
+	"product",
+	"cart",
+	"dialog",
+	"standard-action"
+];
+export type CartUpdateContext = (typeof CART_UPDATE_CONTEXTS)[number];
+declare const CART_UPDATE_ACTIONS: readonly [
+	"add",
+	"remove",
+	"update"
+];
+export type CartUpdateAction = (typeof CART_UPDATE_ACTIONS)[number];
+export type ActionArgs<P, O = void> = [
+	P
+] extends [
+	void
+] ? [
+	options?: O
+] : [
+	Extract<P, void>
+] extends [
+	never
+] ? [
+	payload: P,
+	options?: O
+] : [
+	payload?: Exclude<P, void>,
+	options?: O
+];
+export type UpdateCartUserError = CartMutationUserError;
+export type UpdateCartWarning = CartMutationWarning;
+export interface CartAttributeInput {
+	key: string;
+	value: string;
+}
+export interface StorefrontCartLinesConnection {
+	nodes: CartLine[];
+}
+export interface StorefrontCartSummary {
+	id: string;
+	totalQuantity: number;
+	cost: CartCost;
+	lines: StorefrontCartLinesConnection;
+	discountCodes: CartDiscountCode[];
+}
+export type UpdateCartEventTargetMeta = {
+	type: "shopify:cart:lines-update";
+	action: CartUpdateAction;
+} | {
+	type: "shopify:cart:note-update" | "shopify:cart:attributes-update" | "shopify:cart:discount-update" | "shopify:cart:error";
+};
+export interface CartLineInput {
+	/**
+	 * Existing-line id from SFAPI or the AJAX cart API.
+	 * CartLine GIDs keep or receive a `?cart=` suffix automatically when the cart id is known.
+	 * Present = update/remove; absent = add.
+	 */
+	id?: string;
+	/** ProductVariant GID or raw variant id. Required for add. */
+	merchandiseId?: string;
+	/** Set to 0 to remove. */
+	quantity: number;
+	/** Line item-level custom attributes */
+	attributes?: CartAttributeInput[];
+	/** Selling plan GID or raw selling plan id. */
+	sellingPlanId?: string;
+}
+export interface UpdateCartPayload {
+	/** Cart GID or raw cart token. If omitted, discovered from the cart cookie. */
+	cartId?: string;
+	lines?: CartLineInput[];
+	note?: string;
+	discountCodes?: string[];
+	/** Cart-level custom attributes */
+	attributes?: CartAttributeInput[];
+}
+export interface UpdateCartResult {
+	cart: StorefrontCartSummary;
+	userErrors?: UpdateCartUserError[];
+	warnings?: UpdateCartWarning[];
+	detail?: Record<string, any>;
+}
+export interface UpdateCartOptions {
+	signal?: AbortSignal;
+	event?: {
+		detail?: Record<string, any>;
+		context?: CartUpdateContext;
+	};
+}
+export interface GetCartPayload {
+	/** Cart GID or raw cart token. If omitted, discovered from the browser cookie. */
+	cartId?: string;
+}
+export interface GetCartResult {
+	cart: StorefrontCartSummary | null;
+	detail?: Record<string, any>;
+}
+export interface GetCartOptions {
+	signal?: AbortSignal;
+}
+/**
+ * The default handler, lifted into Effect-land.
+ *
+ * Handlers receive this rather than a pre-computed result so they keep the full
+ * range of the upstream contract: run the default, wrap it, retry it, race it,
+ * or skip it entirely and synthesise a result.
+ */
+export type DefaultHandler<A> = Effect.Effect<A, ActionInvocationError>;
+/**
+ * An action handler written in Effect.
+ *
+ * The returned Effect's success value is what the action resolves with, and its
+ * failure becomes a rejected promise for Shopify.
+ *
+ * Note that `E` is checked but never surfaces to the fiber that called
+ * `configure` — the handler runs long afterwards, when a shopper triggers the
+ * action, so its failure has nowhere to go but the promise Shopify awaits. If
+ * you want handler failures observed, observe them inside the handler.
+ */
+export type Handler<P, A, O, E, R> = (defaultHandler: DefaultHandler<A>, ...args: ActionArgs<P, O>) => Effect.Effect<A, E, R>;
+/**
+ * Resolves the element that `shopify:cart:*` events are dispatched from.
+ *
+ * The error channel is `never` on purpose. Shopify calls this synchronously and
+ * uses the return value immediately, so there is nowhere for a failure to go —
+ * handle errors inside the Effect and fall back to an element or `null`.
+ *
+ * For the same reason this Effect must complete synchronously. Anything that
+ * suspends (`Effect.sleep`, an HTTP call, an async service) cannot produce a
+ * value in time and is reported as `null` with a logged defect, which makes
+ * Shopify dispatch on `document`. If you need async work, resolve it ahead of
+ * time into a `Ref` and read the `Ref` here.
+ */
+export type EventTargetResolver<R> = (meta: UpdateCartEventTargetMeta) => Effect.Effect<EventTarget | null, never, R>;
+export interface UpdateCartConfiguration<E, R> {
+	readonly eventTarget: EventTargetResolver<R>;
+	/** Optional: routing events without changing cart behaviour is valid. */
+	readonly handler?: Handler<UpdateCartPayload, UpdateCartResult, UpdateCartOptions, E, R>;
+}
+export interface OpenCartConfiguration<E, R> {
+	/**
+	 * Required, unlike `updateCart`'s. `openCart` has no event target, so a
+	 * configuration without a handler would claim the one-shot upstream slot
+	 * while contributing nothing — locking everyone else out for the life of
+	 * the page in exchange for default behaviour.
+	 */
+	readonly handler: Handler<void, void, void, E, R>;
+}
+export interface ShopifyStorefrontActionsImpl {
+	/**
+	 * Read the current cart. `getCart` is a bare callable upstream — it has no
+	 * `configure()`, so there is no `configureGetCart`.
+	 */
+	readonly getCart: (payload?: GetCartPayload, options?: GetCartOptions) => Effect.Effect<GetCartResult, ActionsUnavailableError | ActionInvocationError>;
+	readonly updateCart: (payload: UpdateCartPayload, options?: UpdateCartOptions) => Effect.Effect<UpdateCartResult, ActionsUnavailableError | ActionInvocationError>;
+	readonly openCart: Effect.Effect<void, ActionsUnavailableError | ActionInvocationError>;
+	/**
+	 * Install an Effect-based `updateCart` configuration for the lifetime of the
+	 * enclosing `Scope`.
+	 *
+	 * The `R` of the supplied Effects flows out into the returned Effect's
+	 * requirements, so the services your handler needs stay explicit and must be
+	 * provided before this runs — they are captured, not smuggled.
+	 *
+	 * Calling this more than once rebinds rather than failing: we claim the
+	 * upstream slot once and swap our own configuration behind it. A
+	 * `ActionConfigurationRejectedError` therefore means one specific thing —
+	 * something outside this library claimed the action first.
+	 *
+	 * For page-lifetime registration, build it into a layer with
+	 * `Layer.effectDiscard(Actions.configureUpdateCart({ ... }))` so the
+	 * registration lives exactly as long as the runtime does.
+	 */
+	readonly configureUpdateCart: <E, R>(config: UpdateCartConfiguration<E, R>) => Effect.Effect<void, ActionsUnavailableError | ActionConfigurationRejectedError, R | Scope.Scope>;
+	readonly configureOpenCart: <E, R>(config: OpenCartConfiguration<E, R>) => Effect.Effect<void, ActionsUnavailableError | ActionConfigurationRejectedError, R | Scope.Scope>;
+	/**
+	 * Upstream's own notion: `true` until the action's slot is claimed.
+	 *
+	 * Because the slot can never be released, this stays `false` once we have
+	 * claimed it, even after every configuration has been deactivated.
+	 */
+	readonly isDefault: (action: ConfigurableActionName) => Effect.Effect<boolean, ActionsUnavailableError>;
+}
+declare const ShopifyStorefrontActions_base: Context.ServiceClass<ShopifyStorefrontActions, "@brytdesigns/shopify-utils/ShopifyStorefrontActions", ShopifyStorefrontActionsImpl>;
+declare class ShopifyStorefrontActions extends ShopifyStorefrontActions_base {
+}
+declare const layer: Layer.Layer<ShopifyStorefrontActions, never, never>;
+declare const getCart: (payload?: GetCartPayload, options?: GetCartOptions) => Effect.Effect<GetCartResult, ActionsUnavailableError | ActionInvocationError, ShopifyStorefrontActions>;
+declare const updateCart: (payload: UpdateCartPayload, options?: UpdateCartOptions) => Effect.Effect<UpdateCartResult, ActionsUnavailableError | ActionInvocationError, ShopifyStorefrontActions>;
+declare const openCart: Effect.Effect<void, ActionsUnavailableError | ActionInvocationError, ShopifyStorefrontActions>;
+declare const configureUpdateCart: <E, R>(config: UpdateCartConfiguration<E, R>) => Effect.Effect<void, ActionsUnavailableError | ActionConfigurationRejectedError, Scope.Scope | ShopifyStorefrontActions | R>;
+declare const configureOpenCart: <E, R>(config: OpenCartConfiguration<E, R>) => Effect.Effect<void, ActionsUnavailableError | ActionConfigurationRejectedError, Scope.Scope | ShopifyStorefrontActions | R>;
+declare const isDefault: (action: ConfigurableActionName) => Effect.Effect<boolean, ActionsUnavailableError, ShopifyStorefrontActions>;
 export type Type = Schema.Schema.Type<typeof Type>;
-declare const Type: Schema.Literal<[
+declare const Type: Schema.Literals<readonly [
 	"Cart",
 	"Collection",
 	"Customer",
@@ -41,20 +340,54 @@ declare const Type: Schema.Literal<[
 	"StaffMember",
 	"Theme"
 ]>;
-export type GID = Schema.Schema.Encoded<typeof GID>;
-declare const GID: Schema.filter<typeof Schema.String>;
-export type ID = Schema.Schema.Encoded<typeof ID>;
-declare const ID: Schema.Union<[
-	typeof Schema.Number,
-	typeof Schema.NumberFromString,
-	typeof Schema.String
+export type GID = Schema.Codec.Encoded<typeof GID>;
+declare const GID: Schema.String;
+export type ID = Schema.Codec.Encoded<typeof ID>;
+declare const ID: Schema.Union<readonly [
+	Schema.Number,
+	Schema.NumberFromString,
+	Schema.String
 ]>;
 export type FormatOptions<T extends ID, R extends Type> = {
 	id: T;
 	type: R;
 };
-declare const format: <const T extends ID, const R extends Type>({ id, type, }: FormatOptions<T, R>) => Effect.Effect<`gid://shopify/${R}/${T}`, ParseError, never>;
-declare const parse: (input: string) => Effect.Effect<string | number, ParseError, never>;
+declare const format: <const T extends ID, const R extends Type>({ id, type, }: FormatOptions<T, R>) => Effect.Effect<`gid://shopify/${R}/${T}`, Schema.SchemaError, never>;
+declare const parse: (input: string) => Effect.Effect<string | number, Schema.SchemaError, never>;
+/**
+ * Promise-based access to Shopify's storefront cart actions, for consumers that
+ * are not written in Effect.
+ *
+ * This is a facade over `./effect`'s `Actions`, not a reimplementation, so it
+ * inherits the behaviour that matters: the one-shot upstream `configure()` slot
+ * is claimed once and rebound thereafter, a missing runtime is distinguishable
+ * from a refused configuration, and a configuration can be torn down.
+ *
+ * Errors arrive as rejections carrying the same tagged error instances the
+ * Effect API fails with, so `instanceof ActionsUnavailableError` still works.
+ */
+export type Dispose = () => Promise<void>;
+export type UpdateCartHandler = (defaultHandler: () => Promise<UpdateCartResult>, payload: UpdateCartPayload, options?: UpdateCartOptions) => Promise<UpdateCartResult>;
+export type OpenCartHandler = (defaultHandler: () => Promise<void>) => Promise<void>;
+interface UpdateCartConfiguration$1 {
+	/**
+	 * Chooses the element `shopify:cart:*` events dispatch from. Returning
+	 * `null` — the default — leaves Shopify dispatching on `document`.
+	 *
+	 * Must be synchronous: Shopify uses the return value immediately.
+	 */
+	readonly eventTarget?: (meta: UpdateCartEventTargetMeta) => EventTarget | null;
+	readonly handler?: UpdateCartHandler;
+}
+interface OpenCartConfiguration$1 {
+	readonly handler: OpenCartHandler;
+}
+declare const getCart$1: (payload?: GetCartPayload, options?: GetCartOptions) => Promise<GetCartResult>;
+declare const updateCart$1: (payload: UpdateCartPayload, options?: UpdateCartOptions) => Promise<UpdateCartResult>;
+declare const openCart$1: () => Promise<void>;
+declare const isDefault$1: (action: ConfigurableActionName) => Promise<boolean>;
+declare const configureUpdateCart$1: (config?: UpdateCartConfiguration$1) => Promise<Dispose>;
+declare const configureOpenCart$1: (config: OpenCartConfiguration$1) => Promise<Dispose>;
 export declare const parseResource: (gid: Resource.GID) => string | number;
 export type FormatResourceOptions<T extends Resource.ID, R extends Resource.Type> = {
 	id: T;
@@ -65,11 +398,18 @@ type ID$1 = Resource.ID;
 type GID$1 = Resource.GID;
 type Type$1 = Resource.Type;
 
+declare namespace Bridge {
+	export { fromPromiseThunk, toAsyncCallback, toSyncCallback };
+}
 declare namespace Resource {
 	export { GID, ID, Type, format, parse };
 }
+declare namespace Actions {
+	export { ActionConfigurationRejectedError, ActionInvocationError, ActionName, ActionsUnavailableError, ConfigurableActionName, Dispose, GetCartOptions, GetCartPayload, GetCartResult, OpenCartConfiguration$1 as OpenCartConfiguration, OpenCartHandler, UpdateCartConfiguration$1 as UpdateCartConfiguration, UpdateCartEventTargetMeta, UpdateCartHandler, UpdateCartOptions, UpdateCartPayload, UpdateCartResult, configureOpenCart$1 as configureOpenCart, configureUpdateCart$1 as configureUpdateCart, getCart$1 as getCart, isDefault$1 as isDefault, openCart$1 as openCart, updateCart$1 as updateCart };
+}
 
 export {
+	Actions,
 	GID$1 as GID,
 	ID$1 as ID,
 	Type$1 as Type,

package/dist/main/index.js

@@ -1,3 +1,3 @@
-export { formatResource, parseResource } from './resources/index.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+import { actions_exports } from "./actions.js";
+import { formatResource, parseResource } from "./resources/index.js";
+export { actions_exports as Actions, formatResource, parseResource };

package/dist/main/resources/index.js

@@ -1,9 +1,10 @@
-import * as Effect from 'effect/Effect';
-import { Resource } from '../effect';
-
-const parseResource = (gid) => Effect.runSync(Resource.parse(gid));
-const formatResource = (options) => Effect.runSync(Resource.format(options));
-
+import { format, parse } from "../effect/Resource/data.js";
+import "../effect/index.js";
+import * as Effect from "effect/Effect";
+//#region src/resources/index.ts
+var parseResource = (gid) => Effect.runSync(parse(gid));
+var formatResource = (options) => Effect.runSync(format(options));
+//#endregion
 export { formatResource, parseResource };
-//# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map