@byamoah/studio-state 0.0.0-stage → 0.1.0-beta.0

package/index.js

@@ -0,0 +1,371 @@
+export const defineStudioDefaults = (value) => value;
+export function getStudioValue(value, path) {
+  if (
+    !path ||
+    typeof path !== "string" ||
+    path
+      .split(".")
+      .some((part) => ["__proto__", "prototype", "constructor"].includes(part))
+  )
+    return undefined;
+  for (const part of path.split(".")) {
+    if (part.startsWith("@") && Array.isArray(value)) {
+      try {
+        value = value.find(
+          (item) => item?.id === decodeURIComponent(part.slice(1)),
+        );
+      } catch {
+        return undefined;
+      }
+      continue;
+    }
+    if (!value || typeof value !== "object" || !Object.hasOwn(value, part))
+      return undefined;
+    value = value[part];
+  }
+  return value;
+}
+function validStudioId(id) {
+  if (typeof id !== "string" || !id.length || id.length > 200) return false;
+  try {
+    return encodeURIComponent(id).replaceAll(".", "%2E").length <= 300;
+  } catch {
+    return false;
+  }
+}
+export function studioItemSegment(id) {
+  if (!validStudioId(id))
+    throw new Error(
+      "Studio items require a nonempty, well-formed string id (max 200 characters / 300 encoded characters).",
+    );
+  return "@" + encodeURIComponent(id).replaceAll(".", "%2E");
+}
+export function expandStudioPath(document, pattern) {
+  const parts = pattern.split("."), star = parts.indexOf("*");
+  if (star < 0) return [pattern];
+  const items = getStudioValue(document, parts.slice(0, star).join("."));
+  if (!Array.isArray(items)) return [];
+  return items.filter(item => validStudioId(item?.id)).flatMap(item =>
+    expandStudioPath(document, [...parts.slice(0, star), studioItemSegment(item.id), ...parts.slice(star + 1)].join(".")));
+}
+/** OR of type constraints; each constraint is an ancestor collection/type map. */
+export function matchesStudioConditions(document, concretePath, conditions) {
+  if (!conditions?.length) return true;
+  const parts = concretePath.split(".");
+  return conditions.some(condition => Object.entries(condition).every(([pattern, type]) => {
+    const prefix = pattern.split(".");
+    const bound = prefix.map((part, index) => part === "*" ? parts[index] : part);
+    if (!parts[prefix.length]?.startsWith("@")) return false;
+    return getStudioValue(document, [...bound, parts[prefix.length]].join("."))?.type === type;
+  }));
+}
+export function studioCollectionPattern(path) {
+  return path.split(".").map(part => part.startsWith("@") ? "*" : part).join(".");
+}
+export function validateStudioState(value, contract) {
+  const errors = [];
+  const definitions = { ...(contract.collections ?? {}) };
+  // Preserve validation for callers supplying only wildcard fields.
+  for (const field of contract.fields) {
+    const parts = field.path.split(".");
+    for (let index = 0; index < parts.length; index++) if (parts[index] === "*") {
+      const prefix = parts.slice(0, index).join(".");
+      if (!contract.collections?.[prefix]) {
+        const clauses = field.conditions?.map(condition => Object.fromEntries(Object.entries(condition).filter(([ancestor]) => ancestor.split(".").length < index)));
+        const incoming = !clauses?.length || clauses.some(clause => !Object.keys(clause).length) ? undefined : clauses;
+        const previous = definitions[prefix];
+        definitions[prefix] = previous && (!previous.conditions || !incoming) ? {} : { conditions: [...(previous?.conditions ?? []), ...(incoming ?? [])] };
+      }
+    }
+  }
+  for (const [pattern, rule] of Object.entries(definitions)) {
+    for (const path of expandStudioPath(value, pattern)) {
+      if (!matchesStudioConditions(value, path, rule.conditions)) continue;
+      const items = getStudioValue(value, path);
+      if (!Array.isArray(items) || items.length < (rule.minItems ?? 0) || items.length > (rule.maxItems ?? 1000)) {
+        errors.push(`${path}: collection size is outside its allowed range.`); continue;
+      }
+      if (items.some(item => !item || !validStudioId(item.id)) || new Set(items.map(item => item.id)).size !== items.length)
+        errors.push(`${path}: requires at most 1000 items with unique nonempty string ids.`);
+      const allowed = rule.cases && new Set(rule.cases.filter(entry => matchesStudioConditions(value, path, entry.conditions)).flatMap(entry => entry.types));
+      if (rule.variants && items.some(item => !item || typeof item.type !== "string" || !Object.hasOwn(rule.variants, item.type) || (allowed && !allowed.has(item.type))))
+        errors.push(`${path}: contains an unsupported block type.`);
+    }
+  }
+  for (const pattern of contract.fields) for (const path of expandStudioPath(value, pattern.path)) {
+    if (!matchesStudioConditions(value, path, pattern.conditions)) continue;
+    const field = { ...pattern, path };
+    const v = getStudioValue(value, field.path);
+    if (v === undefined || v === null) {
+      if (!field.optional)
+        errors.push(`${field.path}: a bundled value is required.`);
+      continue;
+    }
+    let valid = true;
+    if (field.type === "color")
+      valid =
+        typeof v === "string" &&
+        /^#(?:[0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(v);
+    else if (field.type === "number")
+      valid =
+        typeof v === "number" &&
+        Number.isFinite(v) &&
+        (field.min === undefined || v >= field.min) &&
+        (field.max === undefined || v <= field.max);
+    else if (field.type === "boolean") valid = typeof v === "boolean";
+    else if (field.type === "array") valid = Array.isArray(v);
+    else if (["text", "image"].includes(field.type))
+      valid =
+        typeof v === "string" &&
+        v.length <=
+          (field.maxLength ?? (field.type === "image" ? 1000000 : 600));
+    else if (field.type === "enum") valid = field.values?.includes(v) === true;
+    else valid = false;
+    if (!valid) errors.push(`${field.path}: invalid ${field.type} value.`);
+  }
+  return errors;
+}
+
+/** Duplicate serializable content, never component code or transient component state. */
+export function duplicateStudioItem(document, path, id, options = {}) {
+  const list = getStudioValue(document, path);
+  if (!Array.isArray(list) || list.length >= (options.maxItems ?? 1000))
+    throw new Error("Collection cannot accept another item.");
+  const index = list.findIndex((item) => item?.id === id);
+  if (index < 0 || list.filter((item) => item?.id === id).length !== 1)
+    throw new Error("Select an existing unique item.");
+  if (!["before", "after"].includes(options.position ?? "after"))
+    throw new Error("Invalid insertion position.");
+  const duplicate = createStudioItem(list[index], list, options);
+  list.splice(
+    index + ((options.position ?? "after") === "after" ? 1 : 0),
+    0,
+    duplicate,
+  );
+  return duplicate.id;
+}
+
+/** Create from a template with the same identity safeguards as duplication. */
+export function createStudioItem(template, existing = [], options = {}) {
+  const createId = options.createId ?? (() => globalThis.crypto.randomUUID());
+  const reserved = new Set();
+  const reserve = (value) => {
+    if (!value || typeof value !== "object") return;
+    if (typeof value.id === "string") reserved.add(value.id);
+    for (const child of Object.values(value)) reserve(child);
+  };
+  reserve(existing);
+  reserve(template);
+  const fresh = () => {
+    for (let attempt = 0; attempt < 20; attempt++) {
+      const next = createId();
+      studioItemSegment(next);
+      if (!reserved.has(next)) {
+        reserved.add(next);
+        return next;
+      }
+    }
+    throw new Error("Could not generate a unique item id.");
+  };
+  const duplicate = JSON.parse(JSON.stringify(template));
+  duplicate.id = fresh();
+  const rekeyed = new WeakSet();
+  for (const pattern of [...(options.ownedCollections ?? [])].sort(
+    (a, b) => a.split(".").length - b.split(".").length,
+  )) {
+    if (
+      pattern
+        .split(".")
+        .some((part) =>
+          ["__proto__", "constructor", "prototype"].includes(part),
+        )
+    )
+      throw new Error("Invalid owned collection path.");
+    for (const ownedPath of expandStudioPath(duplicate, pattern)) {
+      const children = getStudioValue(duplicate, ownedPath);
+      if (!Array.isArray(children))
+        throw new Error("Owned collection must be an array.");
+      for (const child of children) {
+        if (!child || typeof child !== "object" || Array.isArray(child))
+          throw new Error("Owned items require object records.");
+        if (typeof child.id === "string") reserved.add(child.id);
+      }
+      for (const child of children) { child.id = fresh(); rekeyed.add(child); }
+    }
+  }
+  const rekeySlots = (owner) => {
+    for (const children of Object.values(owner?.slots ?? {})) {
+      if (!Array.isArray(children)) throw new Error("Slot contents must be arrays.");
+      for (const child of children) {
+        if (!child || typeof child !== "object" || Array.isArray(child)) throw new Error("Slot items require object records.");
+        if (!rekeyed.has(child)) { child.id = fresh(); rekeyed.add(child); }
+        rekeySlots(child);
+      }
+    }
+  };
+  rekeySlots(duplicate);
+  return duplicate;
+}
+
+/** Merge generated content over bundled values; arrays retain authored order and empty lists. */
+export function mergeStudioDefaults(base, authored) {
+  if (!authored || typeof authored !== "object" || Array.isArray(authored))
+    return authored === undefined ? base : authored;
+  const result =
+    base && typeof base === "object" && !Array.isArray(base) ? { ...base } : {};
+  for (const [key, value] of Object.entries(authored)) {
+    if (["__proto__", "constructor", "prototype"].includes(key)) continue;
+    result[key] =
+      value && typeof value === "object" && !Array.isArray(value)
+        ? mergeStudioDefaults(result[key], value)
+        : value;
+  }
+  return result;
+}
+
+const studioRevealListeners = new Set();
+export function subscribeStudioReveal(listener) {
+  studioRevealListeners.add(listener);
+  return () => studioRevealListeners.delete(listener);
+}
+export function requestStudioItemReveal(path, id) {
+  for (const listener of studioRevealListeners) listener({ path, id });
+}
+
+/** Reorder by stable identity. Moving past either end is a harmless no-op. */
+export function moveStudioItem(document, path, id, offset) {
+  if (offset !== -1 && offset !== 1) throw new Error("Move one position at a time.");
+  const list = getStudioValue(document, path);
+  if (!Array.isArray(list)) throw new Error("Select an existing collection.");
+  const index = list.findIndex((item) => item?.id === id);
+  if (index < 0 || list.filter((item) => item?.id === id).length !== 1)
+    throw new Error("Select an existing unique item.");
+  const destination = index + offset;
+  if (destination < 0 || destination >= list.length) return false;
+  [list[index], list[destination]] = [list[destination], list[index]];
+  return true;
+}
+
+/** Remove only the selected content instance, respecting collection limits. */
+export function removeStudioItem(document, path, id, options = {}) {
+  const list = getStudioValue(document, path);
+  if (!Array.isArray(list)) throw new Error("Select an existing collection.");
+  const index = list.findIndex((item) => item?.id === id);
+  if (index < 0 || list.filter((item) => item?.id === id).length !== 1)
+    throw new Error("Select an existing unique item.");
+  if (list.length <= (options.minItems ?? 0))
+    throw new Error("Collection requires its remaining items.");
+  list.splice(index, 1);
+}
+
+/** Insert or replace with a registered data template, never executable content. */
+export function insertStudioBlock(document, path, type, definition, options = {}) {
+  if (!matchesStudioConditions(document,path,definition?.conditions) ||
+      (definition?.cases && !definition.cases.some(entry => entry.types.includes(type) && matchesStudioConditions(document,path,entry.conditions))))
+    throw new Error("This component is not supported by the slot owner.");
+  const variant = Object.hasOwn(definition?.variants ?? {}, type) && definition.variants[type];
+  if (!variant?.template || variant.template.type !== type)
+    throw new Error("Choose a registered block type.");
+  const list = getStudioValue(document, path);
+  if (!Array.isArray(list)) throw new Error("Select an existing collection.");
+  let index = list.length;
+  if (options.relativeTo !== undefined) {
+    index = list.findIndex(item => item?.id === options.relativeTo);
+    if (index < 0 || list.filter(item => item?.id === options.relativeTo).length !== 1)
+      throw new Error("Select an existing unique item.");
+  }
+  const replace = options.position === "replace";
+  if (replace && options.relativeTo === undefined) throw new Error("Select an item to replace.");
+  if (!replace && list.length >= (definition.maxItems ?? 1000)) throw new Error("Collection cannot accept another item.");
+  if (!["before", "after", "replace"].includes(options.position ?? "after")) throw new Error("Invalid insertion position.");
+  const item = createStudioItem(variant.template, list, { ...definition, createId: options.createId });
+  if (!replace && options.relativeTo !== undefined && (options.position ?? "after") === "after") index++;
+  list.splice(index, replace ? 1 : 0, item);
+  return item.id;
+}
+
+export function studioBindingAncestors(binding) {
+  const parts=binding.split(".");
+  try {
+    return parts.flatMap((part,index)=> {
+      if(!part.startsWith("@")) return [];
+      const id=decodeURIComponent(part.slice(1));
+      return validStudioId(id) ? [{path:parts.slice(0,index).join("."),id}] : [];
+    });
+  } catch { return []; }
+}
+/** Resolve a concrete slot to its inferred definition and owner-specific capabilities. */
+export function studioCollectionDefinition(document, definitions, path) {
+  const rule=definitions?.[studioCollectionPattern(path)];
+  if(!rule?.cases || !rule.variants) return rule;
+  const types=new Set(rule.cases.filter(entry=>matchesStudioConditions(document,path,entry.conditions)).flatMap(entry=>entry.types));
+  return {...rule,variants:Object.fromEntries(Object.entries(rule.variants).filter(([type])=>types.has(type)))};
+}
+
+/** Capture data only; presets never contain component implementations. */
+export function createStudioPreset(document, path, id, options) {
+    if (!options?.contract?.contractId || !/^[a-f0-9]{64}$/.test(options.contract.contractId) || !/^[a-z0-9][a-z0-9-]*$/.test(options.projectId))
+        throw Error("A project and compiled contract are required.");
+    const name = options.name?.trim();
+    if (!name || name.length > 100)
+        throw Error("Use a preset name between 1 and 100 characters.");
+    const list = getStudioValue(document, path);
+    if (!Array.isArray(list) || list.filter(item => item?.id === id).length !== 1)
+        throw Error("Select an existing unique item.");
+    const errors = validateStudioState(document, options.contract);
+    if (errors.length)
+        throw Error(errors[0]);
+    const preset = { protocolVersion: 1, id: globalThis.crypto.randomUUID(), projectId: options.projectId, contractId: options.contract.contractId, name, createdAt: new Date().toISOString(), sourcePath: studioCollectionPattern(path), item: JSON.parse(JSON.stringify(list.find(item => item.id === id))) };
+    if (JSON.stringify(preset).length > 1000000)
+        throw Error("Preset exceeds 1 MB.");
+    return preset;
+}
+/** Validate on a clone, then commit only the accepted item to its destination. */
+export function insertStudioPreset(document, path, preset, options) {
+    if (preset?.protocolVersion !== 1 || preset.projectId !== options?.projectId || preset.contractId !== options?.contract?.contractId || !preset.contractId || !preset.item || typeof preset.item !== "object" || Array.isArray(preset.item))
+        throw Error("This preset belongs to a different project or app contract.");
+    const definition = studioCollectionDefinition(document, options.contract.collections, path);
+    if (!definition || !matchesStudioConditions(document, path, definition.conditions))
+        throw Error("Select a compatible collection.");
+    const next = JSON.parse(JSON.stringify(document));
+    let id;
+    if (definition.variants) {
+        const type = preset.item.type;
+        if (typeof type !== "string" || !Object.hasOwn(definition.variants, type))
+            throw Error("This component is not supported by this collection.");
+        id = insertStudioBlock(next, path, type, { ...definition, variants: { ...definition.variants, [type]: { ...definition.variants[type], template: preset.item } } }, options);
+    }
+    else {
+        if (preset.sourcePath !== studioCollectionPattern(path))
+            throw Error("This list uses a different item schema.");
+        const list = getStudioValue(next, path);
+        if (!Array.isArray(list))
+            throw Error("Select an existing collection.");
+        const position = options.position ?? "after";
+        if (!["before", "after", "replace"].includes(position))
+            throw Error("Invalid insertion position.");
+        let index = list.length;
+        if (options.relativeTo !== undefined) {
+            index = list.findIndex(item => item.id === options.relativeTo);
+            if (index < 0 || list.filter(item => item.id === options.relativeTo).length !== 1)
+                throw Error("Select an existing unique item.");
+        }
+        if (position === "replace" && options.relativeTo === undefined)
+            throw Error("Select an item to replace.");
+        if (position !== "replace" && list.length >= (definition.maxItems ?? 1000))
+            throw Error("Collection cannot accept another item.");
+        const item = createStudioItem(preset.item, list, { ...definition, createId: options.createId });
+        id = item.id;
+        if (options.relativeTo !== undefined && position === "after")
+            index++;
+        list.splice(index, position === "replace" ? 1 : 0, item);
+    }
+    const errors = validateStudioState(next, options.contract);
+    if (errors.length)
+        throw Error(errors[0]);
+    const target = getStudioValue(document, path), accepted = getStudioValue(next, path);
+    target.splice(0, target.length, ...accepted);
+    return id;
+}
+
+export {studioMigrationFieldKey,compareStudioContracts,previewStudioMigration} from './migration.js';

