@storystick/media 0.0.0-stage → 0.2.0-rc.0

package/LICENSE

@@ -0,0 +1,112 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 Tanguy Freycon
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+This Agreement shall be governed by the laws of France.

package/PUBLIC-API.md

@@ -0,0 +1,19 @@
+# @storystick/media API contract
+
+Install this candidate explicitly with `@storystick/media@0.2.0-rc.0` after registry bootstrap and publication. This repository alone does not make the candidate or beta channel available on npm.
+
+Version 0.2.0-rc.0, cohort `sdk-0.2.0-rc.0`. ESM distribution; no CommonJS or universal Edge compatibility is promised.
+
+This package supports the integration facades; installing it directly is an advanced use. Reserved contracts are required between SDK packages and must be upgraded with the same cohort. Their public export paths do not promise independent stability.
+
+| Entry | Status |
+| --- | --- |
+| `.` | Supported beta entry |
+| `./video` | Supported beta entry |
+| `./internal/render-diagnostics` | Reserved SDK contract |
+
+The qualified toolchain is Node 24.19.0 and pnpm 9.15.9. Next uses App Router 15.5.28, Sharp 0.35.5 and React/React DOM 19.2.8; Astro uses 7.4.4 with the Node adapter 11.1.9. Browser delivery is verified by bundling; hosted Preview activation and cross-browser behavior require the staging manual check. Source/CLI are Node tools, server entries belong on the server, and browser entries must never receive a server API key.
+
+This is a support/tooling contract. It does not independently grant project access or permission to perform effects.
+
+The repository is private. Public package availability does not make the monorepo public, and npm provenance from that repository is unavailable. Product and pilot support: [Storystick](https://storystick.app).

package/README.md

@@ -1,3 +1,47 @@
-# Temporary Holding Version
+# @storystick/media
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Provider-agnostic helpers for rendering Storystick asset-backed media fields.
+
+## Render an image field
+
+SDK image values carry the asset metadata needed to render them. Resolve the
+value and spread its HTML props to preserve its Preview edit marker:
+
+```tsx
+import { resolveImage } from '@storystick/media'
+
+export function Hero({ image }) {
+  const { props } = resolveImage(image, { sizes: '100vw' })
+  return props ? <img {...props} /> : null
+}
+```
+
+The result includes a discriminated `status` and `props` (`null` when the image
+cannot render). Renderable images supply `src`, intrinsic dimensions, `alt`,
+lazy-loading defaults, responsive props, and the Preview edit marker. The
+resolver cleans text before writing the invisible `alt` attribute.
+
+For raw values, pass `resolveImage(image, { source: document })`. An explicit
+`source` replaces the value's metadata, including when it is `null` or
+`undefined`. It accepts an asset sidecar or a document carrying `_assets`.
+`resolveFile` and `resolveVideo` follow the same source and result conventions.
+
+Living documents resolve the asset's current ready version. Published
+documents resolve only the immutable version and render defaults captured in
+their snapshot sidecar; replacing an asset never rewrites an existing
+publication. A missing publish-time binding is reported as
+`unavailable-at-publication`, and a missing captured version as
+`pinned-version-missing`.
+
+One render can emit at most `IMAGE_RENDER_TRANSFORM_BUDGET` distinct keys: one
+primary transform plus one per canonical responsive-width bucket. Stored crop,
+hotspot, and asset focal-point values are resolved by `asset-grammar` into the
+same canonical crop for the primary URL and every `srcSet` candidate. A
+version-scoped metadata `lqip`, when present and non-empty, is exposed as
+`blurDataURL` on the resolved image.
+
+## Candidate distribution contract
+
+See [PUBLIC-API.md](./PUBLIC-API.md) for supported entries, reserved SDK contracts,
+the qualified runtime matrix and the candidate cohort. Upgrade Storystick
+packages together.

package/dist/file-field.generated.d.ts

@@ -0,0 +1,4 @@
+export interface StorystickFileFieldData {
+    /** File asset */
+    assetId?: string;
+}

package/dist/file-field.generated.js

@@ -0,0 +1,4 @@
+// Auto-generated from packages/core/stories/core/file.story.
+// Run `pnpm --filter @storystick/core generate:media-file-field` to update.
+// Do not edit by hand.
+export {};

package/dist/image-field.generated.d.ts

@@ -0,0 +1,32 @@
+export interface StorystickImageCrop {
+    /** Top */
+    top?: number;
+    /** Bottom */
+    bottom?: number;
+    /** Left */
+    left?: number;
+    /** Right */
+    right?: number;
+}
+export interface StorystickImageHotspot {
+    /** Horizontal center */
+    x?: number;
+    /** Vertical center */
+    y?: number;
+    /** Width */
+    width?: number;
+    /** Height */
+    height?: number;
+}
+export interface StorystickImageFieldData {
+    /** Image asset */
+    assetId?: string;
+    /** Alt text */
+    alt?: string;
+    /** Caption */
+    caption?: string;
+    /** Crop */
+    crop?: StorystickImageCrop;
+    /** Hotspot */
+    hotspot?: StorystickImageHotspot;
+}

package/dist/image-field.generated.js

@@ -0,0 +1,4 @@
+// Auto-generated from packages/core/stories/core/image.story, crop.story, and hotspot.story.
+// Run `pnpm --filter @storystick/core generate:media-image-field` to update.
+// Do not edit by hand.
+export {};

package/dist/index.d.ts

@@ -0,0 +1,121 @@
+import { type ImageDimensionBucket } from '@storystick/asset-grammar';
+import { type StorystickAsset, type StorystickAssetSidecar, type PreviewObjectMarkerAttrs, type PreviewObjectMarkerCarrier } from '@storystick/types';
+import type { StorystickFileFieldData } from './file-field.generated.js';
+import type { StorystickImageFieldData } from './image-field.generated.js';
+export type { StorystickImageCrop, StorystickImageHotspot, } from './image-field.generated.js';
+export type { StorystickAsset, StorystickAssetAltDefault, StorystickAssetDeliveryStatus, StorystickAssetMetadata, StorystickAssetSidecar, StorystickAssetType, } from '@storystick/types';
+export type StorystickImageField = StorystickImageFieldData & PreviewObjectMarkerCarrier;
+/** Canonical provider-neutral value emitted by a `type: file` Story field. */
+export type StorystickFileField = StorystickFileFieldData & PreviewObjectMarkerCarrier;
+export type StorystickImageFit = 'cover' | 'contain' | 'scale-down';
+export type StorystickImageFormat = 'auto' | 'webp' | 'avif' | 'jpeg' | 'png';
+export type StorystickImageQuality = 'low' | 'medium' | 'high';
+export type StorystickImageDpr = 1 | 1.5 | 2;
+export type StorystickImageTransformOptions = {
+    /** A canonical cache bucket. Round measured dimensions before passing them. */
+    width?: ImageDimensionBucket;
+    /** A canonical cache bucket. Round measured dimensions before passing them. */
+    height?: ImageDimensionBucket;
+    fit?: StorystickImageFit;
+    format?: StorystickImageFormat;
+    quality?: StorystickImageQuality;
+    dpr?: StorystickImageDpr;
+    widths?: readonly number[];
+    sizes?: string;
+};
+export type ResolveImageOptions = StorystickImageTransformOptions & {
+    source?: unknown;
+    warn?: (message: string) => void;
+};
+/** One primary transform plus at most one transform per canonical width bucket. */
+export declare const IMAGE_RENDER_TRANSFORM_BUDGET: number;
+/**
+ * De-facto responsive widths shared with framework image components. They are
+ * all canonical grammar buckets and are capped to the source asset width.
+ */
+export declare const DEFAULT_RESPONSIVE_IMAGE_WIDTHS: readonly [640, 750, 828, 1080, 1200, 1920, 2048, 3840];
+export type ImageStatus = 'ok' | 'no-image' | 'no-sidecar' | 'missing-asset' | 'unavailable-at-publication' | 'pinned-version-missing' | 'not-image' | 'archived-asset' | 'private-asset' | 'asset-not-ready' | 'provider-unconfigured' | 'invalid-dimensions' | 'invalid-transform';
+export type StorystickImageProps = {
+    src: string;
+    alt: string;
+    width: number;
+    height: number;
+    srcSet?: string;
+    sizes?: string;
+    loading: 'lazy';
+    decoding: 'async';
+    style?: {
+        objectPosition: string;
+    };
+} & PreviewObjectMarkerAttrs;
+export type ResolveFileOptions = {
+    source?: unknown;
+    warn?: (message: string) => void;
+};
+export type FileStatus = 'ok' | 'no-file' | 'no-sidecar' | 'missing-asset' | 'unavailable-at-publication' | 'pinned-version-missing' | 'not-file' | 'archived-asset' | 'private-asset' | 'asset-not-ready' | 'provider-unconfigured';
+export type StorystickFileProps = {
+    href: string;
+    download: string;
+    type?: string;
+} & PreviewObjectMarkerAttrs;
+type ResolvedStorystickFileOk = {
+    status: 'ok';
+    asset: StorystickAsset;
+    href: string;
+    filename: string;
+    mimeType?: string;
+    sizeBytes?: number;
+    props: StorystickFileProps;
+} & PreviewObjectMarkerAttrs;
+export type ResolvedStorystickFile = ResolvedStorystickFileOk | {
+    status: 'no-file';
+    assetId?: never;
+    asset?: never;
+    props: null;
+} | ({
+    status: 'no-sidecar' | 'missing-asset' | 'unavailable-at-publication' | 'pinned-version-missing';
+    assetId: string;
+    version?: number;
+    asset?: never;
+    props: null;
+} & PreviewObjectMarkerAttrs) | ({
+    status: 'not-file' | 'archived-asset' | 'private-asset' | 'asset-not-ready' | 'provider-unconfigured';
+    assetId: string;
+    asset: StorystickAsset;
+    props: null;
+} & PreviewObjectMarkerAttrs);
+type ResolvedStorystickImageOk = {
+    status: 'ok';
+    asset: StorystickAsset;
+    src: string;
+    srcSet?: string;
+    sizes?: string;
+    alt: string;
+    caption?: string;
+    width: number;
+    height: number;
+    transformKey: string;
+    blurDataURL?: string;
+    props: StorystickImageProps;
+} & PreviewObjectMarkerAttrs;
+export type ResolvedStorystickImage = ResolvedStorystickImageOk | {
+    status: 'no-image';
+    assetId?: never;
+    asset?: never;
+    props: null;
+} | {
+    status: 'no-sidecar' | 'missing-asset' | 'unavailable-at-publication' | 'pinned-version-missing';
+    assetId: string;
+    version?: number;
+    asset?: never;
+    props: null;
+} & PreviewObjectMarkerAttrs | {
+    status: 'not-image' | 'archived-asset' | 'private-asset' | 'asset-not-ready' | 'provider-unconfigured' | 'invalid-dimensions' | 'invalid-transform';
+    assetId: string;
+    asset: StorystickAsset;
+    props: null;
+} & PreviewObjectMarkerAttrs;
+export declare function resolveImage(image: StorystickImageField | null | undefined, options?: ResolveImageOptions): ResolvedStorystickImage;
+/** Resolve a provider-neutral File field to its canonical download surface. */
+export declare function resolveFile(file: StorystickFileField | null | undefined, options?: ResolveFileOptions): ResolvedStorystickFile;
+export declare function getAssetSidecar(source: unknown): StorystickAssetSidecar | undefined;

package/dist/index.js

@@ -0,0 +1,379 @@
+import { canDeliverSvgOriginal } from '@storystick/asset-grammar';
+import { buildUnsplashImageUrl } from '@storystick/asset-grammar/internal/unsplash';
+import { contentResolutionSource } from '@storystick/types/internal/content-origin';
+import { buildImageTransformKey, IMAGE_TRANSFORM_CARDINALITY, ImageTransformGrammarError, resolveImageFraming, roundUpImageDimensionBucket, } from '@storystick/asset-grammar';
+import { lookupStorystickAsset, isStorystickExternalImage, previewObjectMarkerAttrs, storystickAssetOriginalDownloadUrl, } from '@storystick/types';
+import { stripPreviewProvenanceTextMarkers } from '@storystick/types/preview-provenance';
+/** One primary transform plus at most one transform per canonical width bucket. */
+export const IMAGE_RENDER_TRANSFORM_BUDGET = Number(IMAGE_TRANSFORM_CARDINALITY.bucketCount) + 1;
+/**
+ * De-facto responsive widths shared with framework image components. They are
+ * all canonical grammar buckets and are capped to the source asset width.
+ */
+export const DEFAULT_RESPONSIVE_IMAGE_WIDTHS = [
+    640,
+    750,
+    828,
+    1080,
+    1200,
+    1920,
+    2048,
+    3840,
+];
+export function resolveImage(image, options = {}) {
+    options = { ...options, source: contentResolutionSource(image, options) };
+    if (!image || typeof image.assetId !== 'string' || image.assetId.length === 0) {
+        return { status: 'no-image', props: null };
+    }
+    const assetId = image.assetId;
+    const markerAttrs = previewObjectMarkerAttrs(image);
+    const lookup = lookupStorystickAsset(options.source, assetId);
+    if (lookup.status === 'no-sidecar') {
+        warn(options, `Storystick image asset "${assetId}" cannot resolve without an _assets sidecar.`);
+        return { ...markerAttrs, status: 'no-sidecar', assetId, props: null };
+    }
+    if (lookup.status !== 'ok') {
+        warn(options, failureMessage(assetId, lookup.status, 'failure' in lookup ? lookup.failure : undefined));
+        return {
+            ...markerAttrs,
+            status: lookup.status,
+            assetId,
+            ...('version' in lookup && lookup.version !== undefined
+                ? { version: lookup.version }
+                : {}),
+            props: null,
+        };
+    }
+    const asset = lookup.asset;
+    if (asset.assetType !== 'image') {
+        warn(options, `Storystick image asset "${assetId}" is not an image asset.`);
+        return { ...markerAttrs, status: 'not-image', assetId, asset, props: null };
+    }
+    if (asset.delivery.status !== 'ready' || !asset.delivery.baseUrl) {
+        const status = deliveryAssetStatus(asset.delivery.status);
+        warn(options, `Storystick image asset "${assetId}" is not renderable; delivery status is "${asset.delivery.status}".`);
+        return { ...markerAttrs, status, assetId, asset, props: null };
+    }
+    if (asset.externalImage !== undefined && (!isStorystickExternalImage(asset.externalImage) ||
+        !finitePositive(asset.width) || !Number.isInteger(asset.width) ||
+        !finitePositive(asset.height) || !Number.isInteger(asset.height))) {
+        warn(options, `Storystick image asset "${assetId}" has invalid external image material.`);
+        return { ...markerAttrs, status: 'asset-not-ready', assetId, asset, props: null };
+    }
+    const dimensions = resolveDimensions(asset, options);
+    if (!dimensions) {
+        warn(options, `Storystick image asset "${assetId}" is missing renderable dimensions.`);
+        return {
+            ...markerAttrs,
+            status: 'invalid-dimensions',
+            assetId,
+            asset,
+            props: null,
+        };
+    }
+    const framing = resolveImageFraming({
+        crop: image.crop,
+        hotspot: image.hotspot,
+        focalPoint: asset.focalPoint,
+        source: {
+            width: asset.width ?? Number.NaN,
+            height: asset.height ?? Number.NaN,
+        },
+        target: { width: options.width, height: options.height },
+    });
+    if (framing.wasClamped) {
+        warn(options, `Storystick image asset "${assetId}" has framing values outside [0, 1]; they were clamped for rendering.`);
+    }
+    let transformKey;
+    let src;
+    let srcSet;
+    try {
+        const transform = transformForOptions(options, framing.crop);
+        if (asset.mimeType === 'image/svg+xml' && !canDeliverSvgOriginal(transform, asset)) {
+            warn(options, `Storystick SVG asset "${assetId}" cannot be cropped or rasterized. Use its vector original or supply a raster asset.`);
+            return { ...markerAttrs, status: 'invalid-transform', assetId, asset, props: null };
+        }
+        transformKey = asset.mimeType === 'image/svg+xml' ? 'original' : buildImageTransformKey(transform);
+        src = asset.externalImage ? buildUnsplashImageUrl({ urls: asset.externalImage.urls, width: asset.width, height: asset.height }, transform) : transformUrl(asset.delivery.baseUrl, transformKey);
+        srcSet = asset.mimeType === 'image/svg+xml' ? undefined : buildSrcSet(asset.delivery.baseUrl, asset, options, framing.crop);
+    }
+    catch (error) {
+        if (!(error instanceof ImageTransformGrammarError))
+            throw error;
+        warn(options, `Storystick image asset "${assetId}" received an invalid transform (${error.code}). Use a canonical image dimension bucket.`);
+        return {
+            ...markerAttrs,
+            status: 'invalid-transform',
+            assetId,
+            asset,
+            props: null,
+        };
+    }
+    const blurDataURL = resolveBlurDataURL(asset);
+    const alt = stripPreviewProvenanceTextMarkers(resolveAlt(image, asset, options));
+    const caption = typeof image.caption === 'string' && image.caption.trim().length > 0
+        ? stripPreviewProvenanceTextMarkers(image.caption)
+        : undefined;
+    const fallbackObjectPosition = framing.crop === null && framing.fallbackPoint
+        ? `${unitPercent(framing.fallbackPoint.x)} ${unitPercent(framing.fallbackPoint.y)}`
+        : undefined;
+    const props = {
+        ...markerAttrs,
+        src,
+        alt,
+        width: dimensions.width,
+        height: dimensions.height,
+        ...(srcSet ? { srcSet } : {}),
+        ...(options.sizes ? { sizes: options.sizes } : {}),
+        loading: 'lazy',
+        decoding: 'async',
+        ...(fallbackObjectPosition
+            ? { style: { objectPosition: fallbackObjectPosition } }
+            : {}),
+    };
+    return {
+        ...markerAttrs,
+        status: 'ok',
+        asset,
+        src,
+        ...(srcSet ? { srcSet } : {}),
+        ...(options.sizes ? { sizes: options.sizes } : {}),
+        alt,
+        ...(caption ? { caption } : {}),
+        width: dimensions.width,
+        height: dimensions.height,
+        transformKey,
+        ...(blurDataURL ? { blurDataURL } : {}),
+        props,
+    };
+}
+function failureStatus(failure) {
+    if (failure?.reason === 'unavailable-at-publication') {
+        return 'unavailable-at-publication';
+    }
+    if (failure?.reason === 'pinned-version-missing') {
+        return 'pinned-version-missing';
+    }
+    return 'missing-asset';
+}
+function failureMessage(assetId, status, failure) {
+    if (status === 'unavailable-at-publication') {
+        return `Storystick image asset "${assetId}" was not ready when this publication was created.`;
+    }
+    if (status === 'pinned-version-missing') {
+        return `Storystick image asset "${assetId}" cannot resolve its pinned version${failure?.version !== undefined ? ` ${failure.version}` : ''}.`;
+    }
+    return `Storystick image asset "${assetId}" is missing from the _assets sidecar.`;
+}
+function deliveryAssetStatus(status) {
+    if (status === 'archived')
+        return 'archived-asset';
+    if (status === 'private-unsigned')
+        return 'private-asset';
+    if (status === 'provider-unconfigured')
+        return 'provider-unconfigured';
+    return 'asset-not-ready';
+}
+/** Resolve a provider-neutral File field to its canonical download surface. */
+export function resolveFile(file, options = {}) {
+    options = { ...options, source: contentResolutionSource(file, options) };
+    if (!file || typeof file.assetId !== 'string' || file.assetId.length === 0) {
+        return { status: 'no-file', props: null };
+    }
+    const assetId = file.assetId;
+    const markerAttrs = previewObjectMarkerAttrs(file);
+    const lookup = lookupStorystickAsset(options.source, assetId);
+    if (lookup.status === 'no-sidecar') {
+        warn(options, `Storystick file asset "${assetId}" cannot resolve without an _assets sidecar.`);
+        return { ...markerAttrs, status: 'no-sidecar', assetId, props: null };
+    }
+    if (lookup.status !== 'ok') {
+        warn(options, fileFailureMessage(assetId, lookup.status, 'failure' in lookup ? lookup.failure : undefined));
+        return {
+            ...markerAttrs,
+            status: lookup.status,
+            assetId,
+            ...('version' in lookup && lookup.version !== undefined
+                ? { version: lookup.version }
+                : {}),
+            props: null,
+        };
+    }
+    const asset = lookup.asset;
+    if (asset.assetType !== 'file') {
+        warn(options, `Storystick file asset "${assetId}" is not a file asset.`);
+        return { ...markerAttrs, status: 'not-file', assetId, asset, props: null };
+    }
+    if (asset.delivery.status !== 'ready' || !asset.delivery.baseUrl) {
+        const status = deliveryAssetStatus(asset.delivery.status);
+        warn(options, `Storystick file asset "${assetId}" is not downloadable; delivery status is "${asset.delivery.status}".`);
+        return { ...markerAttrs, status, assetId, asset, props: null };
+    }
+    const filename = stripPreviewProvenanceTextMarkers(asset.originalFilename ?? '').trim() ||
+        stripPreviewProvenanceTextMarkers(asset.displayName ?? '') || assetId;
+    const href = storystickAssetOriginalDownloadUrl(asset);
+    if (!href) {
+        return {
+            ...markerAttrs,
+            status: 'asset-not-ready',
+            assetId,
+            asset,
+            props: null,
+        };
+    }
+    const props = {
+        ...markerAttrs,
+        href,
+        download: filename,
+        ...(asset.mimeType ? { type: asset.mimeType } : {}),
+    };
+    return {
+        ...markerAttrs,
+        status: 'ok',
+        asset,
+        href,
+        filename,
+        ...(asset.mimeType ? { mimeType: asset.mimeType } : {}),
+        ...(asset.sizeBytes !== undefined ? { sizeBytes: asset.sizeBytes } : {}),
+        props,
+    };
+}
+export function getAssetSidecar(source) {
+    if (isAssetSidecar(source))
+        return source;
+    if (!isRecord(source))
+        return undefined;
+    return isAssetSidecar(source._assets) ? source._assets : undefined;
+}
+function resolveAlt(image, asset, options) {
+    if (typeof image.alt === 'string') {
+        if (image.alt.length === 0)
+            return '';
+        if (image.alt.trim().length > 0)
+            return image.alt;
+    }
+    if (asset.altDefault.state === 'text')
+        return asset.altDefault.text;
+    if (asset.altDefault.state === 'decorative')
+        return '';
+    warn(options, `Storystick image asset "${asset.assetId}" has no alt text.`);
+    return '';
+}
+function fileFailureMessage(assetId, status, failure) {
+    if (status === 'unavailable-at-publication') {
+        return `Storystick file asset "${assetId}" was not ready when this publication was created.`;
+    }
+    if (status === 'pinned-version-missing') {
+        return `Storystick file asset "${assetId}" cannot resolve its pinned version${failure?.version !== undefined ? ` ${failure.version}` : ''}.`;
+    }
+    return `Storystick file asset "${assetId}" is missing from the _assets sidecar.`;
+}
+function resolveDimensions(asset, options) {
+    const assetWidth = finitePositive(asset.width) ? asset.width : undefined;
+    const assetHeight = finitePositive(asset.height) ? asset.height : undefined;
+    const optionWidth = finitePositive(options.width) ? options.width : undefined;
+    const optionHeight = finitePositive(options.height) ? options.height : undefined;
+    if (optionWidth && optionHeight)
+        return { width: optionWidth, height: optionHeight };
+    if (optionWidth && assetWidth && assetHeight) {
+        return { width: optionWidth, height: Math.round((optionWidth * assetHeight) / assetWidth) };
+    }
+    if (optionHeight && assetWidth && assetHeight) {
+        return { width: Math.round((optionHeight * assetWidth) / assetHeight), height: optionHeight };
+    }
+    if (assetWidth && assetHeight)
+        return { width: assetWidth, height: assetHeight };
+    return null;
+}
+function finitePositive(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
+function unitPercent(value) {
+    return `${Number((value * 100).toFixed(4))}%`;
+}
+function isAssetSidecar(value) {
+    return isRecord(value) && isRecord(value.byId);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function buildSrcSet(baseUrl, asset, options, framingCrop) {
+    const requestedWidths = options.widths ??
+        (options.sizes ? DEFAULT_RESPONSIVE_IMAGE_WIDTHS : undefined);
+    const widths = normalizeSrcSetWidths(requestedWidths, asset.width);
+    if (widths.length === 0)
+        return undefined;
+    return widths
+        .map((width) => {
+        const transform = transformForOptions({ ...options, width, height: undefined, dpr: undefined }, framingCrop);
+        const transformKey = buildImageTransformKey(transform);
+        const url = asset.externalImage ? buildUnsplashImageUrl({ urls: asset.externalImage.urls, width: asset.width, height: asset.height }, transform) : transformUrl(baseUrl, transformKey);
+        return `${url} ${width}w`;
+    })
+        .join(', ');
+}
+function normalizeSrcSetWidths(widths, assetWidth) {
+    if (!widths || widths.length === 0)
+        return [];
+    const max = finitePositive(assetWidth) ? assetWidth : Infinity;
+    const unique = new Set();
+    for (const width of widths) {
+        const bucket = roundUpImageDimensionBucket(width);
+        if (bucket !== null && bucket <= max)
+            unique.add(bucket);
+    }
+    return [...unique].sort((a, b) => a - b);
+}
+function transformForOptions(options, framingCrop) {
+    const resize = options.width !== undefined || options.height !== undefined
+        ? {
+            width: options.width,
+            height: options.height,
+            fit: options.fit ?? (options.width !== undefined && options.height !== undefined ? 'cover' : 'scale-down'),
+        }
+        : undefined;
+    if (!resize &&
+        framingCrop === null &&
+        options.format === undefined &&
+        options.quality === undefined &&
+        options.dpr === undefined) {
+        return null;
+    }
+    return {
+        schemaVersion: 1,
+        ...(resize ? { resize } : {}),
+        ...(framingCrop
+            ? { focus: { mode: 'crop', crop: framingCrop } }
+            : {}),
+        ...(options.format !== undefined ? { format: options.format } : {}),
+        ...(options.quality !== undefined ? { quality: options.quality } : {}),
+        ...(options.dpr !== undefined ? { dpr: options.dpr } : {}),
+    };
+}
+function resolveBlurDataURL(asset) {
+    const lqip = asset.metadata?.lqip;
+    return typeof lqip === 'string' &&
+        lqip.length <= 1024 &&
+        /^data:image\/(?:avif|jpeg|png|webp);base64,[A-Za-z0-9+/]+={0,2}$/.test(lqip)
+        ? lqip
+        : undefined;
+}
+function transformUrl(baseUrl, transformKey) {
+    return `${baseUrl.replace(/\/+$/, '')}/${encodeURIComponent(transformKey)}`;
+}
+function warn(options, message) {
+    if (options.warn) {
+        options.warn(message);
+        return;
+    }
+    if (isProduction())
+        return;
+    if (typeof console !== 'undefined' && typeof console.warn === 'function') {
+        console.warn(message);
+    }
+}
+function isProduction() {
+    return (typeof process !== 'undefined' &&
+        typeof process.env === 'object' &&
+        process.env.NODE_ENV === 'production');
+}

package/dist/internal/render-diagnostics.d.ts

@@ -0,0 +1,3 @@
+/** Shared renderer diagnostics; not part of the public media API. */
+export declare function emitMediaDiagnostic(message: string, warn?: (message: string) => void): void;
+export declare function isProduction(): boolean;

package/dist/internal/render-diagnostics.js

@@ -0,0 +1,9 @@
+/** Shared renderer diagnostics; not part of the public media API. */
+export function emitMediaDiagnostic(message, warn) {
+    warn?.(message);
+    if (typeof console !== 'undefined' && typeof console.warn === 'function')
+        console.warn(message);
+}
+export function isProduction() {
+    return typeof process !== 'undefined' && typeof process.env === 'object' && process.env.NODE_ENV === 'production';
+}

package/dist/video-field.generated.d.ts

@@ -0,0 +1,22 @@
+export interface StorystickVideoTrackData {
+    /** WebVTT file */
+    assetId?: string;
+    /** Kind */
+    kind?: "captions" | "subtitles";
+    /** Language */
+    language?: string;
+    /** Label */
+    label?: string;
+    /** Default track */
+    default?: boolean;
+}
+export interface StorystickVideoFieldData {
+    /** Video asset */
+    assetId?: string;
+    /** Poster image */
+    posterAssetId?: string;
+    /** Text tracks */
+    tracks?: Array<StorystickVideoTrackData & {
+        _key: string;
+    }>;
+}

package/dist/video-field.generated.js

@@ -0,0 +1,4 @@
+// Auto-generated from packages/core/stories/core/video.story and videoTrack.story.
+// Run `pnpm --filter @storystick/core generate:media-video-field` to update.
+// Do not edit by hand.
+export {};

package/dist/video.d.ts

@@ -0,0 +1,117 @@
+import { isPlausibleBcp47LanguageTag, type PreviewObjectMarkerAttrs, type PreviewObjectMarkerCarrier, type StorystickAsset } from '@storystick/types';
+import type { StorystickVideoFieldData, StorystickVideoTrackData } from './video-field.generated.js';
+export { isPlausibleBcp47LanguageTag };
+export type StorystickVideoTrack = StorystickVideoTrackData & PreviewObjectMarkerCarrier;
+/** Canonical provider-neutral value emitted by a `type: video` Story field. */
+export type StorystickVideoField = Omit<StorystickVideoFieldData, 'tracks'> & PreviewObjectMarkerCarrier & {
+    tracks?: Array<StorystickVideoTrack & {
+        _key: string;
+    }>;
+};
+export type ResolveVideoOptions = {
+    source?: unknown;
+    warn?: (message: string) => void;
+};
+export type VideoStatus = 'ok' | 'no-video' | 'no-sidecar' | 'missing-asset' | 'unavailable-at-publication' | 'pinned-version-missing' | 'not-video' | 'archived-asset' | 'private-asset' | 'asset-not-ready' | 'provider-unconfigured' | 'invalid-metadata';
+export type VideoPosterStatus = 'ok' | 'no-poster' | 'no-sidecar' | 'missing-asset' | 'unavailable-at-publication' | 'pinned-version-missing' | 'not-image' | 'archived-asset' | 'private-asset' | 'asset-not-ready' | 'provider-unconfigured';
+export type VideoTrackStatus = 'ok' | 'invalid-track' | 'no-sidecar' | 'missing-asset' | 'unavailable-at-publication' | 'pinned-version-missing' | 'not-file' | 'not-vtt' | 'archived-asset' | 'private-asset' | 'asset-not-ready' | 'provider-unconfigured';
+export type StorystickVideoProps = {
+    src: string;
+    poster?: string;
+    crossOrigin?: 'anonymous';
+    width: number;
+    height: number;
+    controls: true;
+    preload: 'metadata';
+    playsInline: true;
+} & PreviewObjectMarkerAttrs;
+export type StorystickVideoTrackProps = {
+    src: string;
+    kind: 'captions' | 'subtitles';
+    srcLang: string;
+    label?: string;
+    default?: boolean;
+} & PreviewObjectMarkerAttrs;
+export type ResolvedStorystickVideoPoster = {
+    status: 'ok';
+    assetId: string;
+    asset: StorystickAsset;
+    src: string;
+} | {
+    status: 'no-poster';
+    assetId?: never;
+    asset?: never;
+    src?: never;
+} | {
+    status: 'no-sidecar' | 'missing-asset' | 'unavailable-at-publication' | 'pinned-version-missing';
+    assetId: string;
+    version?: number;
+    asset?: never;
+    src?: never;
+} | {
+    status: 'not-image' | 'archived-asset' | 'private-asset' | 'asset-not-ready' | 'provider-unconfigured';
+    assetId: string;
+    asset: StorystickAsset;
+    src?: never;
+};
+export type ResolvedStorystickVideoTrack = ({
+    status: 'ok';
+    _key: string;
+    assetId: string;
+    asset: StorystickAsset;
+    kind: 'captions' | 'subtitles';
+    language: string;
+    label?: string;
+    default?: boolean;
+    props: StorystickVideoTrackProps;
+} & PreviewObjectMarkerAttrs) | ({
+    status: 'invalid-track';
+    _key: string;
+    assetId?: string;
+    props: null;
+} & PreviewObjectMarkerAttrs) | ({
+    status: 'no-sidecar' | 'missing-asset' | 'unavailable-at-publication' | 'pinned-version-missing';
+    _key: string;
+    assetId: string;
+    version?: number;
+    asset?: never;
+    props: null;
+} & PreviewObjectMarkerAttrs) | ({
+    status: 'not-file' | 'not-vtt' | 'archived-asset' | 'private-asset' | 'asset-not-ready' | 'provider-unconfigured';
+    _key: string;
+    assetId: string;
+    asset: StorystickAsset;
+    props: null;
+} & PreviewObjectMarkerAttrs);
+type ResolvedStorystickVideoOk = {
+    status: 'ok';
+    assetId: string;
+    asset: StorystickAsset;
+    src: string;
+    width: number;
+    height: number;
+    durationSeconds: number;
+    codecs: NonNullable<StorystickAsset['codecs']>;
+    poster: ResolvedStorystickVideoPoster;
+    tracks: ResolvedStorystickVideoTrack[];
+    props: StorystickVideoProps;
+} & PreviewObjectMarkerAttrs;
+export type ResolvedStorystickVideo = ResolvedStorystickVideoOk | {
+    status: 'no-video';
+    assetId?: never;
+    asset?: never;
+    props: null;
+} | ({
+    status: 'no-sidecar' | 'missing-asset' | 'unavailable-at-publication' | 'pinned-version-missing';
+    assetId: string;
+    version?: number;
+    asset?: never;
+    props: null;
+} & PreviewObjectMarkerAttrs) | ({
+    status: 'not-video' | 'archived-asset' | 'private-asset' | 'asset-not-ready' | 'provider-unconfigured' | 'invalid-metadata';
+    assetId: string;
+    asset: StorystickAsset;
+    props: null;
+} & PreviewObjectMarkerAttrs);
+/** Resolve a provider-neutral Video field, poster and WebVTT tracks. */
+export declare function resolveVideo(video: StorystickVideoField | null | undefined, options?: ResolveVideoOptions): ResolvedStorystickVideo;

package/dist/video.js

@@ -0,0 +1,264 @@
+import { stripPreviewProvenanceTextMarkers } from '@storystick/types/preview-provenance';
+import { contentResolutionSource } from '@storystick/types/internal/content-origin';
+import { isPlausibleBcp47LanguageTag, lookupStorystickAsset, previewObjectMarkerAttrs, storystickAssetOriginalUrl, } from '@storystick/types';
+export { isPlausibleBcp47LanguageTag };
+/** Resolve a provider-neutral Video field, poster and WebVTT tracks. */
+export function resolveVideo(video, options = {}) {
+    options = { ...options, source: contentResolutionSource(video, options) };
+    if (!video ||
+        typeof video.assetId !== 'string' ||
+        video.assetId.length === 0) {
+        return { status: 'no-video', props: null };
+    }
+    const assetId = video.assetId;
+    const markerAttrs = previewObjectMarkerAttrs(video);
+    const lookup = lookupStorystickAsset(options.source, assetId);
+    if (lookup.status === 'no-sidecar') {
+        warn(options, `Storystick video asset "${assetId}" cannot resolve without an _assets sidecar.`);
+        return { ...markerAttrs, status: 'no-sidecar', assetId, props: null };
+    }
+    if (lookup.status !== 'ok') {
+        warn(options, videoAssetFailureMessage('video', assetId, lookup.status, 'failure' in lookup ? lookup.failure : undefined));
+        return {
+            ...markerAttrs,
+            status: lookup.status,
+            assetId,
+            ...('version' in lookup && lookup.version !== undefined
+                ? { version: lookup.version }
+                : {}),
+            props: null,
+        };
+    }
+    const asset = lookup.asset;
+    if (asset.assetType !== 'video') {
+        warn(options, `Storystick video asset "${assetId}" is not a video asset.`);
+        return { ...markerAttrs, status: 'not-video', assetId, asset, props: null };
+    }
+    if (asset.delivery.status !== 'ready' || !asset.delivery.baseUrl) {
+        const status = deliveryAssetStatus(asset.delivery.status);
+        warn(options, `Storystick video asset "${assetId}" is not playable; delivery status is "${asset.delivery.status}".`);
+        return { ...markerAttrs, status, assetId, asset, props: null };
+    }
+    const src = storystickAssetOriginalUrl(asset);
+    if (!src ||
+        !finitePositive(asset.width) ||
+        !finitePositive(asset.height) ||
+        !finitePositive(asset.durationSeconds) ||
+        !asset.codecs?.video) {
+        warn(options, `Storystick video asset "${assetId}" is missing authoritative playback metadata.`);
+        return {
+            ...markerAttrs,
+            status: 'invalid-metadata',
+            assetId,
+            asset,
+            props: null,
+        };
+    }
+    const poster = resolveVideoPoster(video.posterAssetId, options);
+    let hasDefaultTrack = false;
+    const tracks = (video.tracks ?? []).map((track) => {
+        const resolved = resolveVideoTrack(track, options);
+        if (resolved.status !== 'ok' || resolved.default !== true)
+            return resolved;
+        if (!hasDefaultTrack) {
+            hasDefaultTrack = true;
+            return resolved;
+        }
+        warn(options, `Storystick video track "${track._key}" cannot also be default; only the first resolved default track is kept.`);
+        const { default: _default, ...trackWithoutDefault } = resolved;
+        const { default: _propsDefault, ...propsWithoutDefault } = resolved.props;
+        return { ...trackWithoutDefault, props: propsWithoutDefault };
+    });
+    const props = {
+        ...markerAttrs,
+        src,
+        ...(poster.status === 'ok' ? { poster: poster.src } : {}),
+        ...(tracks.some((track) => track.status === 'ok')
+            ? { crossOrigin: 'anonymous' }
+            : {}),
+        width: asset.width,
+        height: asset.height,
+        controls: true,
+        preload: 'metadata',
+        playsInline: true,
+    };
+    return {
+        ...markerAttrs,
+        status: 'ok',
+        assetId,
+        asset,
+        src,
+        width: asset.width,
+        height: asset.height,
+        durationSeconds: asset.durationSeconds,
+        codecs: asset.codecs,
+        poster,
+        tracks,
+        props,
+    };
+}
+function resolveVideoPoster(posterAssetId, options) {
+    if (!posterAssetId)
+        return { status: 'no-poster' };
+    const lookup = lookupStorystickAsset(options.source, posterAssetId);
+    if (lookup.status === 'no-sidecar') {
+        warn(options, `Storystick video poster "${posterAssetId}" cannot resolve without an _assets sidecar.`);
+        return { status: 'no-sidecar', assetId: posterAssetId };
+    }
+    if (lookup.status !== 'ok') {
+        warn(options, videoAssetFailureMessage('poster', posterAssetId, lookup.status, 'failure' in lookup ? lookup.failure : undefined));
+        return {
+            status: lookup.status,
+            assetId: posterAssetId,
+            ...('version' in lookup && lookup.version !== undefined
+                ? { version: lookup.version }
+                : {}),
+        };
+    }
+    const asset = lookup.asset;
+    if (asset.assetType !== 'image') {
+        warn(options, `Storystick video poster "${posterAssetId}" is not an image asset.`);
+        return { status: 'not-image', assetId: posterAssetId, asset };
+    }
+    const src = storystickAssetOriginalUrl(asset);
+    if (!src) {
+        const status = deliveryAssetStatus(asset.delivery.status);
+        warn(options, `Storystick video poster "${posterAssetId}" is not renderable; delivery status is "${asset.delivery.status}".`);
+        return { status, assetId: posterAssetId, asset };
+    }
+    return { status: 'ok', assetId: posterAssetId, asset, src };
+}
+function resolveVideoTrack(track, options) {
+    const markerAttrs = previewObjectMarkerAttrs(track);
+    const assetId = track.assetId;
+    if (!assetId ||
+        (track.kind !== 'captions' && track.kind !== 'subtitles') ||
+        !isPlausibleBcp47LanguageTag(track.language)) {
+        warn(options, `Storystick video track "${track._key}" needs a WebVTT asset, captions/subtitles kind and BCP 47 language.`);
+        return {
+            ...markerAttrs,
+            status: 'invalid-track',
+            _key: track._key,
+            ...(assetId ? { assetId } : {}),
+            props: null,
+        };
+    }
+    const lookup = lookupStorystickAsset(options.source, assetId);
+    if (lookup.status === 'no-sidecar') {
+        warn(options, `Storystick video track "${track._key}" cannot resolve asset "${assetId}" without an _assets sidecar.`);
+        return {
+            ...markerAttrs,
+            status: 'no-sidecar',
+            _key: track._key,
+            assetId,
+            props: null,
+        };
+    }
+    if (lookup.status !== 'ok') {
+        warn(options, videoAssetFailureMessage('track', assetId, lookup.status, 'failure' in lookup ? lookup.failure : undefined));
+        return {
+            ...markerAttrs,
+            status: lookup.status,
+            _key: track._key,
+            assetId,
+            ...('version' in lookup && lookup.version !== undefined
+                ? { version: lookup.version }
+                : {}),
+            props: null,
+        };
+    }
+    const asset = lookup.asset;
+    if (asset.assetType !== 'file') {
+        warn(options, `Storystick video track "${track._key}" asset "${assetId}" is not a file asset.`);
+        return {
+            ...markerAttrs,
+            status: 'not-file',
+            _key: track._key,
+            assetId,
+            asset,
+            props: null,
+        };
+    }
+    if (asset.mimeType !== 'text/vtt') {
+        warn(options, `Storystick video track "${track._key}" asset "${assetId}" is not WebVTT.`);
+        return {
+            ...markerAttrs,
+            status: 'not-vtt',
+            _key: track._key,
+            assetId,
+            asset,
+            props: null,
+        };
+    }
+    const src = storystickAssetOriginalUrl(asset);
+    if (!src) {
+        warn(options, `Storystick video track "${track._key}" asset "${assetId}" is not deliverable; delivery status is "${asset.delivery.status}".`);
+        return {
+            ...markerAttrs,
+            status: deliveryAssetStatus(asset.delivery.status),
+            _key: track._key,
+            assetId,
+            asset,
+            props: null,
+        };
+    }
+    const label = track.label === undefined ? undefined : stripPreviewProvenanceTextMarkers(track.label);
+    const props = {
+        ...markerAttrs,
+        src,
+        kind: track.kind,
+        srcLang: track.language,
+        ...(label ? { label } : {}),
+        ...(track.default === true ? { default: true } : {}),
+    };
+    return {
+        ...markerAttrs,
+        status: 'ok',
+        _key: track._key,
+        assetId,
+        asset,
+        kind: track.kind,
+        language: track.language,
+        ...(label ? { label } : {}),
+        ...(track.default === true ? { default: true } : {}),
+        props,
+    };
+}
+function videoAssetFailureMessage(role, assetId, status, failure) {
+    const subject = `Storystick video ${role} asset "${assetId}"`;
+    if (status === 'unavailable-at-publication') {
+        return `${subject} was not ready when this publication was created.`;
+    }
+    if (status === 'pinned-version-missing') {
+        return `${subject} cannot resolve its pinned version${failure?.version !== undefined ? ` ${failure.version}` : ''}.`;
+    }
+    return `${subject} is missing from the _assets sidecar.`;
+}
+function deliveryAssetStatus(status) {
+    if (status === 'archived')
+        return 'archived-asset';
+    if (status === 'private-unsigned')
+        return 'private-asset';
+    if (status === 'provider-unconfigured')
+        return 'provider-unconfigured';
+    return 'asset-not-ready';
+}
+function finitePositive(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
+function warn(options, message) {
+    if (options.warn) {
+        options.warn(message);
+        return;
+    }
+    if (isProduction())
+        return;
+    if (typeof console !== 'undefined' && typeof console.warn === 'function') {
+        console.warn(message);
+    }
+}
+function isProduction() {
+    return (typeof process !== 'undefined' &&
+        typeof process.env === 'object' &&
+        process.env.NODE_ENV === 'production');
+}

package/package.json

@@ -1,6 +1,60 @@
 {
   "name": "@storystick/media",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0-rc.0",
+  "license": "FSL-1.1-MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./video": {
+      "types": "./dist/video.d.ts",
+      "import": "./dist/video.js",
+      "default": "./dist/video.js"
+    },
+    "./internal/render-diagnostics": {
+      "types": "./dist/internal/render-diagnostics.d.ts",
+      "import": "./dist/internal/render-diagnostics.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "PUBLIC-API.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": false,
+    "tag": "beta"
+  },
+  "dependencies": {
+    "@storystick/asset-grammar": "0.1.0-rc.0",
+    "@storystick/types": "0.1.0-rc.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "typescript": "^5.8.2",
+    "vitest": "^3.1.1"
+  },
+  "engines": {
+    "node": ">=24.19.0 <25"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/withstorystick/storystick.git",
+    "directory": "packages/media"
+  },
+  "homepage": "https://storystick.app",
+  "bugs": {
+    "url": "https://storystick.app"
+  },
+  "scripts": {
+    "build": "node ../../scripts/package-dist.mjs clean && tsc",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
 }