@gradial/aci 0.1.23 → 0.1.25

package/README.md

@@ -1,6 +1,6 @@
 # Agentic Content Infrastructure SDK
 
-`@gradial/aci` `0.1.23` is a pre-1.0 public-surface reset for the ACI
+`@gradial/aci` `0.1.21` is a pre-1.0 public-surface reset for the ACI
 client SDK. Breaking changes from the old `0.1.x` accidental surface are
 intentional: the root import is framework-neutral, framework runtime behavior is
 behind explicit subpaths, and the first required customer path is React/Next.
@@ -8,7 +8,7 @@ behind explicit subpaths, and the first required customer path is React/Next.
 ## Install
 
 ```bash
-npm install @gradial/aci@0.1.23 zod@^4
+npm install @gradial/aci@0.1.21 zod@^4
 ```
 
 ## Root Import
@@ -68,13 +68,13 @@ go through an app-owned HTTP endpoint backed server-side by a `ContentProvider`.
 The first RC scaffold path is Next:
 
 ```bash
-npx @gradial/aci@0.1.23 init my-site --template next-starter
+npx @gradial/aci@0.1.21 init my-site --template next-starter
 ```
 
 List available templates:
 
 ```bash
-npx @gradial/aci@0.1.23 init --list
+npx @gradial/aci@0.1.21 init --list
 ```
 
 ## Verify Locally

package/dist/audience-data-models.d.ts

