@arken/seer-protocol 0.1.1 → 0.1.2

package/skill/skill.router.ts

@@ -0,0 +1,201 @@
+import { z as zod } from 'zod';
+import { initTRPC, inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '../../util/rpc';
+import type { RouterContext } from '../../types';
+import {
+  Skill,
+  SkillMod,
+  SkillClassification,
+  SkillCondition,
+  SkillStatusEffect,
+  SkillTree,
+  SkillTreeNode,
+} from './skill.schema';
+import { Query } from '../../schema';
+
+export const z = zod;
+export const t = initTRPC.context<RouterContext>().create();
+export const router = t.router;
+export const procedure = t.procedure;
+
+export const createRouter = () =>
+  router({
+    // Skill Procedures
+    getSkill: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkill as any)(input, ctx)),
+
+    createSkill: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: Skill.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkill as any)(input, ctx)),
+
+    updateSkill: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: Skill.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkill as any)(input, ctx)),
+
+    deleteSkill: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkill as any)(input, ctx)),
+
+    // SkillMod Procedures
+    getSkillMod: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillMod as any)(input, ctx)),
+
+    createSkillMod: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: SkillMod.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillMod as any)(input, ctx)),
+
+    updateSkillMod: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: SkillMod.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillMod as any)(input, ctx)),
+
+    deleteSkillMod: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillMod as any)(input, ctx)),
+
+    // SkillClassification Procedures
+    getSkillClassification: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillClassification as any)(input, ctx)),
+
+    createSkillClassification: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: SkillClassification.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillClassification as any)(input, ctx)),
+
+    updateSkillClassification: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: SkillClassification.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillClassification as any)(input, ctx)),
+
+    deleteSkillClassification: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillClassification as any)(input, ctx)),
+
+    // SkillCondition Procedures
+    getSkillCondition: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillCondition as any)(input, ctx)),
+
+    createSkillCondition: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: SkillCondition.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillCondition as any)(input, ctx)),
+
+    updateSkillCondition: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: SkillCondition.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillCondition as any)(input, ctx)),
+
+    deleteSkillCondition: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillCondition as any)(input, ctx)),
+
+    // SkillStatusEffect Procedures
+    getSkillStatusEffect: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillStatusEffect as any)(input, ctx)),
+
+    createSkillStatusEffect: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: SkillStatusEffect.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillStatusEffect as any)(input, ctx)),
+
+    updateSkillStatusEffect: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: SkillStatusEffect.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillStatusEffect as any)(input, ctx)),
+
+    deleteSkillStatusEffect: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillStatusEffect as any)(input, ctx)),
+
+    // SkillTree Procedures
+    getSkillTree: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillTree as any)(input, ctx)),
+
+    createSkillTree: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: SkillTree.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillTree as any)(input, ctx)),
+
+    updateSkillTree: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: SkillTree.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillTree as any)(input, ctx)),
+
+    deleteSkillTree: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillTree as any)(input, ctx)),
+
+    // SkillTreeNode Procedures
+    getSkillTreeNode: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillTreeNode as any)(input, ctx)),
+
+    createSkillTreeNode: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: SkillTreeNode.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillTreeNode as any)(input, ctx)),
+
+    updateSkillTreeNode: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: SkillTreeNode.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillTreeNode as any)(input, ctx)),
+
+    deleteSkillTreeNode: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillTreeNode as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/skill/skill.schema.ts

@@ -0,0 +1,40 @@
+import { z, ObjectId, Entity } from '../../schema';
+
+export const Skill = Entity.merge(
+  z.object({
+    name: z.string().min(1),
+    description: z.string().min(1).optional(),
+    type: z.enum(['attack', 'defense', 'utility']),
+    cooldown: z.number().min(0).optional(),
+    power: z.number().min(0).optional(),
+  })
+);
+
+export const SkillEffect = Entity.merge(
+  z.object({
+    skillId: ObjectId, // Reference to the associated Skill
+    effectType: z.enum(['damage', 'heal', 'buff', 'debuff']),
+    magnitude: z.number().min(0),
+    duration: z.number().min(0).optional(),
+  })
+);
+
+export const SkillRequirement = Entity.merge(
+  z.object({
+    skillId: ObjectId, // Reference to the associated Skill
+    levelRequired: z.number().min(1),
+    previousSkillId: ObjectId.optional(), // Reference to a prerequisite skill
+  })
+);
+
+export const SkillMod = Entity.merge(z.object({}));
+
+export const SkillClassification = Entity.merge(z.object({}));
+
+export const SkillCondition = Entity.merge(z.object({}));
+
+export const SkillStatusEffect = Entity.merge(z.object({}));
+
+export const SkillTree = Entity.merge(z.object({}));
+
+export const SkillTreeNode = Entity.merge(z.object({}));

