@vibesdotdev/media 0.0.0-stage → 1.0.0-rc.4

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @vibesdotdev/media
+ *
+ * Universal media contracts: stable artifact revision identity plus runtime
+ * kinds for capture, image transformation, and motion. Pure TypeScript: no FS,
+ * no native deps, no SvelteKit. Owners resolve artifact references; providers
+ * implement environment capabilities.
+ *
+ * @example Provider package declares a capture surface:
+ * ```ts
+ * // bridge/src/media/bridge.screen.descriptor.ts
+ * import { createRuntimeAsset } from '@vibesdotdev/kernel/factory';
+ *
+ * export default createRuntimeAsset({
+ *   kind: 'media/capture',
+ *   id: 'bridge.screen',
+ *   surface: 'screen',
+ *   hardware: ['consumer'],
+ *   enabled: true
+ * });
+ * ```
+ *
+ * @example Consumer resolves a provider and captures:
+ * ```ts
+ * import type { CaptureProvider } from '@vibesdotdev/media';
+ *
+ * const provider = (await runtime
+ *   .query('media/capture')
+ *   .withId('bridge.screen')
+ *   .resolve()) as CaptureProvider;
+ *
+ * const shot = await provider.capture({ format: 'png' });
+ * // shot.data is Uint8Array, shot.format === 'png'
+ * ```
+ */
+export { default as mediaPlugin } from './media.plugin.ts';
+export { OpaqueMediaIdSchema } from './schemas/opaque-id.ts';
+export { MediaArtifactTypeSchema, MediaArtifactOwnerSchema, MediaArtifactReferenceSchema, createMediaArtifactReference, CaptureSurfaceSchema, CaptureHardwareSchema, CaptureFormatSchema, CaptureDescriptorSchema, CaptureOptionsSchema, CaptureResultSchema, CaptureSourceSchema, ImageDecodeFormatSchema, ImageEncodeFormatSchema, ImageTransformOperationSchema, ImageResizeFilterSchema, ImageTransformStabilitySchema, ImagePlatformDependentFormatsSchema, ImageTransformDescriptorSchema, ImageResizeSchema, ImageOutputSchema, ImageTransformRequestSchema, ImageTransformResultSchema } from './schemas/index.ts';
+export type { MediaArtifactType, MediaArtifactOwner, MediaArtifactReference, CaptureSurface, CaptureHardware, CaptureFormat, CaptureDescriptor, CaptureOptions, CaptureResult, CaptureSource, ImageDecodeFormat, ImageEncodeFormat, ImageTransformOperation, ImageResizeFilter, ImageTransformStability, ImagePlatformDependentFormats, ImageTransformDescriptor, ImageResize, ImageOutput, ImageTransformRequest, ParsedImageTransformRequest, ImageTransformResult } from './schemas/index.ts';
+export type { CaptureProvider, ImageTransformer } from './interfaces/index.ts';
+export { MEDIA_CAPTURE_KIND_ID, MEDIA_IMAGE_TRANSFORM_KIND_ID } from './kinds/index.ts';
+export { FrameSchema, FrameSequenceSchema, PixelBufferSchema, FrameChannelsSchema, MotionAnalyzerDescriptorSchema, MotionCapabilitySchema, MotionHardwareSchema, RegionSchema, FrameDiffOptionsSchema, FrameDiffResultSchema, TemporalStatsOptionsSchema, TemporalStatsResultSchema, OpticalFlowOptionsSchema, OpticalFlowResultSchema, FlowVectorSchema, MotionDirectionSchema, MotionEnergyOptionsSchema, MotionEnergyResultSchema, DirectionStrengthSchema, MotionVerdictSchema, MotionSummaryOptionsSchema, MotionSummarySchema } from './schemas/index.ts';
+export type { Frame, FrameSequence, PixelBuffer, FrameChannels, MotionAnalyzerDescriptor, MotionCapability, MotionHardware, Region, FrameDiffOptions, FrameDiffResult, TemporalStatsOptions, TemporalStatsResult, OpticalFlowOptions, OpticalFlowResult, FlowVector, MotionDirection, MotionEnergyOptions, MotionEnergyResult, DirectionStrength, MotionVerdict, MotionSummaryOptions, MotionSummary } from './schemas/index.ts';
+export type { MotionAnalyzer } from './interfaces/index.ts';
+export { MEDIA_MOTION_KIND_ID, MEDIA_MOTION_REFERENCE_ID } from './kinds/index.ts';
+export { MediaCaptureClient } from './capture-client.ts';
+export type { CaptureSession } from './capture-client.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAG3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EACN,uBAAuB,EACvB,wBAAwB,EACxB,4BAA4B,EAC5B,4BAA4B,EAC5B,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,EACvB,uBAAuB,EACvB,6BAA6B,EAC7B,uBAAuB,EACvB,6BAA6B,EAC7B,mCAAmC,EACnC,8BAA8B,EAC9B,iBAAiB,EACjB,iBAAiB,EACjB,2BAA2B,EAC3B,0BAA0B,EAC1B,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EACX,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,cAAc,EACd,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,uBAAuB,EACvB,iBAAiB,EACjB,uBAAuB,EACvB,6BAA6B,EAC7B,wBAAwB,EACxB,WAAW,EACX,WAAW,EACX,qBAAqB,EACrB,2BAA2B,EAC3B,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAG5B,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAG/E,OAAO,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAC;AAKxF,OAAO,EACN,WAAW,EACX,mBAAmB,EACnB,iBAAiB,EACjB,mBAAmB,EACnB,8BAA8B,EAC9B,sBAAsB,EACtB,oBAAoB,EACpB,YAAY,EACZ,sBAAsB,EACtB,qBAAqB,EACrB,0BAA0B,EAC1B,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,mBAAmB,EACnB,0BAA0B,EAC1B,mBAAmB,EACnB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EACX,KAAK,EACL,aAAa,EACb,WAAW,EACX,aAAa,EACb,wBAAwB,EACxB,gBAAgB,EAChB,cAAc,EACd,MAAM,EACN,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,UAAU,EACV,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACpB,aAAa,EACb,MAAM,oBAAoB,CAAC;AAG5B,YAAY,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAEnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,YAAY,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,49 @@
+/**
+ * @vibesdotdev/media
+ *
+ * Universal media contracts: stable artifact revision identity plus runtime
+ * kinds for capture, image transformation, and motion. Pure TypeScript: no FS,
+ * no native deps, no SvelteKit. Owners resolve artifact references; providers
+ * implement environment capabilities.
+ *
+ * @example Provider package declares a capture surface:
+ * ```ts
+ * // bridge/src/media/bridge.screen.descriptor.ts
+ * import { createRuntimeAsset } from '@vibesdotdev/kernel/factory';
+ *
+ * export default createRuntimeAsset({
+ *   kind: 'media/capture',
+ *   id: 'bridge.screen',
+ *   surface: 'screen',
+ *   hardware: ['consumer'],
+ *   enabled: true
+ * });
+ * ```
+ *
+ * @example Consumer resolves a provider and captures:
+ * ```ts
+ * import type { CaptureProvider } from '@vibesdotdev/media';
+ *
+ * const provider = (await runtime
+ *   .query('media/capture')
+ *   .withId('bridge.screen')
+ *   .resolve()) as CaptureProvider;
+ *
+ * const shot = await provider.capture({ format: 'png' });
+ * // shot.data is Uint8Array, shot.format === 'png'
+ * ```
+ */
+// Plugin
+export { default as mediaPlugin } from "./media.plugin.js";
+// Schemas
+export { OpaqueMediaIdSchema } from "./schemas/opaque-id.js";
+export { MediaArtifactTypeSchema, MediaArtifactOwnerSchema, MediaArtifactReferenceSchema, createMediaArtifactReference, CaptureSurfaceSchema, CaptureHardwareSchema, CaptureFormatSchema, CaptureDescriptorSchema, CaptureOptionsSchema, CaptureResultSchema, CaptureSourceSchema, ImageDecodeFormatSchema, ImageEncodeFormatSchema, ImageTransformOperationSchema, ImageResizeFilterSchema, ImageTransformStabilitySchema, ImagePlatformDependentFormatsSchema, ImageTransformDescriptorSchema, ImageResizeSchema, ImageOutputSchema, ImageTransformRequestSchema, ImageTransformResultSchema } from "./schemas/index.js";
+// Kind constant
+export { MEDIA_CAPTURE_KIND_ID, MEDIA_IMAGE_TRANSFORM_KIND_ID } from "./kinds/index.js";
+// ── Motion perception (`media/motion`) ──────────────────────────────────────
+// Motion schemas
+export { FrameSchema, FrameSequenceSchema, PixelBufferSchema, FrameChannelsSchema, MotionAnalyzerDescriptorSchema, MotionCapabilitySchema, MotionHardwareSchema, RegionSchema, FrameDiffOptionsSchema, FrameDiffResultSchema, TemporalStatsOptionsSchema, TemporalStatsResultSchema, OpticalFlowOptionsSchema, OpticalFlowResultSchema, FlowVectorSchema, MotionDirectionSchema, MotionEnergyOptionsSchema, MotionEnergyResultSchema, DirectionStrengthSchema, MotionVerdictSchema, MotionSummaryOptionsSchema, MotionSummarySchema } from "./schemas/index.js";
+// Motion kind constants
+export { MEDIA_MOTION_KIND_ID, MEDIA_MOTION_REFERENCE_ID } from "./kinds/index.js";
+export { MediaCaptureClient } from "./capture-client.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,SAAS;AACT,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE3D,UAAU;AACV,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EACN,uBAAuB,EACvB,wBAAwB,EACxB,4BAA4B,EAC5B,4BAA4B,EAC5B,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,EACvB,uBAAuB,EACvB,6BAA6B,EAC7B,uBAAuB,EACvB,6BAA6B,EAC7B,mCAAmC,EACnC,8BAA8B,EAC9B,iBAAiB,EACjB,iBAAiB,EACjB,2BAA2B,EAC3B,0BAA0B,EAC1B,MAAM,oBAAoB,CAAC;AA8B5B,gBAAgB;AAChB,OAAO,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAC;AAExF,+EAA+E;AAE/E,iBAAiB;AACjB,OAAO,EACN,WAAW,EACX,mBAAmB,EACnB,iBAAiB,EACjB,mBAAmB,EACnB,8BAA8B,EAC9B,sBAAsB,EACtB,oBAAoB,EACpB,YAAY,EACZ,sBAAsB,EACtB,qBAAqB,EACrB,0BAA0B,EAC1B,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,mBAAmB,EACnB,0BAA0B,EAC1B,mBAAmB,EACnB,MAAM,oBAAoB,CAAC;AA8B5B,wBAAwB;AACxB,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAEnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/interfaces/capture-provider.d.ts

