timeback 0.1.0 → 0.1.2

package/dist/index.js

@@ -358,19 +358,255 @@ var SubjectTrackInput = z4.object({
   targetCourseId: z4.string(),
   metadata: z4.record(z4.string(), z4.unknown()).optional()
 });
+// ../types/src/zod/qti.ts
+import { z as z5 } from "zod/v4";
+var QtiAssessmentItemType = z5.enum([
+  "choice",
+  "text-entry",
+  "extended-text",
+  "inline-choice",
+  "match",
+  "order",
+  "associate",
+  "select-point",
+  "graphic-order",
+  "graphic-associate",
+  "graphic-gap-match",
+  "hotspot",
+  "hottext",
+  "slider",
+  "drawing",
+  "media",
+  "upload"
+]);
+var QtiCardinality = z5.enum(["single", "multiple", "ordered", "record"]);
+var QtiBaseType = z5.enum([
+  "identifier",
+  "boolean",
+  "integer",
+  "float",
+  "string",
+  "point",
+  "pair",
+  "directedPair",
+  "duration",
+  "file",
+  "uri"
+]);
+var QtiDifficulty = z5.enum(["easy", "medium", "hard"]);
+var QtiNavigationMode = z5.enum(["linear", "nonlinear"]);
+var QtiSubmissionMode = z5.enum(["individual", "simultaneous"]);
+var QtiShowHide = z5.enum(["show", "hide"]);
+var QtiValidationSchema = z5.enum(["test", "item", "stimulus"]);
+var QtiFeedbackType = z5.enum(["QUESTION", "LESSON"]);
+var QtiCorrectResponse = z5.object({
+  value: z5.array(z5.string())
+}).strict();
+var QtiResponseDeclaration = z5.object({
+  identifier: z5.string().min(1),
+  cardinality: QtiCardinality,
+  baseType: QtiBaseType.optional(),
+  correctResponse: QtiCorrectResponse
+}).strict();
+var QtiOutcomeDeclaration = z5.object({
+  identifier: z5.string().min(1),
+  cardinality: QtiCardinality,
+  baseType: QtiBaseType.optional()
+}).strict();
+var QtiTestOutcomeDeclaration = z5.object({
+  identifier: z5.string().min(1),
+  cardinality: QtiCardinality.optional(),
+  baseType: QtiBaseType,
+  normalMaximum: z5.number().optional(),
+  normalMinimum: z5.number().optional(),
+  defaultValue: z5.object({
+    value: z5.unknown().optional()
+  }).strict().optional()
+}).strict();
+var QtiInlineFeedback = z5.object({
+  outcomeIdentifier: z5.string().min(1),
+  variableIdentifier: z5.string().min(1)
+}).strict();
+var QtiResponseProcessing = z5.object({
+  templateType: z5.enum(["match_correct", "map_response"]),
+  responseDeclarationIdentifier: z5.string().min(1),
+  outcomeIdentifier: z5.string().min(1),
+  correctResponseIdentifier: z5.string().min(1),
+  incorrectResponseIdentifier: z5.string().min(1),
+  inlineFeedback: QtiInlineFeedback.optional()
+}).strict();
+var QtiLearningObjectiveSet = z5.object({
+  source: z5.string().min(1),
+  learningObjectiveIds: z5.array(z5.string())
+}).strict();
+var QtiItemMetadata = z5.object({
+  subject: z5.string().optional(),
+  grade: TimebackGrade.optional(),
+  difficulty: QtiDifficulty.optional(),
+  learningObjectiveSet: z5.array(QtiLearningObjectiveSet).optional()
+}).strict();
+var QtiModalFeedback = z5.object({
+  outcomeIdentifier: z5.string().min(1),
+  identifier: z5.string().min(1),
+  showHide: QtiShowHide,
+  content: z5.string(),
+  title: z5.string()
+}).strict();
+var QtiFeedbackInline = z5.object({
+  outcomeIdentifier: z5.string().min(1),
+  identifier: z5.string().min(1),
+  showHide: QtiShowHide,
+  content: z5.string(),
+  class: z5.array(z5.string())
+}).strict();
+var QtiFeedbackBlock = z5.object({
+  outcomeIdentifier: z5.string().min(1),
+  identifier: z5.string().min(1),
+  showHide: QtiShowHide,
+  content: z5.string(),
+  class: z5.array(z5.string())
+}).strict();
+var QtiStylesheet = z5.object({
+  href: z5.string().min(1),
+  type: z5.string().min(1)
+}).strict();
+var QtiCatalogInfo = z5.object({
+  id: z5.string().min(1),
+  support: z5.string(),
+  content: z5.string()
+}).strict();
+var QtiAssessmentItemCreateInput = z5.object({
+  identifier: z5.string().min(1),
+  title: z5.string().min(1),
+  type: QtiAssessmentItemType,
+  qtiVersion: z5.string().optional(),
+  timeDependent: z5.boolean().optional(),
+  adaptive: z5.boolean().optional(),
+  responseDeclarations: z5.array(QtiResponseDeclaration).optional(),
+  outcomeDeclarations: z5.array(QtiOutcomeDeclaration).optional(),
+  responseProcessing: QtiResponseProcessing.optional(),
+  metadata: QtiItemMetadata.optional(),
+  modalFeedback: z5.array(QtiModalFeedback).optional(),
+  feedbackInline: z5.array(QtiFeedbackInline).optional(),
+  feedbackBlock: z5.array(QtiFeedbackBlock).optional()
+}).strict();
+var QtiAssessmentItemUpdateInput = z5.object({
+  title: z5.string().min(1),
+  type: QtiAssessmentItemType,
+  qtiVersion: z5.string().optional(),
+  timeDependent: z5.boolean().optional(),
+  adaptive: z5.boolean().optional(),
+  responseDeclarations: z5.array(QtiResponseDeclaration).optional(),
+  outcomeDeclarations: z5.array(QtiOutcomeDeclaration).optional(),
+  responseProcessing: QtiResponseProcessing.optional(),
+  metadata: QtiItemMetadata.optional(),
+  modalFeedback: z5.array(QtiModalFeedback).optional(),
+  feedbackInline: z5.array(QtiFeedbackInline).optional(),
+  feedbackBlock: z5.array(QtiFeedbackBlock).optional(),
+  rawXml: z5.string(),
+  content: z5.record(z5.string(), z5.unknown())
+}).strict();
+var QtiAssessmentItemProcessResponseInput = z5.object({
+  response: z5.union([z5.string(), z5.array(z5.string())])
+}).strict();
+var QtiAssessmentItemRef = z5.object({
+  identifier: z5.string().min(1),
+  href: z5.union([z5.string(), z5.array(z5.string()), z5.array(z5.array(z5.string()))]).optional(),
+  sequence: z5.number().optional()
+}).strict();
+var QtiAssessmentSection = z5.object({
+  identifier: z5.string().min(1),
+  title: z5.string().min(1),
+  visible: z5.boolean(),
+  required: z5.boolean().optional(),
+  fixed: z5.boolean().optional(),
+  sequence: z5.number().optional(),
+  "qti-assessment-item-ref": z5.array(QtiAssessmentItemRef).optional()
+}).strict();
+var QtiTestPart = z5.object({
+  identifier: z5.string().min(1),
+  navigationMode: QtiNavigationMode,
+  submissionMode: QtiSubmissionMode,
+  "qti-assessment-section": z5.union([QtiAssessmentSection, z5.array(QtiAssessmentSection)])
+}).strict();
+var QtiAssessmentTestCreateInput = z5.object({
+  identifier: z5.string().min(1),
+  title: z5.string().min(1),
+  qtiVersion: z5.string().optional(),
+  toolName: z5.string().optional(),
+  toolVersion: z5.string().optional(),
+  timeLimit: z5.number().optional(),
+  maxAttempts: z5.number().optional(),
+  toolsEnabled: z5.record(z5.string(), z5.boolean()).optional(),
+  metadata: z5.record(z5.string(), z5.unknown()).optional(),
+  "qti-test-part": QtiTestPart,
+  "qti-outcome-declaration": z5.array(QtiTestOutcomeDeclaration).optional()
+}).strict();
+var QtiAssessmentTestUpdateInput = z5.object({
+  title: z5.string().min(1),
+  qtiVersion: z5.string().optional(),
+  toolName: z5.string().optional(),
+  toolVersion: z5.string().optional(),
+  timeLimit: z5.number().optional(),
+  maxAttempts: z5.number().optional(),
+  toolsEnabled: z5.record(z5.string(), z5.boolean()).optional(),
+  metadata: z5.record(z5.string(), z5.unknown()).optional(),
+  "qti-test-part": QtiTestPart,
+  "qti-outcome-declaration": z5.array(QtiTestOutcomeDeclaration).optional()
+}).strict();
+var QtiStimulusCreateInput = z5.object({
+  identifier: z5.string().min(1),
+  title: z5.string().min(1),
+  label: z5.string().optional(),
+  language: z5.string().optional(),
+  stylesheet: QtiStylesheet.optional(),
+  content: z5.string(),
+  catalogInfo: z5.array(QtiCatalogInfo).optional(),
+  toolName: z5.string().optional(),
+  toolVersion: z5.string().optional(),
+  metadata: z5.record(z5.string(), z5.unknown()).optional()
+}).strict();
+var QtiStimulusUpdateInput = z5.object({
+  title: z5.string().min(1),
+  label: z5.string().optional(),
+  language: z5.string().optional(),
+  stylesheet: QtiStylesheet.optional(),
+  content: z5.string(),
+  catalogInfo: z5.array(QtiCatalogInfo).optional(),
+  toolName: z5.string().optional(),
+  toolVersion: z5.string().optional(),
+  metadata: z5.record(z5.string(), z5.unknown()).optional()
+}).strict();
+var QtiValidateInput = z5.object({
+  xml: z5.string().optional(),
+  schema: QtiValidationSchema,
+  entityId: z5.string().optional()
+}).strict();
+var QtiValidateBatchInput = z5.object({
+  xml: z5.array(z5.string()),
+  schema: QtiValidationSchema,
+  entityIds: z5.array(z5.string())
+}).strict();
+var QtiLessonFeedbackInput = z5.object({
+  questionId: z5.string().optional(),
+  userId: z5.string().min(1),
+  feedback: z5.string().min(1),
+  lessonId: z5.string().min(1),
+  humanApproved: z5.boolean().optional()
+}).strict();
 // ../internal/cli-infra/src/credentials/store.ts
 import { homedir, platform as platform2 } from "node:os";
 import { join } from "node:path";
 
 // ../internal/cli-infra/src/credentials/schema.ts