@@ -0,0 +1,406 @@
+import { z } from 'zod';
+export declare const segmentDataModel: import("./index.js").DataModelContract<z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        enabled: "enabled";
+        disabled: "disabled";
+    }>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, "segment">;
+export declare const audienceDataModel: import("./index.js").DataModelContract<z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        enabled: "enabled";
+        disabled: "disabled";
+    }>;
+    priority: z.ZodNumber;
+    membershipSource: z.ZodEnum<{
+        segment: "segment";
+        rule: "rule";
+        manual: "manual";
+        external: "external";
+        none: "none";
+    }>;
+    ruleRef: z.ZodOptional<z.ZodString>;
+    segmentRef: z.ZodOptional<z.ZodString>;
+    providerRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, "audience">;
+export declare const audienceRuleDataModel: import("./index.js").DataModelContract<z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        enabled: "enabled";
+        disabled: "disabled";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    expression: z.ZodObject<{
+        all: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                equals: "equals";
+                contains: "contains";
+                startsWith: "startsWith";
+                exists: "exists";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>>>;
+        any: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                equals: "equals";
+                contains: "contains";
+                startsWith: "startsWith";
+                exists: "exists";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, "audience_rule">;
+export declare const visitorProfileDataModel: import("./index.js").DataModelContract<z.ZodObject<{
+    visitorId: z.ZodString;
+    audienceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    segmentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    traits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, "visitor_profile">;
+export declare const goalDataModel: import("./index.js").DataModelContract<z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        enabled: "enabled";
+        disabled: "disabled";
+    }>;
+    eventName: z.ZodString;
+    eventRule: z.ZodOptional<z.ZodObject<{
+        all: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                equals: "equals";
+                contains: "contains";
+                startsWith: "startsWith";
+                exists: "exists";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>>>;
+        any: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                equals: "equals";
+                contains: "contains";
+                startsWith: "startsWith";
+                exists: "exists";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "goal">;
+export declare const experimentDataModel: import("./index.js").DataModelContract<z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        running: "running";
+        paused: "paused";
+        stopped: "stopped";
+        promoted: "promoted";
+        archived: "archived";
+    }>;
+    kind: z.ZodEnum<{
+        ab: "ab";
+        abn: "abn";
+        xt: "xt";
+    }>;
+    priority: z.ZodNumber;
+    allocationVersion: z.ZodOptional<z.ZodString>;
+    salt: z.ZodOptional<z.ZodString>;
+    scope: z.ZodObject<{
+        routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fragments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    primaryGoalRef: z.ZodOptional<z.ZodString>;
+    primaryGoalId: z.ZodOptional<z.ZodString>;
+    goalRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    goalIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    arms: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        displayName: z.ZodString;
+        role: z.ZodEnum<{
+            control: "control";
+            variant: "variant";
+        }>;
+        allocationBasisPoints: z.ZodOptional<z.ZodNumber>;
+        rule: z.ZodOptional<z.ZodObject<{
+            all: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    equals: "equals";
+                    contains: "contains";
+                    startsWith: "startsWith";
+                    exists: "exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strip>>>;
+            any: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    equals: "equals";
+                    contains: "contains";
+                    startsWith: "startsWith";
+                    exists: "exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "experiment">;
+export declare const experimentationDataModels: (import("./index.js").DataModelContract<z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        enabled: "enabled";
+        disabled: "disabled";
+    }>;
+    eventName: z.ZodString;
+    eventRule: z.ZodOptional<z.ZodObject<{
+        all: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                equals: "equals";
+                contains: "contains";
+                startsWith: "startsWith";
+                exists: "exists";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>>>;
+        any: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                equals: "equals";
+                contains: "contains";
+                startsWith: "startsWith";
+                exists: "exists";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "goal"> | import("./index.js").DataModelContract<z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        running: "running";
+        paused: "paused";
+        stopped: "stopped";
+        promoted: "promoted";
+        archived: "archived";
+    }>;
+    kind: z.ZodEnum<{
+        ab: "ab";
+        abn: "abn";
+        xt: "xt";
+    }>;
+    priority: z.ZodNumber;
+    allocationVersion: z.ZodOptional<z.ZodString>;
+    salt: z.ZodOptional<z.ZodString>;
+    scope: z.ZodObject<{
+        routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fragments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    primaryGoalRef: z.ZodOptional<z.ZodString>;
+    primaryGoalId: z.ZodOptional<z.ZodString>;
+    goalRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    goalIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    arms: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        displayName: z.ZodString;
+        role: z.ZodEnum<{
+            control: "control";
+            variant: "variant";
+        }>;
+        allocationBasisPoints: z.ZodOptional<z.ZodNumber>;
+        rule: z.ZodOptional<z.ZodObject<{
+            all: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    equals: "equals";
+                    contains: "contains";
+                    startsWith: "startsWith";
+                    exists: "exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strip>>>;
+            any: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    equals: "equals";
+                    contains: "contains";
+                    startsWith: "startsWith";
+                    exists: "exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "experiment">)[];
+export declare const audienceDataModels: (import("./index.js").DataModelContract<z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        enabled: "enabled";
+        disabled: "disabled";
+    }>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, "segment"> | import("./index.js").DataModelContract<z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        enabled: "enabled";
+        disabled: "disabled";
+    }>;
+    priority: z.ZodNumber;
+    membershipSource: z.ZodEnum<{
+        segment: "segment";
+        rule: "rule";
+        manual: "manual";
+        external: "external";
+        none: "none";
+    }>;
+    ruleRef: z.ZodOptional<z.ZodString>;
+    segmentRef: z.ZodOptional<z.ZodString>;
+    providerRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, "audience"> | import("./index.js").DataModelContract<z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        enabled: "enabled";
+        disabled: "disabled";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    expression: z.ZodObject<{
+        all: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                equals: "equals";
+                contains: "contains";
+                startsWith: "startsWith";
+                exists: "exists";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>>>;
+        any: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                equals: "equals";
+                contains: "contains";
+                startsWith: "startsWith";
+                exists: "exists";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, "audience_rule"> | import("./index.js").DataModelContract<z.ZodObject<{
+    visitorId: z.ZodString;
+    audienceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    segmentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    traits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, "visitor_profile"> | import("./index.js").DataModelContract<z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        enabled: "enabled";
+        disabled: "disabled";
+    }>;
+    eventName: z.ZodString;
+    eventRule: z.ZodOptional<z.ZodObject<{
+        all: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                equals: "equals";
+                contains: "contains";
+                startsWith: "startsWith";
+                exists: "exists";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>>>;
+        any: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                equals: "equals";
+                contains: "contains";
+                startsWith: "startsWith";
+                exists: "exists";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "goal"> | import("./index.js").DataModelContract<z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        running: "running";
+        paused: "paused";
+        stopped: "stopped";
+        promoted: "promoted";
+        archived: "archived";
+    }>;
+    kind: z.ZodEnum<{
+        ab: "ab";
+        abn: "abn";
+        xt: "xt";
+    }>;
+    priority: z.ZodNumber;
+    allocationVersion: z.ZodOptional<z.ZodString>;
+    salt: z.ZodOptional<z.ZodString>;
+    scope: z.ZodObject<{
+        routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fragments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    primaryGoalRef: z.ZodOptional<z.ZodString>;
+    primaryGoalId: z.ZodOptional<z.ZodString>;
+    goalRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    goalIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    arms: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        displayName: z.ZodString;
+        role: z.ZodEnum<{
+            control: "control";
+            variant: "variant";
+        }>;
+        allocationBasisPoints: z.ZodOptional<z.ZodNumber>;
+        rule: z.ZodOptional<z.ZodObject<{
+            all: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    equals: "equals";
+                    contains: "contains";
+                    startsWith: "startsWith";
+                    exists: "exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strip>>>;
+            any: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    equals: "equals";
+                    contains: "contains";
+                    startsWith: "startsWith";
+                    exists: "exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "experiment">)[];

package/dist/audience-data-models.js

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+import { defineDataModel } from './define-data-model.js';
+const resourceStatus = z.enum(['draft', 'enabled', 'disabled']);
+const experimentStatus = z.enum(['draft', 'running', 'paused', 'stopped', 'promoted', 'archived']);
+const experimentKind = z.enum(['ab', 'abn', 'xt']);
+const scalarValue = z.union([z.string(), z.number(), z.boolean()]);
+const requestRuleConditionSchema = z.object({
+    field: z.string().min(1),
+    operator: z.enum(['equals', 'contains', 'startsWith', 'exists']),
+    value: scalarValue.optional(),
+});
+const requestRuleExpressionSchema = z.object({
+    all: z.array(requestRuleConditionSchema).optional(),
+    any: z.array(requestRuleConditionSchema).optional(),
+});
+export const segmentDataModel = defineDataModel({
+    type: 'segment',
+    schema: z.object({
+        id: z.string().min(1),
+        displayName: z.string().min(1),
+        status: resourceStatus,
+        priority: z.number().int().nonnegative().optional(),
+        description: z.string().optional(),
+    }),
+});
+export const audienceDataModel = defineDataModel({
+    type: 'audience',
+    schema: z.object({
+        id: z.string().min(1),
+        displayName: z.string().min(1),
+        status: resourceStatus,
+        priority: z.number().int().nonnegative(),
+        membershipSource: z.enum(['rule', 'segment', 'manual', 'external', 'none']),
+        ruleRef: z.string().optional(),
+        segmentRef: z.string().optional(),
+        providerRef: z.string().optional(),
+    }),
+});
+export const audienceRuleDataModel = defineDataModel({
+    type: 'audience_rule',
+    schema: z.object({
+        id: z.string().min(1),
+        status: resourceStatus,
+        description: z.string().optional(),
+        expression: requestRuleExpressionSchema,
+    }),
+});
+export const visitorProfileDataModel = defineDataModel({
+    type: 'visitor_profile',
+    schema: z.object({
+        visitorId: z.string().min(1),
+        audienceIds: z.array(z.string().min(1)).optional(),
+        segmentIds: z.array(z.string().min(1)).optional(),
+        traits: z.record(z.string(), scalarValue).optional(),
+        updatedAt: z.string().optional(),
+    }),
+});
+export const goalDataModel = defineDataModel({
+    type: 'goal',
+    schema: z.object({
+        id: z.string().min(1),
+        displayName: z.string().min(1),
+        status: resourceStatus,
+        eventName: z.string().min(1),
+        eventRule: requestRuleExpressionSchema.optional(),
+    }),
+});
+export const experimentDataModel = defineDataModel({
+    type: 'experiment',
+    schema: z.object({
+        id: z.string().min(1),
+        displayName: z.string().min(1),
+        status: experimentStatus,
+        kind: experimentKind,
+        priority: z.number().int().nonnegative(),
+        allocationVersion: z.string().optional(),
+        salt: z.string().optional(),
+        scope: z.object({
+            routes: z.array(z.string().min(1)).optional(),
+            fragments: z.array(z.string().min(1)).optional(),
+        }),
+        primaryGoalRef: z.string().optional(),
+        primaryGoalId: z.string().optional(),
+        goalRefs: z.array(z.string().min(1)).optional(),
+        goalIds: z.array(z.string().min(1)).optional(),
+        arms: z.array(z.object({
+            id: z.string().min(1),
+            displayName: z.string().min(1),
+            role: z.enum(['control', 'variant']),
+            allocationBasisPoints: z.number().int().min(0).max(10000).optional(),
+            rule: requestRuleExpressionSchema.optional(),
+        })).min(1),
+    }),
+});
+export const experimentationDataModels = [
+    goalDataModel,
+    experimentDataModel,
+];
+export const audienceDataModels = [
+    segmentDataModel,
+    audienceDataModel,
+    audienceRuleDataModel,
+    visitorProfileDataModel,
+    ...experimentationDataModels,
+];

package/dist/block-ref.d.ts

@@ -27,8 +27,8 @@ export interface BlockRefOptions {
  */
 export declare function blockRef(options?: BlockRefOptions): z.ZodObject<{
     id: z.ZodString;
-    component: z.ZodEnum<{
+    component: z.ZodString | z.ZodEnum<{
         [x: string]: string;
-    }> | z.ZodString;
+    }>;
     props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>;

package/dist/content/assets.js

@@ -31,7 +31,7 @@ export async function getReleaseAssetResponse(input) {
     copyHeader(res.headers, headers, 'content-length');
     copyHeader(res.headers, headers, 'etag');
     copyHeader(res.headers, headers, 'last-modified');
-    headers.set('cache-control', 'public, max-age=31536000, immutable');
+    headers.set('cache-control', 'public, max-age=300, must-revalidate');
     return new Response(res.body, { status: 200, headers });
 }
 function cleanAssetPath(value) {

package/dist/index.d.ts

@@ -12,3 +12,6 @@ export type { Config, RouteConfig, ExternalDependency, DAMConfig, } from './type
 export type { Renderer, RenderCapabilities, RenderPageRequest, RenderPageResult, RequestContext, ReleaseContext, RenderFragmentRequest, RenderIslandRequest, RenderResult, IslandDescriptor, CachePolicy, GeoContext, } from './types/renderer.js';
 export type { Asset, } from './types/media.js';
 export { AssetSchema, isImage, isAsset, } from './types/media.js';
+export * from './audience-data-models.js';
+export * from './define-data-model.js';
+export * from './types/index.js';

package/dist/index.js

@@ -6,3 +6,9 @@ export { ImageSchema, imageAttrs, primaryImageSource, } from './types/image.js';
 export { LinkSchema, resolveLink, resolveHref, assertSafeHref, normalizeLinkRel, } from './types/link.js';
 export { HeadingSchema, InlineContentSchema, RichTextValueSchema, } from './types/rich-text.js';
 export { AssetSchema, isImage, isAsset, } from './types/media.js';
+export * from './audience-data-models.js';
+export * from './define-data-model.js';
+export * from './types/index.js';
+// Note: content/ is NOT re-exported here because it imports node:path,
+// making it incompatible with client-side bundlers. Import server-only
+// content utilities from '@gradial/aci/content' explicitly.

package/dist/next/asset-route.d.ts

@@ -2,7 +2,6 @@ type AssetRouteContext = {
     params: Promise<AssetRouteParams>;
 };
 type AssetRouteParams = {
-    releaseId?: string;
     path?: string[];
 };
 export declare const runtime = "nodejs";

package/dist/next/asset-route.js

@@ -1,21 +1,20 @@
 import { FileContentProvider } from '../providers/file.js';
-import { getReleaseAssetResponse } from '../content/assets.js';
-const LOCAL_RELEASE_ID = 'local';
+import { getReleaseAssetResponse, resolveReleaseId } from './server.js';
 export const runtime = 'nodejs';
 export const dynamic = 'force-dynamic';
 export async function GET(_request, { params }) {
     const resolvedParams = await params;
-    const releaseId = resolvedParams.releaseId || '';
     const assetPath = '/' + (resolvedParams.path || []).join('/');
-    if (!releaseId || assetPath === '/') {
+    if (assetPath === '/') {
         return new Response('asset not found', { status: 404 });
     }
-    if (releaseId === LOCAL_RELEASE_ID) {
+    if (process.env.ACI_CONTENT_PROVIDER === 'file') {
         const provider = new FileContentProvider();
         return provider.fetchRaw(assetPath);
     }
     try {
-        return await getReleaseAssetResponse({ releaseId, assetPath });
+        const releaseId = await resolveReleaseId();
+        return await getReleaseAssetResponse(releaseId, assetPath);
     }
     catch {
         return new Response('asset not found', { status: 404 });