@@ -0,0 +1,33 @@
+/**
+ * CaptureProvider Interface
+ *
+ * The contract every `media/capture` implementation must satisfy. The
+ * runtime resolves implementations from descriptors of kind
+ * `media/capture`; consumers obtain a `CaptureProvider` via
+ * `runtime.query('media/capture').withId(...).resolve()`.
+ */
+import type { CaptureOptions, CaptureResult, CaptureSource } from '../schemas/capture-options.ts';
+/**
+ * Provider for a single capturable surface.
+ *
+ * An implementation owns one descriptor (one `id`, one `surface`). When a
+ * caller has access to multiple displays / cameras / mics, the provider's
+ * `listSources()` enumerates them and `capture({ sourceId })` selects one.
+ */
+export interface CaptureProvider {
+    /**
+     * Capture a single frame / clip / snapshot from this provider.
+     *
+     * Throws on hard failures (no permission, native bridge unreachable,
+     * unsupported format requested for this surface). Successful captures
+     * return the encoded payload plus metadata.
+     */
+    capture(options?: CaptureOptions): Promise<CaptureResult>;
+    /**
+     * Enumerate the sources this provider can capture from. May return an
+     * empty list when the underlying system has no sources of this kind
+     * (e.g. no displays attached on a headless box).
+     */
+    listSources(): Promise<CaptureSource[]>;
+}
+//# sourceMappingURL=capture-provider.d.ts.map