package/skill/skill.types.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import * as schema from './skill.schema';
+import { Document, Model } from '../../util/mongo';
+
+export type * from './skill.router';
+export type * from './skill.service';
+export type { RouterContext } from '../../types';
+
+export type Skill = z.infer<typeof schema.Skill>;
+export type SkillMod = z.infer<typeof schema.SkillMod>;
+export type SkillClassification = z.infer<typeof schema.SkillClassification>;
+export type SkillCondition = z.infer<typeof schema.SkillCondition>;
+export type SkillStatusEffect = z.infer<typeof schema.SkillStatusEffect>;
+export type SkillTree = z.infer<typeof schema.SkillTree>;
+export type SkillTreeNode = z.infer<typeof schema.SkillTreeNode>;
+
+export type SkillDocument = Skill & Document;
+export type SkillModDocument = SkillMod & Document;
+export type SkillClassificationDocument = SkillClassification & Document;
+export type SkillConditionDocument = SkillCondition & Document;
+export type SkillStatusEffectDocument = SkillStatusEffect & Document;
+export type SkillTreeDocument = SkillTree & Document;
+export type SkillTreeNodeDocument = SkillTreeNode & Document;
+
+export type Mappings = {
+  Skill: Model<SkillDocument>;
+  SkillMod: Model<SkillModDocument>;
+  SkillClassification: Model<SkillClassificationDocument>;
+  SkillCondition: Model<SkillConditionDocument>;
+  SkillStatusEffect: Model<SkillStatusEffectDocument>;
+  SkillTree: Model<SkillTreeDocument>;
+  SkillTreeNode: Model<SkillTreeNodeDocument>;
+};

package/trek/trek.models.ts

@@ -1 +1 @@
-import { z, ObjectId, Entity } from '@arken/schema';
+import { z, ObjectId, Entity } from '@arken/node/schema';

package/trek/trek.router.ts

@@ -2,7 +2,7 @@
 
 import { z as zod } from 'zod';
 import { initTRPC } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '@arken/rpc';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
 import type { inferRouterOutputs, inferRouterInputs } from '@trpc/server';
 import type { RouterContext } from '../../types';
 

package/trek/trek.schema.ts

@@ -1 +1 @@
-import { z, ObjectId, Entity } from '@arken/schema';
+import { z, ObjectId, Entity } from '@arken/node/schema';

package/trek/trek.types.ts

@@ -1 +1 @@
-import { z, ObjectId, Entity } from '@arken/schema';
+import { z, ObjectId, Entity } from '@arken/node/schema';

package/types.ts

@@ -1,10 +1,32 @@
+
+// arken/packages/seer/protocol/types.ts
+//
 import * as Arken from '@arken/node';
 import { Router, RouterInput, RouterOutput } from './router';
-import * as Evolution from './modules/evolution';
-import * as Infinite from './modules/infinite';
-import * as Oasis from './modules/oasis';
-import * as Trek from './modules/trek';
-import type * as Types from './types';
+
+
+// Imports
+import * as Area from './area';
+import * as Asset from './asset';
+import * as Chain from './chain';
+import * as Character from './character';
+import * as Chat from './chat';
+import * as Collection from './collection';
+import * as Core from './core';
+import * as Game from './game';
+import * as Interface from './interface';
+import * as Item from './item';
+import * as Job from './job';
+import * as Market from './market';
+import * as Product from './product';
+import * as Profile from './profile';
+import * as Raffle from './raffle';
+import * as Skill from './skill';
+import * as Video from './video';
+import * as Evolution from './evolution';
+import * as Infinite from './infinite';
+import * as Oasis from './oasis';
+import * as Trek from './trek';
 
 export type { Router, RouterInput, RouterOutput };
 