-import { z as z5 } from "zod";
-var CredentialsSchema = z5.object({
-  clientId: z5.string().min(1, "Client ID is required"),
-  clientSecret: z5.string().min(1, "Client secret is required"),
-  email: z5.email("Valid email is required").optional()
+import { z as z6 } from "zod";
+var CredentialsSchema = z6.object({
+  clientId: z6.string().min(1, "Client ID is required"),
+  clientSecret: z6.string().min(1, "Client secret is required"),
+  email: z6.email("Valid email is required").optional()
 });
-var ClientIdSchema = z5.string().min(1, "Client ID is required").regex(/^[a-z0-9]+$/, "Client ID must contain only lowercase letters and numbers").length(26, "Client ID must be exactly 26 characters");
-var ClientSecretSchema = z5.string().min(1, "Client secret is required").regex(/^[a-z0-9]+$/, "Client secret must contain only lowercase letters and numbers").max(53, "Client secret must be less than 53 characters");
+var ClientIdSchema = z6.string().min(1, "Client ID is required").regex(/^[a-z0-9]+$/, "Client ID must contain only lowercase letters and numbers").length(26, "Client ID must be exactly 26 characters");
+var ClientSecretSchema = z6.string().min(1, "Client secret is required").regex(/^[a-z0-9]+$/, "Client secret must contain only lowercase letters and numbers").max(53, "Client secret must be less than 53 characters");
 
 // ../internal/cli-infra/src/credentials/store.ts
 function getConfigDir() {
@@ -1036,21 +1272,21 @@ function createIdentityHandlers(params) {
   };
 }
 // src/server/handlers/activity.ts
-import * as z6 from "zod";
-var activityMetricsSchema = z6.object({
-  totalQuestions: z6.number().int().nonnegative().optional(),
-  correctQuestions: z6.number().int().nonnegative().optional(),
-  xpEarned: z6.number().int().nonnegative().optional(),
-  masteredUnits: z6.number().int().nonnegative().optional()
+import * as z7 from "zod";
+var activityMetricsSchema = z7.object({
+  totalQuestions: z7.number().int().nonnegative().optional(),
+  correctQuestions: z7.number().int().nonnegative().optional(),
+  xpEarned: z7.number().int().nonnegative().optional(),
+  masteredUnits: z7.number().int().nonnegative().optional()
 });
-var activityEndPayloadSchema = z6.object({
-  id: z6.string().min(1),
-  name: z6.string().min(1),
-  courseCode: z6.string().min(1),
-  startedAt: z6.iso.datetime(),
-  endedAt: z6.iso.datetime(),
-  elapsedMs: z6.number().int().nonnegative(),
-  pausedMs: z6.number().int().nonnegative(),
+var activityEndPayloadSchema = z7.object({
+  id: z7.string().min(1),
+  name: z7.string().min(1),
+  courseCode: z7.string().min(1),
+  startedAt: z7.iso.datetime(),
+  endedAt: z7.iso.datetime(),
+  elapsedMs: z7.number().int().nonnegative(),
+  pausedMs: z7.number().int().nonnegative(),
   metrics: activityMetricsSchema
 });
 function createActivityHandler(config2) {
@@ -1138,6 +1374,19 @@ async function createServer(config2) {
     }
   };
 }
+function createIdentityServer(config2) {
+  const identity = createIdentityHandlers({
+    env: config2.env,
+    identity: config2.identity
+  });
+  return {
+    config: config2,
+    handle: {
+      identity
+    }
+  };
+}
 export {
-  createServer
+  createServer,
+  createIdentityServer
 };

package/dist/server/adapters/express.d.ts

@@ -7,7 +7,7 @@
  * Uses minimal generic interfaces that work with any framework implementing
  * the Express middleware pattern.
  */
-import type { ExpressLikeHandler, ExpressLikeRouter, TimebackInput } from './types';
+import type { AnyTimebackInput, ExpressLikeHandler, ExpressLikeRouter } from './types';
 /**
  * Convert Timeback instance to Express middleware.
  *
@@ -15,7 +15,9 @@ import type { ExpressLikeHandler, ExpressLikeRouter, TimebackInput } from './typ
  * - `toExpressMiddleware(timeback)`
  * - `toExpressMiddleware(timeback.handle)`
  *
- * @param input - Timeback instance or handlers
+ * Also accepts identity-only instances from `createIdentityServer()`.
+ *
+ * @param input - Timeback instance or handlers (full or identity-only)
  * @returns Express middleware function
  *
  * @example
@@ -32,7 +34,7 @@ import type { ExpressLikeHandler, ExpressLikeRouter, TimebackInput } from './typ
  * app.listen(3000)
  * ```
  */
-export declare function toExpressMiddleware(input: TimebackInput): ExpressLikeHandler;
+export declare function toExpressMiddleware(input: AnyTimebackInput): ExpressLikeHandler;
 /**
  * Mount Timeback routes on an Express router.
  *
@@ -40,7 +42,9 @@ export declare function toExpressMiddleware(input: TimebackInput): ExpressLikeHa
  * - `mountExpressRoutes(timeback, router)`
  * - `mountExpressRoutes(timeback.handle, router)`
  *
- * @param input - Timeback instance or handlers
+ * Also accepts identity-only instances from `createIdentityServer()`.
+ *
+ * @param input - Timeback instance or handlers (full or identity-only)
  * @param router - Express router to mount routes on
  *
  * @example
@@ -58,5 +62,5 @@ export declare function toExpressMiddleware(input: TimebackInput): ExpressLikeHa
  * app.listen(3000)
  * ```
  */
-export declare function mountExpressRoutes(input: TimebackInput, router: ExpressLikeRouter): void;
+export declare function mountExpressRoutes(input: AnyTimebackInput, router: ExpressLikeRouter): void;
 //# sourceMappingURL=express.d.ts.map

package/dist/server/adapters/express.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"express.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/express.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EACX,kBAAkB,EAIlB,iBAAiB,EACjB,aAAa,EACb,MAAM,SAAS,CAAA;AA6FhB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,GAAG,kBAAkB,CA+C5E;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAiDxF"}
+{"version":3,"file":"express.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/express.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EACX,gBAAgB,EAChB,kBAAkB,EAIlB,iBAAiB,EACjB,MAAM,SAAS,CAAA;AA6FhB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,GAAG,kBAAkB,CAqD/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAyD3F"}

package/dist/server/adapters/express.js

@@ -470,6 +470,12 @@ function decodeBase64Url(encoded) {
 function getHandlers(input) {
   return "handle" in input ? input.handle : input;
 }
+function hasActivityHandler(handlers) {
+  return "activity" in handlers;
+}
+function hasUserHandler(handlers) {
+  return "user" in handlers;
+}
 
 // src/server/adapters/express.ts
 function toWebRequest(req) {
@@ -525,8 +531,13 @@ function toExpressMiddleware(input) {
           return Promise.resolve(handle.identity.signOut());
         }
       }
-      if (req.method === "POST") {
-        if (path.endsWith(ROUTES.ACTIVITY)) {
+      if (hasUserHandler(handle)) {
+        if (req.method === "GET" && path.endsWith(ROUTES.USER.ME)) {
+          return handle.user.me(webReq);
+        }
+      }
+      if (hasActivityHandler(handle)) {
+        if (req.method === "POST" && path.endsWith(ROUTES.ACTIVITY)) {
           return handle.activity(webReq);
         }
       }
@@ -557,7 +568,12 @@ function mountExpressRoutes(input, router) {
   router.get(ROUTES.IDENTITY.SIGNIN, createHandler((req) => handle.identity.signIn(req)));
   router.get(ROUTES.IDENTITY.CALLBACK, createHandler((req) => handle.identity.callback(req)));
   router.get(ROUTES.IDENTITY.SIGNOUT, createHandler(() => handle.identity.signOut()));
-  router.post(ROUTES.ACTIVITY, createHandler((req) => handle.activity(req)));
+  if (hasUserHandler(handle)) {
+    router.get(ROUTES.USER.ME, createHandler((req) => handle.user.me(req)));
+  }
+  if (hasActivityHandler(handle)) {
+    router.post(ROUTES.ACTIVITY, createHandler((req) => handle.activity(req)));
+  }
 }
 export {
   toExpressMiddleware,

package/dist/server/adapters/native.d.ts

@@ -4,7 +4,7 @@
  * Universal handler for any runtime that supports the Web Fetch API:
  * Bun, Deno, Cloudflare Workers, Hono, etc.
  */
-import type { NativeHandlerOptions, TimebackInput } from './types';
+import type { AnyTimebackInput, NativeHandlerOptions } from './types';
 /**
  * Create a native Fetch API handler.
  *
@@ -15,7 +15,9 @@ import type { NativeHandlerOptions, TimebackInput } from './types';
  * - `toNativeHandler(timeback)`
  * - `toNativeHandler(timeback.handle)`
  *
- * @param input - Timeback instance or handlers
+ * Also accepts identity-only instances from `createIdentityServer()`.
+ *
+ * @param input - Timeback instance or handlers (full or identity-only)
  * @returns Universal request handler
  *
  * @example
@@ -41,5 +43,5 @@ import type { NativeHandlerOptions, TimebackInput } from './types';
  * Deno.serve(handler)
  * ```
  */
-export declare function toNativeHandler(input: TimebackInput | NativeHandlerOptions): (req: Request) => Promise<Response>;
+export declare function toNativeHandler(input: AnyTimebackInput | NativeHandlerOptions): (req: Request) => Promise<Response>;
 //# sourceMappingURL=native.d.ts.map

package/dist/server/adapters/native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/native.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAYlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,aAAa,GAAG,oBAAoB,GACzC,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAyCrC"}
+{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/native.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAYrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,gBAAgB,GAAG,oBAAoB,GAC5C,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CA2CrC"}

package/dist/server/adapters/native.js

@@ -470,6 +470,12 @@ function decodeBase64Url(encoded) {
 function getHandlers(input) {
   return "handle" in input ? input.handle : input;
 }
+function hasActivityHandler(handlers) {
+  return "activity" in handlers;
+}
+function hasUserHandler(handlers) {
+  return "user" in handlers;
+}
 
 // src/server/adapters/native.ts
 function isNativeHandlerOptions(v) {
@@ -492,12 +498,14 @@ function toNativeHandler(input) {
       if (path.endsWith(ROUTES.IDENTITY.SIGNOUT)) {
         return Promise.resolve(handle.identity.signOut());
       }
-      if (path.endsWith(ROUTES.USER.ME)) {
+    }
+    if (hasUserHandler(handle)) {
+      if (method === "GET" && path.endsWith(ROUTES.USER.ME)) {
         return handle.user.me(req);
       }
     }
-    if (method === "POST") {
-      if (path.endsWith(ROUTES.ACTIVITY)) {
+    if (hasActivityHandler(handle)) {
+      if (method === "POST" && path.endsWith(ROUTES.ACTIVITY)) {
         return handle.activity(req);
       }
     }

package/dist/server/adapters/nextjs.d.ts

@@ -3,7 +3,7 @@
  *
  * Adapts Timeback handlers for Next.js App Router.
  */
-import type { NextjsHandlers, TimebackInput } from './types';
+import type { AnyTimebackInput, NextjsHandlers } from './types';
 /**
  * Convert Timeback instance to Next.js App Router handlers.
  *
@@ -14,7 +14,9 @@ import type { NextjsHandlers, TimebackInput } from './types';
  * - `toNextjsHandler(timeback)`
  * - `toNextjsHandler(timeback.handle)`
  *
- * @param input - Timeback instance or handlers
+ * Also accepts identity-only instances from `createIdentityServer()`.
+ *
+ * @param input - Timeback instance or handlers (full or identity-only)
  * @returns Object with HTTP method handlers for Next.js App Router
  *
  * @example
@@ -26,5 +28,5 @@ import type { NextjsHandlers, TimebackInput } from './types';
  * export const { GET, POST } = toNextjsHandler(timeback)
  * ```
  */
-export declare function toNextjsHandler(input: TimebackInput): NextjsHandlers;
+export declare function toNextjsHandler(input: AnyTimebackInput): NextjsHandlers;
 //# sourceMappingURL=nextjs.d.ts.map

package/dist/server/adapters/nextjs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nextjs.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/nextjs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,cAAc,CAUpE"}
+{"version":3,"file":"nextjs.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/nextjs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE/D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,gBAAgB,GAAG,cAAc,CAUvE"}

package/dist/server/adapters/nextjs.js

@@ -470,6 +470,12 @@ function decodeBase64Url(encoded) {
 function getHandlers(input) {
   return "handle" in input ? input.handle : input;
 }
+function hasActivityHandler(handlers) {
+  return "activity" in handlers;
+}
+function hasUserHandler(handlers) {
+  return "user" in handlers;
+}
 
 // src/server/adapters/native.ts
 function isNativeHandlerOptions(v) {
@@ -492,12 +498,14 @@ function toNativeHandler(input) {
       if (path.endsWith(ROUTES.IDENTITY.SIGNOUT)) {
         return Promise.resolve(handle.identity.signOut());
       }
-      if (path.endsWith(ROUTES.USER.ME)) {
+    }
+    if (hasUserHandler(handle)) {
+      if (method === "GET" && path.endsWith(ROUTES.USER.ME)) {
         return handle.user.me(req);
       }
     }
-    if (method === "POST") {
-      if (path.endsWith(ROUTES.ACTIVITY)) {
+    if (hasActivityHandler(handle)) {
+      if (method === "POST" && path.endsWith(ROUTES.ACTIVITY)) {
         return handle.activity(req);
       }
     }

package/dist/server/adapters/nuxt.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Nuxt Adapter
+ *
+ * Adapts Timeback handlers for Nuxt 3.
+ * Supports both middleware-based (recommended) and route-based approaches.
+ *
+ * This adapter does NOT import h3 or nuxt - it uses minimal interfaces
+ * that are compatible with H3's event structure.
+ */
+import type { AnyTimebackInput, NuxtHandlerOptions, NuxtHandlers, NuxtLikeEvent } from './types';
+/**
+ * Nuxt server middleware handler for Timeback.
+ *
+ * This is the **recommended** approach for Nuxt 3 integration.
+ * It intercepts requests at the middleware level before they reach route handlers.
+ *
+ * Returns a Response if the request matches a Timeback route, or undefined
+ * to let the request continue to other handlers.
+ *
+ * @param options - Handler options
+ * @returns Response from Timeback or undefined to continue
+ *
+ * @example
+ * ```typescript
+ * // server/middleware/timeback.ts
+ * import { timeback } from '~/lib/timeback'
+ * import { nuxtHandler } from 'timeback/nuxt'
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const response = await nuxtHandler({
+ *     timeback,
+ *     event,
+ *   })
+ *
+ *   if (response) {
+ *     return response
+ *   }
+ * })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // server/middleware/timeback.ts - with custom callback path
+ * import { timeback } from '~/lib/timeback'
+ * import { nuxtHandler } from 'timeback/nuxt'
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const response = await nuxtHandler({
+ *     timeback,
+ *     event,
+ *     callbackPath: '/api/auth/sso/callback/timeback',
+ *   })
+ *
+ *   if (response) {
+ *     return response
+ *   }
+ * })
+ * ```
+ */
+export declare function nuxtHandler<TEvent extends NuxtLikeEvent>(options: NuxtHandlerOptions<TEvent>): Promise<Response | undefined>;
+/**
+ * Convert Timeback instance to Nuxt route handlers.
+ *
+ * This is an **alternative** approach using Nuxt's catch-all route handlers.
+ * Use this if you prefer explicit route files over middleware.
+ *
+ * Accepts either the full Timeback instance or just the handlers:
+ * - `toNuxtHandler(timeback)`
+ * - `toNuxtHandler(timeback.handle)`
+ *
+ * Also accepts identity-only instances from `createIdentityServer()`.
+ *
+ * @param input - Timeback instance or handlers (full or identity-only), or options object
+ * @returns Object with HTTP method handlers for Nuxt
+ *
+ * @example
+ * ```typescript
+ * // server/api/timeback/[...timeback].ts
+ * import { timeback } from '~/lib/timeback'
+ * import { toNuxtHandler } from 'timeback/nuxt'
+ *
+ * const handlers = toNuxtHandler(timeback)
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const method = event.request?.method ?? event.node?.req?.method ?? 'GET'
+ *   const handler = handlers[method as keyof typeof handlers]
+ *   if (handler) {
+ *     return handler(event)
+ *   }
+ *   return new Response('Method not allowed', { status: 405 })
+ * })
+ * ```
+ */
+export declare function toNuxtHandler(input: AnyTimebackInput | {
+    timeback: AnyTimebackInput;
+    callbackPath?: string;
+}): NuxtHandlers;
+//# sourceMappingURL=nuxt.d.ts.map

package/dist/server/adapters/nuxt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nuxt.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/nuxt.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EACX,gBAAgB,EAEhB,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,MAAM,SAAS,CAAA;AAsNhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAsB,WAAW,CAAC,MAAM,SAAS,aAAa,EAC7D,OAAO,EAAE,kBAAkB,CAAC,MAAM,CAAC,GACjC,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CA+C/B;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAC5B,KAAK,EAAE,gBAAgB,GAAG;IAAE,QAAQ,EAAE,gBAAgB,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7E,YAAY,CAyDd"}