package/dist/interfaces/capture-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-provider.d.ts","sourceRoot":"","sources":["../../src/interfaces/capture-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACX,cAAc,EACd,aAAa,EACb,aAAa,EACb,MAAM,+BAA+B,CAAC;AAEvC;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC/B;;;;;;OAMG;IACH,OAAO,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAE1D;;;;OAIG;IACH,WAAW,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;CACxC"}

package/dist/interfaces/capture-provider.js

@@ -0,0 +1,10 @@
+/**
+ * CaptureProvider Interface
+ *
+ * The contract every `media/capture` implementation must satisfy. The
+ * runtime resolves implementations from descriptors of kind
+ * `media/capture`; consumers obtain a `CaptureProvider` via
+ * `runtime.query('media/capture').withId(...).resolve()`.
+ */
+export {};
+//# sourceMappingURL=capture-provider.js.map

package/dist/interfaces/capture-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-provider.js","sourceRoot":"","sources":["../../src/interfaces/capture-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/interfaces/image-transformer.d.ts

@@ -0,0 +1,7 @@
+import type { ImageTransformRequest, ImageTransformResult } from '../schemas/image-transform.ts';
+/** Runtime implementation contract for `media/image-transform`. */
+export interface ImageTransformer {
+    readonly id: string;
+    transform(request: ImageTransformRequest): Promise<ImageTransformResult>;
+}
+//# sourceMappingURL=image-transformer.d.ts.map