@@ -104,3 +126,148 @@ export interface Client {
 export interface ServiceContext {
   client: Client;
 }
+
+
+import { createRouter } from './router';
+
+export * as util from './util';
+
+export type * as Schema from './schema';
+
+export type Router = ReturnType<typeof createRouter>;
+
+export type ApplicationServiceType = Partial<{
+  Area: Area.Service;
+  Asset: Asset.Service;
+  Chain: Chain.Service;
+  Character: Character.Service;
+  Chat: Chat.Service;
+  Collection: Collection.Service;
+  Core: Core.Service;
+  Game: Game.Service;
+  Interface: Interface.Service;
+  Item: Item.Service;
+  Job: Job.Service;
+  Market: Market.Service;
+  Product: Product.Service;
+  Profile: Profile.Service;
+  Raffle: Raffle.Service;
+  Skill: Skill.Service;
+  Video: Video.Service;
+}>;
+
+export type ApplicationModelType = Partial<
+  Area.Types.Mappings &
+    Asset.Types.Mappings &
+    Chain.Types.Mappings &
+    Character.Types.Mappings &
+    Chat.Types.Mappings &
+    Collection.Types.Mappings &
+    Core.Types.Mappings &
+    Game.Types.Mappings &
+    Interface.Types.Mappings &
+    Item.Types.Mappings &
+    Job.Types.Mappings &
+    Market.Types.Mappings &
+    Product.Types.Mappings &
+    Profile.Types.Mappings &
+    Raffle.Types.Mappings &
+    Skill.Types.Mappings &
+    Video.Types.Mappings
+>;
+
+export interface Application {
+  model: ApplicationModelType;
+  service: ApplicationServiceType;
+  web3?: any;
+}
+
+export type RouterClient = {
+  socket: any;
+  roles: string[];
+  permissions: any;
+  profile?: Profile.Types.Profile;
+  emit: any;
+};
+
+export type RouterContext = {
+  app: Application;
+  client?: RouterClient;
+  profile?: Profile.Types.Profile;
+};
+
+export interface Signature {
+  hash?: string;
+  address?: string;
+}
+
+export type Position = {
+  x: number;
+  y: number;
+  z?: number;
+};
+
+export type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+
+export type PatchOp =
+  | { op: 'set'; key: string; value: any }
+  | { op: 'unset'; key: string }
+  | { op: 'inc'; key: string; value: number }
+  | { op: 'push'; key: string; value: any }
+  | { op: 'merge'; key: string; value: Record<string, any> };
+
+export type EntityPatch = {
+  entityType: string; // allow any string
+  entityId: string;
+  baseVersion?: number;
+  ops: PatchOp[];
+  claimable?: boolean;
+};
+
+export type GameObjectDef = {
+  id: string;
+  type: string; // allow any string
+  name: string;
+  position: { x: number; y: number };
+  radius?: number; // interaction distance
+  tags?: string[];
+  meta?: Record<string, any>;
+};
+
+export type Requirement =
+  | { kind: 'exists'; key: string }
+  | { kind: 'touchedObject'; objectId: string; afterKey?: string; writeKey: string };
+
+// Generic effects (can be positive or negative)
+export type Effect =
+  | { kind: 'item.grant'; itemKey: string; quantity?: number }
+  | { kind: 'currency.grant'; key: string; amount: number } // negative amount allowed
+  | { kind: 'reputation.delta'; npcId: string; amount: number } // negative allowed
+  | { kind: 'state.patch'; patch: EntityPatch } // generic patch against any entityType
+  | { kind: 'ui.unlock'; uiKey: string } // optional, future
+  | { kind: 'emit'; eventType: string; payload?: any }; // optional, future
+
+export type QuestDef = {
+  id: string;
+  metaverseId: string;
+  name: string;
+
+  // Requirements can be checked shard-side (for anti-cheat) AND client-side (for UI state)
+  requirements: Requirement[];
+
+  // Effects are applied on completion/claim (seer-side)
+  effects: Effect[];
+
+  // keys shard will write (auditing + permissions)
+  writes?: string[];
+};
+
+type QuestCompleteOp = {
+  kind: 'quest.complete';
+  id: string;
+  ts: number;
+  questId: string;
+  metaverseId: string;
+  evidence?: Record<string, any>;
+  effects?: any[]; // can include effect refs for replay/debug
+};

package/video/index.ts

@@ -0,0 +1,5 @@
+export * as Types from './video.types';
+export * as Models from './video.models';
+export * as Schemas from './video.schema';
+export * from './video.router';
+export * from './video.service';

package/video/video.models.ts

@@ -0,0 +1,25 @@
+import * as mongo from '../../util/mongo';
+import type * as Types from './video.types';
+
+export const Video = mongo.createModel<Types.VideoDocument>('Video', {
+  youtubeId: { type: String, unique: true, required: true },
+  url: { type: String, required: true },
+});
+
+export const VideoParticipant = mongo.createModel<Types.VideoParticipantDocument>('VideoParticipant', {
+  profileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: true },
+});
+
+export const VideoDialogue = mongo.createModel<Types.VideoDialogueDocument>('VideoDialogue', {
+  participantId: { type: mongo.Schema.Types.ObjectId, ref: 'VideoParticipant', required: true },
+  text: { type: String, required: true },
+  timestamp: { type: String, required: true },
+});
+
+export const VideoTranscript = mongo.createModel<Types.VideoTranscriptDocument>('VideoTranscript', {
+  videoId: { type: mongo.Schema.Types.ObjectId, ref: 'Video', required: true },
+  // transcript: { type: [mongo.Schema.Types.Mixed], required: true },
+  summary: { type: String, optional: true },
+});
+
+export const VideoScene = mongo.createModel<Types.VideoSceneDocument>('VideoScene', {});