package/migration.js

@@ -0,0 +1,235 @@
+import {
+  getStudioValue,
+  expandStudioPath,
+  matchesStudioConditions,
+  validateStudioState,
+} from "./index.js";
+const canonical = (value) =>
+  Array.isArray(value)
+    ? value.map(canonical)
+    : value && typeof value === "object"
+      ? Object.fromEntries(
+          Object.keys(value)
+            .sort()
+            .map((key) => [key, canonical(value[key])]),
+        )
+      : value;
+const clauses = (value) =>
+  value
+    ?.map(canonical)
+    .sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+export function studioMigrationFieldKey(field) {
+  return JSON.stringify([field.path, clauses(field.conditions) ?? null]);
+}
+function fieldShape({ usages, sourceIds, status, ...field }) {
+  return canonical({
+    ...field,
+    ...(field.conditions ? { conditions: clauses(field.conditions) } : {}),
+  });
+}
+function collectionShape({ template, direction, variants, ...rule }) {
+  return canonical({ ...rule, types: Object.keys(variants ?? {}).sort() });
+}
+export function compareStudioContracts(previous, next) {
+  if (previous.contractId && previous.contractId === next.contractId) return [];
+  const changes = [];
+  for (const [scope, oldItems, newItems, key, shape] of [
+    [
+      "field",
+      previous.fields ?? [],
+      next.fields ?? [],
+      studioMigrationFieldKey,
+      fieldShape,
+    ],
+    [
+      "collection",
+      Object.entries(previous.collections ?? {}).map(([path, rule]) => ({
+        path,
+        ...rule,
+      })),
+      Object.entries(next.collections ?? {}).map(([path, rule]) => ({
+        path,
+        ...rule,
+      })),
+      (value) => value.path,
+      collectionShape,
+    ],
+  ]) {
+    const old = new Map(oldItems.map((value) => [key(value), value])),
+      current = new Map(newItems.map((value) => [key(value), value]));
+    for (const [id, before] of old) {
+      const after = current.get(id);
+      if (!after)
+        changes.push({
+          scope,
+          key: id,
+          path: before.path,
+          kind: "removed",
+          before,
+        });
+      else if (JSON.stringify(shape(before)) !== JSON.stringify(shape(after)))
+        changes.push({
+          scope,
+          key: id,
+          path: before.path,
+          kind: "changed",
+          before,
+          after,
+        });
+    }
+    for (const [id, after] of current)
+      if (!old.has(id))
+        changes.push({
+          scope,
+          key: id,
+          path: after.path,
+          kind: "added",
+          after,
+        });
+  }
+  return changes;
+}
+function safeParts(path) {
+  const parts = path.split(".");
+  if (
+    parts.some(
+      (p) =>
+        !p ||
+        ["__proto__", "prototype", "constructor"].includes(p) ||
+        !(p === "*" || p.startsWith("@") || /^[A-Za-z_$][\w$]*$/.test(p)),
+    )
+  )
+    throw Error("Unsafe migration path.");
+  return parts;
+}
+function write(document, path, value) {
+  const parts = safeParts(path);
+  let owner = document;
+  for (const part of parts.slice(0, -1)) {
+    if (part.startsWith("@")) {
+      if (!Array.isArray(owner))
+        throw Error("Destination collection does not exist.");
+      const id = decodeURIComponent(part.slice(1));
+      if (owner.filter((item) => item?.id === id).length !== 1)
+        throw Error("Destination item does not exist uniquely.");
+      owner = owner.find((item) => item?.id === id);
+    } else {
+      if (!owner || typeof owner !== "object" || Array.isArray(owner))
+        throw Error("Destination parent is incompatible.");
+      owner = owner[part] ??= {};
+    }
+  }
+  const key = parts.at(-1);
+  if (
+    key.startsWith("@") ||
+    key === "*" ||
+    !owner ||
+    typeof owner !== "object" ||
+    Array.isArray(owner)
+  )
+    throw Error("Select a field destination.");
+  owner[key] = structuredClone(value);
+}
+function convert(value, conversion) {
+  if (conversion === "copy") return structuredClone(value);
+  if (
+    conversion === "text" &&
+    ["string", "number", "boolean"].includes(typeof value)
+  )
+    return String(value);
+  if (
+    conversion === "number" &&
+    (typeof value === "number" ||
+      (typeof value === "string" && value.trim() !== ""))
+  ) {
+    const number = Number(value);
+    if (Number.isFinite(number)) return number;
+  }
+  if (
+    conversion === "boolean" &&
+    (value === true || value === false || value === "true" || value === "false")
+  )
+    return value === true || value === "true";
+  throw Error("The value cannot be converted using the selected conversion.");
+}
+/** Pure preview: original documents and archived content are never mutated. */
+export function previewStudioMigration(
+  source,
+  document,
+  previous,
+  next,
+  mappings = [],
+) {
+  const candidate = structuredClone(document),
+    errors = [],
+    changes = [],
+    written = new Set();
+  const old = new Map(
+      previous.fields.map((field) => [studioMigrationFieldKey(field), field]),
+    ),
+    current = new Map(
+      next.fields.map((field) => [studioMigrationFieldKey(field), field]),
+    );
+  for (const mapping of mappings) {
+    try {
+      const from = old.get(mapping.from),
+        to = current.get(mapping.to);
+      if (!from || !to)
+        throw Error("Choose fields from the selected contracts.");
+      safeParts(from.path);
+      safeParts(to.path);
+      if (
+        (from.path.match(/\*/g) ?? []).length !==
+        (to.path.match(/\*/g) ?? []).length
+      )
+        throw Error(
+          "List nesting differs; an explicit structural migration is required.",
+        );
+      const conversion = mapping.conversion ?? "copy";
+      if (conversion === "copy" && from.type !== to.type)
+        throw Error("Different field types require an explicit conversion.");
+      if (
+        conversion !== "copy" &&
+        to.type !==
+          { text: "text", number: "number", boolean: "boolean" }[conversion]
+      )
+        throw Error("Conversion does not match the destination type.");
+      let matched = 0;
+      for (const path of expandStudioPath(source, from.path)) {
+        if (!matchesStudioConditions(source, path, from.conditions)) continue;
+        const value = getStudioValue(source, path);
+        if (value === undefined) continue;
+        const wildcards = path
+          .split(".")
+          .filter((_, index) => from.path.split(".")[index] === "*");
+        let i = 0;
+        const target = to.path
+          .split(".")
+          .map((part) => (part === "*" ? wildcards[i++] : part))
+          .join(".");
+        if (!matchesStudioConditions(candidate, target, to.conditions))
+          continue;
+        if (written.has(target))
+          throw Error("Multiple mappings write to the same destination.");
+        const after = convert(value, conversion),
+          before = getStudioValue(candidate, target);
+        write(candidate, target, after);
+        written.add(target);
+        matched++;
+        if (JSON.stringify(before) !== JSON.stringify(after))
+          changes.push({ from: path, to: target, before, after });
+      }
+      if (!matched)
+        throw Error("No matching source values or destination owners.");
+    } catch (error) {
+      errors.push(error.message);
+    }
+  }
+  errors.push(...validateStudioState(candidate, next));
+  return {
+    document: candidate,
+    changes,
+    errors: [...new Set(errors)],
+    valid: errors.length === 0,
+  };
+}

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@byamoah/studio-state",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-beta.0",
+  "type": "module",
+  "description": "Typed Studio state context and runtime contract validation",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./react": {
+      "types": "./react.d.ts",
+      "default": "./react.js"
+    },
+    "./delivery": {
+      "types": "./delivery.d.ts",
+      "default": "./delivery.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "*.js",
+    "*.d.ts",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/KBismark/studio.git",
+    "directory": "packages/state"
+  },
+  "bugs": {
+    "url": "https://github.com/KBismark/studio/issues"
+  },
+  "license": "Apache-2.0"
+}