package/dist/interfaces/image-transformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-transformer.d.ts","sourceRoot":"","sources":["../../src/interfaces/image-transformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,qBAAqB,EACrB,oBAAoB,EACpB,MAAM,+BAA+B,CAAC;AAEvC,mEAAmE;AACnE,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACzE"}

package/dist/interfaces/image-transformer.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=image-transformer.js.map

package/dist/interfaces/image-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-transformer.js","sourceRoot":"","sources":["../../src/interfaces/image-transformer.ts"],"names":[],"mappings":""}

package/dist/interfaces/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Media Interfaces
+ */
+export type { CaptureProvider } from './capture-provider.ts';
+export type { MotionAnalyzer } from './motion-analyzer.ts';
+export type { ImageTransformer } from './image-transformer.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/interfaces/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/interfaces/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,YAAY,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,YAAY,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/interfaces/index.js

@@ -0,0 +1,5 @@
+/**
+ * Media Interfaces
+ */
+export {};
+//# sourceMappingURL=index.js.map

package/dist/interfaces/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/interfaces/index.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/interfaces/motion-analyzer.d.ts

@@ -0,0 +1,55 @@
+/**
+ * MotionAnalyzer Interface
+ *
+ * The contract every `media/motion` implementation satisfies. Consumers
+ * obtain a `MotionAnalyzer` via
+ * `runtime.query('media/motion').withId('media.motion.reference').resolve()`
+ * and feed it decoded frame sequences.
+ *
+ * Methods are async by contract even though the reference provider computes
+ * synchronously — that leaves room for a provider to offload to a worker,
+ * WASM module, or native/GPU backend without changing consumer code.
+ */
+import type { Frame } from '../schemas/motion-frame.ts';
+import type { FrameDiffOptions, FrameDiffResult, TemporalStatsOptions, TemporalStatsResult, OpticalFlowOptions, OpticalFlowResult, MotionEnergyOptions, MotionEnergyResult, MotionSummaryOptions, MotionSummary } from '../schemas/motion-analysis.ts';
+export interface MotionAnalyzer {
+    /**
+     * Absolute luma difference between two frames — "what changed between these
+     * two screenshots". Returns overall magnitude, the fraction of pixels that
+     * changed, and a bounding box of the changed region.
+     */
+    frameDiff(a: Frame, b: Frame, options?: FrameDiffOptions): Promise<FrameDiffResult>;
+    /**
+     * Per-pixel temporal mean + standard deviation over a sequence. The std map
+     * is the cheapest "does anything vary here" signal and needs no motion
+     * model — it already leaks a ghost of hidden temporal structure.
+     *
+     * Requires at least two frames; throws otherwise.
+     */
+    temporalStats(frames: Frame[], options?: TemporalStatsOptions): Promise<TemporalStatsResult>;
+    /**
+     * Block-matching optical flow between two frames — "what moved and where",
+     * as a coarse grid of displacement vectors plus confidence-weighted means.
+     */
+    opticalFlow(a: Frame, b: Frame, options?: OpticalFlowOptions): Promise<OpticalFlowResult>;
+    /**
+     * Reichardt / lag-1 opponent motion energy over a sequence. Separates
+     * coherently drifting structure (high `coherence`, a clear dominant
+     * direction) from temporally independent twinkle (coherence ≈ 0) — the
+     * exact asymmetry a motion-carrier scheme exploits and that naive
+     * frame-sampling pipelines miss.
+     *
+     * Requires at least two frames; throws otherwise.
+     */
+    motionEnergy(frames: Frame[], options?: MotionEnergyOptions): Promise<MotionEnergyResult>;
+    /**
+     * Compact classification of a whole sequence — `static`,
+     * `coherent-motion`, or `incoherent-change` — with the supporting scalars.
+     * Composed from the primitives above; the payload a vision model or planner
+     * consumes instead of raw maps.
+     *
+     * Requires at least two frames; throws otherwise.
+     */
+    summarize(frames: Frame[], options?: MotionSummaryOptions): Promise<MotionSummary>;
+}
+//# sourceMappingURL=motion-analyzer.d.ts.map