package/video/video.router.ts

@@ -0,0 +1,143 @@
+import { z as zod } from 'zod';
+import { initTRPC, inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '../../util/rpc';
+import type { RouterContext } from '../../types';
+import { Video, VideoParticipant, VideoDialogue, VideoTranscript, VideoScene } from './video.schema';
+import { Query } from '../../schema'; // Assuming the Query schema is located in '../../schema'
+
+export const z = zod;
+export const t = initTRPC.context<RouterContext>().create();
+export const router = t.router;
+export const procedure = t.procedure;
+
+export const createRouter = () =>
+  router({
+    // Video endpoints
+    getVideo: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Video.getVideo as any)(input, ctx)),
+
+    createVideo: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: Video.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.createVideo as any)(input, ctx)),
+
+    updateVideo: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: Video.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.updateVideo as any)(input, ctx)),
+
+    deleteVideo: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.deleteVideo as any)(input, ctx)),
+
+    // Video Participant endpoints
+    getVideoParticipant: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Video.getVideoParticipant as any)(input, ctx)),
+
+    createVideoParticipant: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: VideoParticipant.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.createVideoParticipant as any)(input, ctx)),
+
+    updateVideoParticipant: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: VideoParticipant.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.updateVideoParticipant as any)(input, ctx)),
+
+    deleteVideoParticipant: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.deleteVideoParticipant as any)(input, ctx)),
+
+    // Video Dialogue endpoints
+    getVideoDialogue: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Video.getVideoDialogue as any)(input, ctx)),
+
+    createVideoDialogue: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: VideoDialogue.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.createVideoDialogue as any)(input, ctx)),
+
+    updateVideoDialogue: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: VideoDialogue.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.updateVideoDialogue as any)(input, ctx)),
+
+    deleteVideoDialogue: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.deleteVideoDialogue as any)(input, ctx)),
+
+    // Video Transcript endpoints
+    getVideoTranscript: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Video.getVideoTranscript as any)(input, ctx)),
+
+    createVideoTranscript: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: VideoTranscript.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.createVideoTranscript as any)(input, ctx)),
+
+    updateVideoTranscript: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: VideoTranscript.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.updateVideoTranscript as any)(input, ctx)),
+
+    deleteVideoTranscript: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.deleteVideoTranscript as any)(input, ctx)),
+
+    // Video Scene endpoints
+    getVideoScene: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Video.getVideoScene as any)(input, ctx)),
+
+    createVideoScene: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: VideoScene.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.createVideoScene as any)(input, ctx)),
+
+    updateVideoScene: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: VideoScene.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.updateVideoScene as any)(input, ctx)),
+
+    deleteVideoScene: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.deleteVideoScene as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;