package/dist/interfaces/motion-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion-analyzer.d.ts","sourceRoot":"","sources":["../../src/interfaces/motion-analyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,KAAK,EACX,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,aAAa,EACb,MAAM,+BAA+B,CAAC;AAEvC,MAAM,WAAW,cAAc;IAC9B;;;;OAIG;IACH,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAEpF;;;;;;OAMG;IACH,aAAa,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAE7F;;;OAGG;IACH,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAE1F;;;;;;;;OAQG;IACH,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAE1F;;;;;;;OAOG;IACH,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CACnF"}

package/dist/interfaces/motion-analyzer.js

@@ -0,0 +1,14 @@
+/**
+ * MotionAnalyzer Interface
+ *
+ * The contract every `media/motion` implementation satisfies. Consumers
+ * obtain a `MotionAnalyzer` via
+ * `runtime.query('media/motion').withId('media.motion.reference').resolve()`
+ * and feed it decoded frame sequences.
+ *
+ * Methods are async by contract even though the reference provider computes
+ * synchronously — that leaves room for a provider to offload to a worker,
+ * WASM module, or native/GPU backend without changing consumer code.
+ */
+export {};
+//# sourceMappingURL=motion-analyzer.js.map

package/dist/interfaces/motion-analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion-analyzer.js","sourceRoot":"","sources":["../../src/interfaces/motion-analyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/kinds/capture.d.ts

@@ -0,0 +1,58 @@
+/**
+ * `media/capture` Kind
+ *
+ * Runtime-kind definition for capturable media providers. Descriptors are
+ * resolved by `id` and filtered by `hardware` scope; surface is metadata
+ * for consumers to filter on but not part of resolution.
+ */
+import { type CaptureDescriptor } from '../schemas/capture-descriptor.ts';
+import type { CaptureProvider } from '../interfaces/capture-provider.ts';
+/**
+ * Kind id consumers pass to `runtime.query()`.
+ */
+export declare const MEDIA_CAPTURE_KIND_ID: "media/capture";
+/**
+ * Runtime-kind shape for `media/capture`.
+ *
+ * Resolution strategy: filter candidates to those whose `hardware` list
+ * includes the active scope's hardware. Prefer descriptors that explicitly
+ * declare the requested hardware over those that omit it. If multiple
+ * candidates remain, pick the first — callers should disambiguate by `id`
+ * via `runtime.query('media/capture').withId('...')`.
+ */
+export declare const mediaCaptureKind: {
+    id: "media/capture";
+    descriptorSchema: import("zod/v4").ZodObject<{
+        id: import("zod/v4").ZodString;
+        name: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        description: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        tags: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        priority: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+        capabilityId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        requiredContext: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        optionalContext: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        config: import("zod/v4").ZodOptional<import("zod/v4").ZodUnknown>;
+        retention: import("zod/v4").ZodOptional<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodObject<{
+            maxAgeDays: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+            maxEntries: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+            maxBytes: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+            cascadeFrom: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            ageField: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            reason: import("zod/v4").ZodString;
+            enforcedBy: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        }, import("zod/v4/core").$strip>]>>;
+        kind: import("zod/v4").ZodLiteral<"media/capture">;
+        surface: import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodLiteral<"screen">, import("zod/v4").ZodLiteral<"camera">, import("zod/v4").ZodLiteral<"microphone-snapshot">, import("zod/v4").ZodString]>;
+        hardware: import("zod/v4").ZodArray<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodLiteral<"consumer">, import("zod/v4").ZodLiteral<"cloud">, import("zod/v4").ZodString]>>;
+        enabled: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+    }, import("zod/v4/core").$strip>;
+    resolve(candidates: CaptureDescriptor[], scope: {
+        hardware: string;
+    }): CaptureDescriptor | undefined;
+};
+/**
+ * Type re-export so consumers can `import type { CaptureProvider } from
+ * '@vibesdotdev/media/kinds/capture'` if they want kind-co-located types.
+ */
+export type { CaptureProvider };
+//# sourceMappingURL=capture.d.ts.map

package/dist/kinds/capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../../src/kinds/capture.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAA2B,KAAK,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACnG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAG,eAAwB,CAAC;AAE9D;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;wBAIR,iBAAiB,EAAE,SAAS;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,iBAAiB,GAAG,SAAS;CAMpG,CAAC;AAEF;;;GAGG;AACH,YAAY,EAAE,eAAe,EAAE,CAAC"}

package/dist/kinds/capture.js

@@ -0,0 +1,34 @@
+/**
+ * `media/capture` Kind
+ *
+ * Runtime-kind definition for capturable media providers. Descriptors are
+ * resolved by `id` and filtered by `hardware` scope; surface is metadata
+ * for consumers to filter on but not part of resolution.
+ */
+import { CaptureDescriptorSchema } from "../schemas/capture-descriptor.js";
+/**
+ * Kind id consumers pass to `runtime.query()`.
+ */
+export const MEDIA_CAPTURE_KIND_ID = 'media/capture';
+/**
+ * Runtime-kind shape for `media/capture`.
+ *
+ * Resolution strategy: filter candidates to those whose `hardware` list
+ * includes the active scope's hardware. Prefer descriptors that explicitly
+ * declare the requested hardware over those that omit it. If multiple
+ * candidates remain, pick the first — callers should disambiguate by `id`
+ * via `runtime.query('media/capture').withId('...')`.
+ */
+export const mediaCaptureKind = {
+    id: MEDIA_CAPTURE_KIND_ID,
+    descriptorSchema: CaptureDescriptorSchema,
+    resolve(candidates, scope) {
+        if (candidates.length === 0)
+            return undefined;
+        const matching = candidates.filter((d) => d.hardware.includes(scope.hardware));
+        if (matching.length === 0)
+            return undefined;
+        return matching[0];
+    }
+};
+//# sourceMappingURL=capture.js.map

package/dist/kinds/capture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.js","sourceRoot":"","sources":["../../src/kinds/capture.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,uBAAuB,EAA0B,MAAM,kCAAkC,CAAC;AAGnG;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,eAAwB,CAAC;AAE9D;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC/B,EAAE,EAAE,qBAAqB;IACzB,gBAAgB,EAAE,uBAAuB;IAEzC,OAAO,CAAC,UAA+B,EAAE,KAA2B;QACnE,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAC9C,MAAM,QAAQ,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC/E,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAC5C,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;IACpB,CAAC;CACD,CAAC"}

package/dist/kinds/image-transform.d.ts

@@ -0,0 +1,91 @@
+import { type ImageTransformDescriptor } from '../schemas/image-transform.ts';
+import type { ImageTransformer } from '../interfaces/image-transformer.ts';
+export declare const MEDIA_IMAGE_TRANSFORM_KIND_ID: "media/image-transform";
+export declare const mediaImageTransformKind: {
+    id: "media/image-transform";
+    descriptorSchema: import("zod/v4").ZodObject<{
+        id: import("zod/v4").ZodString;
+        name: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        description: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        tags: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        capabilityId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        requiredContext: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        optionalContext: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        config: import("zod/v4").ZodOptional<import("zod/v4").ZodUnknown>;
+        retention: import("zod/v4").ZodOptional<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodObject<{
+            maxAgeDays: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+            maxEntries: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+            maxBytes: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+            cascadeFrom: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            ageField: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            reason: import("zod/v4").ZodString;
+            enforcedBy: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        }, import("zod/v4/core").$strip>]>>;
+        kind: import("zod/v4").ZodLiteral<"media/image-transform">;
+        decodeFormats: import("zod/v4").ZodArray<import("zod/v4").ZodEnum<{
+            png: "png";
+            jpeg: "jpeg";
+            webp: "webp";
+            heic: "heic";
+            avif: "avif";
+            bmp: "bmp";
+            tiff: "tiff";
+            gif: "gif";
+        }>>;
+        encodeFormats: import("zod/v4").ZodArray<import("zod/v4").ZodEnum<{
+            png: "png";
+            jpeg: "jpeg";
+            webp: "webp";
+            heic: "heic";
+            avif: "avif";
+        }>>;
+        platformDependentFormats: import("zod/v4").ZodDefault<import("zod/v4").ZodObject<{
+            decode: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodEnum<{
+                png: "png";
+                jpeg: "jpeg";
+                webp: "webp";
+                heic: "heic";
+                avif: "avif";
+                bmp: "bmp";
+                tiff: "tiff";
+                gif: "gif";
+            }>>>;
+            encode: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodEnum<{
+                png: "png";
+                jpeg: "jpeg";
+                webp: "webp";
+                heic: "heic";
+                avif: "avif";
+            }>>>;
+        }, import("zod/v4/core").$strip>>;
+        operations: import("zod/v4").ZodArray<import("zod/v4").ZodEnum<{
+            rotate: "rotate";
+            "auto-orient": "auto-orient";
+            resize: "resize";
+            flip: "flip";
+            flop: "flop";
+            modulate: "modulate";
+        }>>;
+        hardware: import("zod/v4").ZodArray<import("zod/v4").ZodString>;
+        stability: import("zod/v4").ZodEnum<{
+            stable: "stable";
+            experimental: "experimental";
+        }>;
+        preservesIccProfileFor: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodEnum<{
+            png: "png";
+            jpeg: "jpeg";
+            webp: "webp";
+            heic: "heic";
+            avif: "avif";
+        }>>>;
+        maxInputBytes: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+        maxPixels: import("zod/v4").ZodNumber;
+        priority: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+        enabled: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+    }, import("zod/v4/core").$strip>;
+    resolve(candidates: ImageTransformDescriptor[], scope: {
+        hardware: string;
+    }): ImageTransformDescriptor | undefined;
+};
+export type { ImageTransformer };
+//# sourceMappingURL=image-transform.d.ts.map

package/dist/kinds/image-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-transform.d.ts","sourceRoot":"","sources":["../../src/kinds/image-transform.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,KAAK,wBAAwB,EAC7B,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAE3E,eAAO,MAAM,6BAA6B,EAAG,uBAAgC,CAAC;AAE9E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAKtB,wBAAwB,EAAE,SAC/B;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GACzB,wBAAwB,GAAG,SAAS;CAKvC,CAAC;AAEF,YAAY,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/kinds/image-transform.js

@@ -0,0 +1,12 @@
+import { ImageTransformDescriptorSchema } from "../schemas/image-transform.js";
+export const MEDIA_IMAGE_TRANSFORM_KIND_ID = 'media/image-transform';
+export const mediaImageTransformKind = {
+    id: MEDIA_IMAGE_TRANSFORM_KIND_ID,
+    descriptorSchema: ImageTransformDescriptorSchema,
+    resolve(candidates, scope) {
+        return candidates
+            .filter((descriptor) => descriptor.enabled && descriptor.hardware.includes(scope.hardware))
+            .sort((left, right) => right.priority - left.priority)[0];
+    }
+};
+//# sourceMappingURL=image-transform.js.map

package/dist/kinds/image-transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-transform.js","sourceRoot":"","sources":["../../src/kinds/image-transform.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,8BAA8B,EAE9B,MAAM,+BAA+B,CAAC;AAGvC,MAAM,CAAC,MAAM,6BAA6B,GAAG,uBAAgC,CAAC;AAE9E,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACtC,EAAE,EAAE,6BAA6B;IACjC,gBAAgB,EAAE,8BAA8B;IAEhD,OAAO,CACN,UAAsC,EACtC,KAA2B;QAE3B,OAAO,UAAU;aACf,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;aAC1F,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5D,CAAC;CACD,CAAC"}

package/dist/kinds/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Media Kinds
+ */
+export { mediaCaptureKind, MEDIA_CAPTURE_KIND_ID } from './capture.ts';
+export type { CaptureProvider } from './capture.ts';
+export { mediaMotionKind, MEDIA_MOTION_KIND_ID, MEDIA_MOTION_REFERENCE_ID } from './motion.ts';
+export type { MotionAnalyzer } from './motion.ts';
+export { mediaImageTransformKind, MEDIA_IMAGE_TRANSFORM_KIND_ID } from './image-transform.ts';
+export type { ImageTransformer } from './image-transform.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/kinds/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/kinds/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACvE,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,OAAO,EACN,eAAe,EACf,oBAAoB,EACpB,yBAAyB,EACzB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,EAAE,uBAAuB,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;AAC9F,YAAY,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/kinds/index.js

@@ -0,0 +1,7 @@
+/**
+ * Media Kinds
+ */
+export { mediaCaptureKind, MEDIA_CAPTURE_KIND_ID } from "./capture.js";
+export { mediaMotionKind, MEDIA_MOTION_KIND_ID, MEDIA_MOTION_REFERENCE_ID } from "./motion.js";
+export { mediaImageTransformKind, MEDIA_IMAGE_TRANSFORM_KIND_ID } from "./image-transform.js";
+//# sourceMappingURL=index.js.map

package/dist/kinds/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/kinds/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAGvE,OAAO,EACN,eAAe,EACf,oBAAoB,EACpB,yBAAyB,EACzB,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,uBAAuB,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/kinds/motion.d.ts

@@ -0,0 +1,57 @@
+/**
+ * `media/motion` Kind
+ *
+ * Runtime-kind definition for temporal-perception providers. Descriptors are
+ * resolved by `id` and filtered by `hardware` scope, mirroring `media/capture`.
+ * The reference provider (pure TS) declares both `consumer` and `cloud`, so a
+ * bare `runtime.query('media/motion')` resolves it in any scope; an accelerated
+ * provider registered for a narrower scope wins there.
+ */
+import { type MotionAnalyzerDescriptor } from '../schemas/motion-descriptor.ts';
+import type { MotionAnalyzer } from '../interfaces/motion-analyzer.ts';
+/** Kind id consumers pass to `runtime.query()`. */
+export declare const MEDIA_MOTION_KIND_ID: "media/motion";
+/** Id of the built-in pure-TS reference analyzer that ships with this package. */
+export declare const MEDIA_MOTION_REFERENCE_ID: "media.motion.reference";
+/**
+ * Runtime-kind shape for `media/motion`.
+ *
+ * Resolution: keep candidates whose `hardware` includes the active scope's
+ * hardware; return the first. Callers disambiguate by `id` via
+ * `runtime.query('media/motion').withId('...')`.
+ */
+export declare const mediaMotionKind: {
+    id: "media/motion";
+    descriptorSchema: import("zod/v4").ZodObject<{
+        id: import("zod/v4").ZodString;
+        name: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        description: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        tags: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        priority: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+        capabilityId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        requiredContext: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        optionalContext: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        config: import("zod/v4").ZodOptional<import("zod/v4").ZodUnknown>;
+        retention: import("zod/v4").ZodOptional<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodObject<{
+            maxAgeDays: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+            maxEntries: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+            maxBytes: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+            cascadeFrom: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            ageField: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            reason: import("zod/v4").ZodString;
+            enforcedBy: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        }, import("zod/v4/core").$strip>]>>;
+        kind: import("zod/v4").ZodLiteral<"media/motion">;
+        capabilities: import("zod/v4").ZodArray<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodLiteral<"frame-diff">, import("zod/v4").ZodLiteral<"temporal-stats">, import("zod/v4").ZodLiteral<"optical-flow">, import("zod/v4").ZodLiteral<"motion-energy">, import("zod/v4").ZodLiteral<"summarize">, import("zod/v4").ZodString]>>;
+        hardware: import("zod/v4").ZodArray<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodLiteral<"consumer">, import("zod/v4").ZodLiteral<"cloud">, import("zod/v4").ZodString]>>;
+        enabled: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+    }, import("zod/v4/core").$strip>;
+    resolve(candidates: MotionAnalyzerDescriptor[], scope: {
+        hardware: string;
+    }): MotionAnalyzerDescriptor | undefined;
+};
+/**
+ * Type re-export so consumers can co-locate the interface type with the kind.
+ */
+export type { MotionAnalyzer };
+//# sourceMappingURL=motion.d.ts.map

package/dist/kinds/motion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../../src/kinds/motion.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAEN,KAAK,wBAAwB,EAC7B,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAEvE,mDAAmD;AACnD,eAAO,MAAM,oBAAoB,EAAG,cAAuB,CAAC;AAE5D,kFAAkF;AAClF,eAAO,MAAM,yBAAyB,EAAG,wBAAiC,CAAC;AAE3E;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;wBAKd,wBAAwB,EAAE,SAC/B;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GACzB,wBAAwB,GAAG,SAAS;CAMvC,CAAC;AAEF;;GAEG;AACH,YAAY,EAAE,cAAc,EAAE,CAAC"}